'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; function notNil(x) { return x != null; } function pick(obj) { 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 = {}; for (var _a = 0, keys_1 = keys; _a < keys_1.length; _a++) { var key = keys_1[_a]; if (key in obj) { res[key] = obj[key]; } } return res; } function omit(obj) { 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 = {}; for (var _a = 0, _b = Object.keys(obj); _a < _b.length; _a++) { var key = _b[_a]; if (!keys.includes(key)) { res[key] = obj[key]; } } 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 res = arg; for (var _i = 0, funcs_1 = funcs; _i < funcs_1.length; _i++) { var func = funcs_1[_i]; res = func(res); } return res; }; } function groupBy(collection, keyFunc) { var result = {}; for (var _i = 0, collection_1 = collection; _i < collection_1.length; _i++) { var obj = collection_1[_i]; var key = keyFunc(obj); if (key in result) { result[key].push(obj); } else { result[key] = [obj]; } } return result; } function mapValues(obj, mapper) { var result = {}; for (var key in obj) { result[key] = mapper(obj[key]); } return result; } /*! ***************************************************************************** Copyright (c) Microsoft Corporation. Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ***************************************************************************** */ exports.__assign = function() { exports.__assign = Object.assign || function __assign(t) { for (var s, i = 1, n = arguments.length; i < n; i++) { s = arguments[i]; for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; } return t; }; return exports.__assign.apply(this, arguments); }; function __rest(s, e) { var t = {}; for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p]; if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]]; } return t; } 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)); } var isBrowser = typeof window !== "undefined"; var NONE = Symbol("NONE"); var useIsomorphicLayoutEffect = 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], children)); } 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, {}], children)); } } else { return children; } } function isReactNode(x) { return (typeof x === "string" || typeof x === "number" || React__default["default"].isValidElement(x)); } function mergeProps(props) { 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); for (var _a = 0, restProps_1 = restProps; _a < restProps_1.length; _a++) { var rest = restProps_1[_a]; for (var _b = 0, _c = Object.keys(rest); _b < _c.length; _b++) { var key = _c[_b]; result[key] = mergePropVals(key, result[key], rest[key]); } } 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) { for (var _i = 0, refs_1 = refs; _i < refs_1.length; _i++) { var ref = refs_1[_i]; updateRef(ref, value); } }; } 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, args); } if (typeof val2 === "function") { res = val2.apply(void 0, args); } return res; }; } else { // For all else, prefer val2 return val2; } } /** * 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([], IMG_SIZES), DEVICE_SIZES); 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 : 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%"; } 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. displayWidth = (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(displayWidth, fullWidth, { minWidth: displayMinWidth, }), sizes = _b.sizes, widthDescs = _b.widthDescs; var imageLoader = getImageLoader(loader); var spacerSvg = ". Else it will render to a