'use strict'; var React = require('react'); var ReactDOM__default = require('react-dom'); function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } function _interopNamespace(e) { if (e && e.__esModule) return e; var n = Object.create(null); if (e) { Object.keys(e).forEach(function (k) { if (k !== 'default') { var d = Object.getOwnPropertyDescriptor(e, k); Object.defineProperty(n, k, d.get ? d : { enumerable: true, get: function () { return e[k]; } }); } }); } n["default"] = e; return Object.freeze(n); } var React__default = /*#__PURE__*/_interopDefaultLegacy(React); var React__namespace = /*#__PURE__*/_interopNamespace(React); var ReactDOM__default__default = /*#__PURE__*/_interopDefaultLegacy(ReactDOM__default); var classnames = {exports: {}}; (function (module) { /* global define */ (function () { var hasOwn = {}.hasOwnProperty; function classNames() { var classes = []; for (var i = 0; i < arguments.length; i++) { var arg = arguments[i]; if (!arg) continue; var argType = typeof arg; if (argType === 'string' || argType === 'number') { classes.push(arg); } else if (Array.isArray(arg)) { if (arg.length) { var inner = classNames.apply(null, arg); if (inner) { classes.push(inner); } } } else if (argType === 'object') { if (arg.toString === Object.prototype.toString) { for (var key in arg) { if (hasOwn.call(arg, key) && arg[key]) { classes.push(key); } } } else { classes.push(arg.toString()); } } } return classes.join(' '); } if (module.exports) { classNames.default = classNames; module.exports = classNames; } else { window.classNames = classNames; } }()); }(classnames)); var classNames$1 = classnames.exports; var PlasmicDataSourceContext = /*#__PURE__*/React__default["default"].createContext(undefined); function usePlasmicDataSourceContext() { return React__default["default"].useContext(PlasmicDataSourceContext); } function useCurrentUser() { var ctx = usePlasmicDataSourceContext(); return ctx == null ? void 0 : ctx.user; } var PlasmicDataSourceContextProvider = PlasmicDataSourceContext.Provider; var dlv_umd = {exports: {}}; (function (module, exports) { !function(t,n){module.exports=function(t,n,e,i,o){for(n=n.split?n.split("."):n,i=0;i 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } if (t[2]) _.ops.pop(); _.trys.pop(); continue; } op = body.call(thisArg, _); } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; } } function __values(o) { var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; if (m) return m.call(o); if (o && typeof o.length === "number") return { next: function () { if (o && i >= o.length) o = void 0; return { value: o && o[i++], done: !o }; } }; throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); } function __read(o, n) { var m = typeof Symbol === "function" && o[Symbol.iterator]; if (!m) return o; var i = m.call(o), r, ar = [], e; try { while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); } catch (error) { e = { error: error }; } finally { try { if (r && !r.done && (m = i["return"])) m.call(i); } finally { if (e) throw e.error; } } return ar; } function __spreadArray(to, from, pack) { if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { if (ar || !(i in from)) { if (!ar) ar = Array.prototype.slice.call(from, 0, i); ar[i] = from[i]; } } return to.concat(ar || Array.prototype.slice.call(from)); } function notNil(x) { return x != null; } function pick(obj) { var e_1, _a; var keys = []; for (var _i = 1; _i < arguments.length; _i++) { keys[_i - 1] = arguments[_i]; } if (Object.keys(obj).length === 0) { return obj; } var res = {}; try { for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) { var key = keys_1_1.value; if (key in obj) { res[key] = obj[key]; } } } catch (e_1_1) { e_1 = { error: e_1_1 }; } finally { try { if (keys_1_1 && !keys_1_1.done && (_a = keys_1["return"])) _a.call(keys_1); } finally { if (e_1) throw e_1.error; } } return res; } function omit(obj) { var e_3, _a; var keys = []; for (var _i = 1; _i < arguments.length; _i++) { keys[_i - 1] = arguments[_i]; } if (Object.keys(obj).length === 0) { return obj; } var res = {}; try { for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) { var key = _c.value; if (!keys.includes(key)) { res[key] = obj[key]; } } } catch (e_3_1) { e_3 = { error: e_3_1 }; } finally { try { if (_c && !_c.done && (_a = _b["return"])) _a.call(_b); } finally { if (e_3) throw e_3.error; } } return res; } function isSubset(a1, a2) { return a1.every(function (x) { return a2.includes(x); }); } function chainSingleArgFuncs() { var funcs = []; for (var _i = 0; _i < arguments.length; _i++) { funcs[_i] = arguments[_i]; } if (funcs.length === 0) { return undefined; } return function (arg) { var e_4, _a; var res = arg; try { for (var funcs_1 = __values(funcs), funcs_1_1 = funcs_1.next(); !funcs_1_1.done; funcs_1_1 = funcs_1.next()) { var func = funcs_1_1.value; res = func(res); } } catch (e_4_1) { e_4 = { error: e_4_1 }; } finally { try { if (funcs_1_1 && !funcs_1_1.done && (_a = funcs_1["return"])) _a.call(funcs_1); } finally { if (e_4) throw e_4.error; } } return res; }; } function groupBy(collection, keyFunc) { var e_5, _a; var result = {}; try { for (var collection_1 = __values(collection), collection_1_1 = collection_1.next(); !collection_1_1.done; collection_1_1 = collection_1.next()) { var obj = collection_1_1.value; var key = keyFunc(obj); if (key in result) { result[key].push(obj); } else { result[key] = [obj]; } } } catch (e_5_1) { e_5 = { error: e_5_1 }; } finally { try { if (collection_1_1 && !collection_1_1.done && (_a = collection_1["return"])) _a.call(collection_1); } finally { if (e_5) throw e_5.error; } } return result; } function mapValues(obj, mapper) { var result = {}; for (var key in obj) { result[key] = mapper(obj[key]); } return result; } var isBrowser = typeof window !== "undefined"; var NONE = Symbol("NONE"); var useIsomorphicLayoutEffect$1 = isBrowser ? React__default["default"].useLayoutEffect : React__default["default"].useEffect; function createElementWithChildren(elementType, props, children) { if (Array.isArray(children)) { return React__default["default"].createElement.apply(React__default["default"], __spreadArray([elementType, props], __read(children), false)); } else if (children || "children" in props) { // Only call React.createElement with `children` if there are actual children, // or if there was an explicit (albeit undefined) children passed via // props. Otherwise, if you pass `undefined` as the children argument // to React.createElement, the created element will have prop {children: undefined}. // If the `root` is an PlasmicGeneratedComponent, and these props with {children: undefined} // are used, then it will be taken as a `children` override, and will thus blank out // everything under the root node. return React__default["default"].createElement(elementType, props, children); } else { return React__default["default"].createElement(elementType, props); } } function ensureNotArray(children) { if (Array.isArray(children)) { if (children.length === 1) { return children[0]; } else { return React__default["default"].createElement.apply(React__default["default"], __spreadArray([React__default["default"].Fragment, {}], __read(children), false)); } } else { return children; } } function isReactNode(x) { return (typeof x === "string" || typeof x === "number" || React__default["default"].isValidElement(x)); } function mergeProps(props) { var e_1, _a, e_2, _b; var restProps = []; for (var _i = 1; _i < arguments.length; _i++) { restProps[_i - 1] = arguments[_i]; } if (restProps.every(function (rest) { return Object.keys(rest).length === 0; })) { return props; } var result = exports.__assign({}, props); try { for (var restProps_1 = __values(restProps), restProps_1_1 = restProps_1.next(); !restProps_1_1.done; restProps_1_1 = restProps_1.next()) { var rest = restProps_1_1.value; try { for (var _c = (e_2 = void 0, __values(Object.keys(rest))), _d = _c.next(); !_d.done; _d = _c.next()) { var key = _d.value; result[key] = mergePropVals(key, result[key], rest[key]); } } catch (e_2_1) { e_2 = { error: e_2_1 }; } finally { try { if (_d && !_d.done && (_b = _c["return"])) _b.call(_c); } finally { if (e_2) throw e_2.error; } } } } catch (e_1_1) { e_1 = { error: e_1_1 }; } finally { try { if (restProps_1_1 && !restProps_1_1.done && (_a = restProps_1["return"])) _a.call(restProps_1); } finally { if (e_1) throw e_1.error; } } return result; } function updateRef(ref, value) { if (!ref) { return; } if (typeof ref === "function") { ref(value); } else { if (!Object.isFrozen(ref)) { ref.current = value; } } } function mergeRefs() { var refs = []; for (var _i = 0; _i < arguments.length; _i++) { refs[_i] = arguments[_i]; } return function (value) { var e_3, _a; try { for (var refs_1 = __values(refs), refs_1_1 = refs_1.next(); !refs_1_1.done; refs_1_1 = refs_1.next()) { var ref = refs_1_1.value; updateRef(ref, value); } } catch (e_3_1) { e_3 = { error: e_3_1 }; } finally { try { if (refs_1_1 && !refs_1_1.done && (_a = refs_1["return"])) _a.call(refs_1); } finally { if (e_3) throw e_3.error; } } }; } function mergePropVals(name, val1, val2) { if (val1 === NONE || val2 === NONE) { // The NONE sentinel always skips all merging and returns null return null; } else if (val1 == null) { // If either of them is nil, prefer the other return val2; } else if (val2 == null) { return val1; } else if (name === "className") { // Special case for className -- always combine both class names return classNames$1(val1, val2); } else if (name === "style") { // Special case for style -- always shallow-merge style dicts return exports.__assign(exports.__assign({}, val1), val2); } else if (name === "ref") { // Special case for ref return mergeRefs(val1, val2); } else if (typeof val1 !== typeof val2) { // If the type of the two values are different, then no way to merge them. // Prefer val2. return val2; } else if (name.startsWith("on") && typeof val1 === "function") { // Special case for event handlers -- always call both handlers return function () { var args = []; for (var _i = 0; _i < arguments.length; _i++) { args[_i] = arguments[_i]; } var res; if (typeof val1 === "function") { res = val1.apply(void 0, __spreadArray([], __read(args), false)); } if (typeof val2 === "function") { res = val2.apply(void 0, __spreadArray([], __read(args), false)); } return res; }; } else { // For all else, prefer val2 return val2; } } var PlasmicHeadContext = React__namespace.createContext(undefined); function PlasmicHead(props) { var Head = React__namespace.useContext(PlasmicHeadContext); if (!Head) { console.warn("Plasmic: Head meta tags are being ignored. To make them work, pass a Head component into PlasmicRootProvider."); // TODO: Link to doc about Head. return null; } // Helmet does not support React.Fragments, so we need to use `[, // ]` instead of `<>`. return (React__namespace.createElement(Head, null, props.image ? ([ React__namespace.createElement("meta", { key: "twitter:card", name: "twitter:card", content: "summary_large_image" }), React__namespace.createElement("meta", { key: "og:image", property: "og:image", content: props.image }), React__namespace.createElement("meta", { key: "twitter:image", name: "twitter:image", content: props.image }), ]) : (React__namespace.createElement("meta", { key: "twitter:card", name: "twitter:card", content: "summary" })), props.title && [ React__namespace.createElement("title", { key: "title" }, props.title), React__namespace.createElement("meta", { key: "og:title", property: "og:title", content: props.title }), React__namespace.createElement("meta", { key: "twitter:title", property: "twitter:title", content: props.title }), ], props.description && [ React__namespace.createElement("meta", { key: "description", name: "description", content: props.description }), React__namespace.createElement("meta", { key: "og:description", property: "og:description", content: props.description }), React__namespace.createElement("meta", { key: "twitter:description", name: "twitter:description", content: props.description }), ], props.canonical && (React__namespace.createElement("link", { key: "canonical", ref: "canonical", href: props.canonical })))); } var plasmicHeadMeta = { name: "hostless-plasmic-head", displayName: "Head", description: "Used to add page metadata to HTML .", importName: "PlasmicHead", importPath: "@plasmicapp/react-web", isRepeatable: false, styleSections: false, props: { title: { type: "string", displayName: "Title" }, description: { type: "string", displayName: "Description" }, image: { type: "imageUrl", displayName: "Image" }, canonical: { type: "string", displayName: "Canonical URL" } } }; /** * Responsive `` replacement, based on `next/image` */ // Default image sizes to snap to // TODO: make this configurable? var IMG_SIZES = [16, 32, 48, 64, 96, 128, 256, 384]; var DEVICE_SIZES = [640, 750, 828, 1080, 1200, 1920, 2048, 3840]; var ALL_SIZES = __spreadArray(__spreadArray([], __read(IMG_SIZES), false), __read(DEVICE_SIZES), false); var PlasmicImg = React__default["default"].forwardRef(function PlasmicImg(props, outerRef) { var src = props.src, className = props.className, displayWidth = props.displayWidth, displayHeight = props.displayHeight, displayMinWidth = props.displayMinWidth, displayMinHeight = props.displayMinHeight, displayMaxWidth = props.displayMaxWidth, displayMaxHeight = props.displayMaxHeight, quality = props.quality, loader = props.loader, imgRef = props.imgRef, style = props.style, loading = props.loading, rest = __rest(props, ["src", "className", "displayWidth", "displayHeight", "displayMinWidth", "displayMinHeight", "displayMaxWidth", "displayMaxHeight", "quality", "loader", "imgRef", "style", "loading"]); var imgProps = Object.assign({}, rest, { // Default loading to "lazy" if not specified (which is different from the // html img, which defaults to eager!) loading: loading !== null && loading !== void 0 ? loading : "lazy" }); var _a = typeof src === "string" || !src ? { fullWidth: undefined, fullHeight: undefined, aspectRatio: undefined } : src, fullWidth = _a.fullWidth, fullHeight = _a.fullHeight, aspectRatio = _a.aspectRatio; var srcStr = src ? typeof src === "string" ? src : typeof src.src === "string" ? src.src : src.src.src : ""; // Assume external image if either dimension is null and use usual if (fullHeight == null || fullWidth == null) { return (React__default["default"].createElement("img", exports.__assign({ src: srcStr, className: className, style: style }, imgProps, { loading: loading, ref: mergeRefs(imgRef, outerRef) }))); } if (isSvg(srcStr) && (displayHeight == null || displayHeight === "auto") && (displayWidth == null || displayWidth === "auto")) { displayWidth = "100%"; } var computedDisplayWidth = displayWidth; if (fullWidth && fullHeight && (!displayWidth || displayWidth === "auto") && !!getPixelLength(displayHeight)) { // If there's a pixel length specified for displayHeight but not displayWidth, // then we can derive the pixel length for displayWidth. Having an explicit // displayWidth makes this a fixed-size image, which makes it possible for us to // generate better markup! if (!isSvg(srcStr)) { // We shouldn't do it for SVGs though, because `fullWidth` and // `fullHeight` might have rounded values so the final // `displayWidth` could differ by 1px or so. computedDisplayWidth = (getPixelLength(displayHeight) * fullWidth) / fullHeight; } } var spacerWidth = fullWidth; var spacerHeight = fullHeight; if (aspectRatio && isFinite(aspectRatio) && isSvg(srcStr)) { // For SVGs, fullWidth and fullHeight can be rounded values, which would // cause some discrepancy between the actual aspect ratio and the aspect // ratio from those values. So, for those cases, we set large width / height // values to get a more precise ratio from the spacer. spacerWidth = DEFAULT_SVG_WIDTH; spacerHeight = Math.round(spacerWidth / aspectRatio); } var _b = getWidths(computedDisplayWidth, fullWidth, { minWidth: displayMinWidth }), sizes = _b.sizes, widthDescs = _b.widthDescs; var imageLoader = getImageLoader(loader); var spacerSvg = ". Else it will render to a