{"version":3,"sources":["node_modules/@ionic/pwa-elements/dist/esm/index-1c5c47b4.js"],"sourcesContent":["const NAMESPACE = 'ionicpwaelements';\n\n/**\n * Virtual DOM patching algorithm based on Snabbdom by\n * Simon Friis Vindum (@paldepind)\n * Licensed under the MIT License\n * https://github.com/snabbdom/snabbdom/blob/master/LICENSE\n *\n * Modified for Stencil's renderer and slot projection\n */\nlet scopeId;\nlet hostTagName;\nlet isSvgMode = false;\nlet queuePending = false;\nconst createTime = (fnName, tagName = '') => {\n    {\n        return () => {\n            return;\n        };\n    }\n};\nconst uniqueTime = (key, measureText) => {\n    {\n        return () => {\n            return;\n        };\n    }\n};\nconst HYDRATED_CSS = '{visibility:hidden}.hydrated{visibility:inherit}';\n/**\n * Default style mode id\n */\n/**\n * Reusable empty obj/array\n * Don't add values to these!!\n */\nconst EMPTY_OBJ = {};\n/**\n * Namespaces\n */\nconst SVG_NS = 'http://www.w3.org/2000/svg';\nconst HTML_NS = 'http://www.w3.org/1999/xhtml';\nconst isDef = (v) => v != null;\n/**\n * Check whether a value is a 'complex type', defined here as an object or a\n * function.\n *\n * @param o the value to check\n * @returns whether it's a complex type or not\n */\nconst isComplexType = (o) => {\n    // https://jsperf.com/typeof-fn-object/5\n    o = typeof o;\n    return o === 'object' || o === 'function';\n};\n/**\n * Helper method for querying a `meta` tag that contains a nonce value\n * out of a DOM's head.\n *\n * @param doc The DOM containing the `head` to query against\n * @returns The content of the meta tag representing the nonce value, or `undefined` if no tag\n * exists or the tag has no content.\n */\nfunction queryNonceMetaTagContent(doc) {\n    var _a, _b, _c;\n    return (_c = (_b = (_a = doc.head) === null || _a === void 0 ? void 0 : _a.querySelector('meta[name=\"csp-nonce\"]')) === null || _b === void 0 ? void 0 : _b.getAttribute('content')) !== null && _c !== void 0 ? _c : undefined;\n}\n/**\n * Production h() function based on Preact by\n * Jason Miller (@developit)\n * Licensed under the MIT License\n * https://github.com/developit/preact/blob/master/LICENSE\n *\n * Modified for Stencil's compiler and vdom\n */\n// export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, child?: d.ChildType): d.VNode;\n// export function h(nodeName: string | d.FunctionalComponent, vnodeData: d.PropsType, ...children: d.ChildType[]): d.VNode;\nconst h = (nodeName, vnodeData, ...children) => {\n    let child = null;\n    let simple = false;\n    let lastSimple = false;\n    const vNodeChildren = [];\n    const walk = (c) => {\n        for (let i = 0; i < c.length; i++) {\n            child = c[i];\n            if (Array.isArray(child)) {\n                walk(child);\n            }\n            else if (child != null && typeof child !== 'boolean') {\n                if ((simple = typeof nodeName !== 'function' && !isComplexType(child))) {\n                    child = String(child);\n                }\n                if (simple && lastSimple) {\n                    // If the previous child was simple (string), we merge both\n                    vNodeChildren[vNodeChildren.length - 1].$text$ += child;\n                }\n                else {\n                    // Append a new vNode, if it's text, we create a text vNode\n                    vNodeChildren.push(simple ? newVNode(null, child) : child);\n                }\n                lastSimple = simple;\n            }\n        }\n    };\n    walk(children);\n    if (vnodeData) {\n        {\n            const classData = vnodeData.className || vnodeData.class;\n            if (classData) {\n                vnodeData.class =\n                    typeof classData !== 'object'\n                        ? classData\n                        : Object.keys(classData)\n                            .filter((k) => classData[k])\n                            .join(' ');\n            }\n        }\n    }\n    const vnode = newVNode(nodeName, null);\n    vnode.$attrs$ = vnodeData;\n    if (vNodeChildren.length > 0) {\n        vnode.$children$ = vNodeChildren;\n    }\n    return vnode;\n};\n/**\n * A utility function for creating a virtual DOM node from a tag and some\n * possible text content.\n *\n * @param tag the tag for this element\n * @param text possible text content for the node\n * @returns a newly-minted virtual DOM node\n */\nconst newVNode = (tag, text) => {\n    const vnode = {\n        $flags$: 0,\n        $tag$: tag,\n        $text$: text,\n        $elm$: null,\n        $children$: null,\n    };\n    {\n        vnode.$attrs$ = null;\n    }\n    return vnode;\n};\nconst Host = {};\n/**\n * Check whether a given node is a Host node or not\n *\n * @param node the virtual DOM node to check\n * @returns whether it's a Host node or not\n */\nconst isHost = (node) => node && node.$tag$ === Host;\n/**\n * Parse a new property value for a given property type.\n *\n * While the prop value can reasonably be expected to be of `any` type as far as TypeScript's type checker is concerned,\n * it is not safe to assume that the string returned by evaluating `typeof propValue` matches:\n *   1. `any`, the type given to `propValue` in the function signature\n *   2. the type stored from `propType`.\n *\n * This function provides the capability to parse/coerce a property's value to potentially any other JavaScript type.\n *\n * Property values represented in TSX preserve their type information. In the example below, the number 0 is passed to\n * a component. This `propValue` will preserve its type information (`typeof propValue === 'number'`). Note that is\n * based on the type of the value being passed in, not the type declared of the class member decorated with `@Prop`.\n * ```tsx\n * <my-cmp prop-val={0}></my-cmp>\n * ```\n *\n * HTML prop values on the other hand, will always a string\n *\n * @param propValue the new value to coerce to some type\n * @param propType the type of the prop, expressed as a binary number\n * @returns the parsed/coerced value\n */\nconst parsePropertyValue = (propValue, propType) => {\n    // ensure this value is of the correct prop type\n    if (propValue != null && !isComplexType(propValue)) {\n        if (propType & 4 /* MEMBER_FLAGS.Boolean */) {\n            // per the HTML spec, any string value means it is a boolean true value\n            // but we'll cheat here and say that the string \"false\" is the boolean false\n            return propValue === 'false' ? false : propValue === '' || !!propValue;\n        }\n        if (propType & 2 /* MEMBER_FLAGS.Number */) {\n            // force it to be a number\n            return parseFloat(propValue);\n        }\n        if (propType & 1 /* MEMBER_FLAGS.String */) {\n            // could have been passed as a number or boolean\n            // but we still want it as a string\n            return String(propValue);\n        }\n        // redundant return here for better minification\n        return propValue;\n    }\n    // not sure exactly what type we want\n    // so no need to change to a different type\n    return propValue;\n};\nconst getElement = (ref) => (getHostRef(ref).$hostElement$ );\nconst createEvent = (ref, name, flags) => {\n    const elm = getElement(ref);\n    return {\n        emit: (detail) => {\n            return emitEvent(elm, name, {\n                bubbles: !!(flags & 4 /* EVENT_FLAGS.Bubbles */),\n                composed: !!(flags & 2 /* EVENT_FLAGS.Composed */),\n                cancelable: !!(flags & 1 /* EVENT_FLAGS.Cancellable */),\n                detail,\n            });\n        },\n    };\n};\n/**\n * Helper function to create & dispatch a custom Event on a provided target\n * @param elm the target of the Event\n * @param name the name to give the custom Event\n * @param opts options for configuring a custom Event\n * @returns the custom Event\n */\nconst emitEvent = (elm, name, opts) => {\n    const ev = plt.ce(name, opts);\n    elm.dispatchEvent(ev);\n    return ev;\n};\nconst rootAppliedStyles = /*@__PURE__*/ new WeakMap();\nconst registerStyle = (scopeId, cssText, allowCS) => {\n    let style = styles.get(scopeId);\n    if (supportsConstructableStylesheets && allowCS) {\n        style = (style || new CSSStyleSheet());\n        if (typeof style === 'string') {\n            style = cssText;\n        }\n        else {\n            style.replaceSync(cssText);\n        }\n    }\n    else {\n        style = cssText;\n    }\n    styles.set(scopeId, style);\n};\nconst addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => {\n    var _a;\n    let scopeId = getScopeId(cmpMeta);\n    const style = styles.get(scopeId);\n    // if an element is NOT connected then getRootNode() will return the wrong root node\n    // so the fallback is to always use the document for the root node in those cases\n    styleContainerNode = styleContainerNode.nodeType === 11 /* NODE_TYPE.DocumentFragment */ ? styleContainerNode : doc;\n    if (style) {\n        if (typeof style === 'string') {\n            styleContainerNode = styleContainerNode.head || styleContainerNode;\n            let appliedStyles = rootAppliedStyles.get(styleContainerNode);\n            let styleElm;\n            if (!appliedStyles) {\n                rootAppliedStyles.set(styleContainerNode, (appliedStyles = new Set()));\n            }\n            if (!appliedStyles.has(scopeId)) {\n                {\n                    // TODO(STENCIL-659): Remove code implementing the CSS variable shim\n                    {\n                        styleElm = doc.createElement('style');\n                        styleElm.innerHTML = style;\n                    }\n                    // Apply CSP nonce to the style tag if it exists\n                    const nonce = (_a = plt.$nonce$) !== null && _a !== void 0 ? _a : queryNonceMetaTagContent(doc);\n                    if (nonce != null) {\n                        styleElm.setAttribute('nonce', nonce);\n                    }\n                    styleContainerNode.insertBefore(styleElm, styleContainerNode.querySelector('link'));\n                }\n                if (appliedStyles) {\n                    appliedStyles.add(scopeId);\n                }\n            }\n        }\n        else if (!styleContainerNode.adoptedStyleSheets.includes(style)) {\n            styleContainerNode.adoptedStyleSheets = [...styleContainerNode.adoptedStyleSheets, style];\n        }\n    }\n    return scopeId;\n};\nconst attachStyles = (hostRef) => {\n    const cmpMeta = hostRef.$cmpMeta$;\n    const elm = hostRef.$hostElement$;\n    const flags = cmpMeta.$flags$;\n    const endAttachStyles = createTime('attachStyles', cmpMeta.$tagName$);\n    const scopeId = addStyle(elm.shadowRoot ? elm.shadowRoot : elm.getRootNode(), cmpMeta);\n    // TODO(STENCIL-662): Remove code related to deprecated shadowDomShim field\n    if (flags & 10 /* CMP_FLAGS.needsScopedEncapsulation */) {\n        // only required when we're NOT using native shadow dom (slot)\n        // or this browser doesn't support native shadow dom\n        // and this host element was NOT created with SSR\n        // let's pick out the inner content for slot projection\n        // create a node to represent where the original\n        // content was first placed, which is useful later on\n        // DOM WRITE!!\n        elm['s-sc'] = scopeId;\n        elm.classList.add(scopeId + '-h');\n    }\n    endAttachStyles();\n};\nconst getScopeId = (cmp, mode) => 'sc-' + (cmp.$tagName$);\n/**\n * Production setAccessor() function based on Preact by\n * Jason Miller (@developit)\n * Licensed under the MIT License\n * https://github.com/developit/preact/blob/master/LICENSE\n *\n * Modified for Stencil's compiler and vdom\n */\nconst setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags) => {\n    if (oldValue !== newValue) {\n        let isProp = isMemberInElement(elm, memberName);\n        let ln = memberName.toLowerCase();\n        if (memberName === 'class') {\n            const classList = elm.classList;\n            const oldClasses = parseClassList(oldValue);\n            const newClasses = parseClassList(newValue);\n            classList.remove(...oldClasses.filter((c) => c && !newClasses.includes(c)));\n            classList.add(...newClasses.filter((c) => c && !oldClasses.includes(c)));\n        }\n        else if (memberName === 'style') {\n            // update style attribute, css properties and values\n            {\n                for (const prop in oldValue) {\n                    if (!newValue || newValue[prop] == null) {\n                        if (prop.includes('-')) {\n                            elm.style.removeProperty(prop);\n                        }\n                        else {\n                            elm.style[prop] = '';\n                        }\n                    }\n                }\n            }\n            for (const prop in newValue) {\n                if (!oldValue || newValue[prop] !== oldValue[prop]) {\n                    if (prop.includes('-')) {\n                        elm.style.setProperty(prop, newValue[prop]);\n                    }\n                    else {\n                        elm.style[prop] = newValue[prop];\n                    }\n                }\n            }\n        }\n        else if (memberName === 'ref') {\n            // minifier will clean this up\n            if (newValue) {\n                newValue(elm);\n            }\n        }\n        else if ((!isProp ) &&\n            memberName[0] === 'o' &&\n            memberName[1] === 'n') {\n            // Event Handlers\n            // so if the member name starts with \"on\" and the 3rd characters is\n            // a capital letter, and it's not already a member on the element,\n            // then we're assuming it's an event listener\n            if (memberName[2] === '-') {\n                // on- prefixed events\n                // allows to be explicit about the dom event to listen without any magic\n                // under the hood:\n                // <my-cmp on-click> // listens for \"click\"\n                // <my-cmp on-Click> // listens for \"Click\"\n                // <my-cmp on-ionChange> // listens for \"ionChange\"\n                // <my-cmp on-EVENTS> // listens for \"EVENTS\"\n                memberName = memberName.slice(3);\n            }\n            else if (isMemberInElement(win, ln)) {\n                // standard event\n                // the JSX attribute could have been \"onMouseOver\" and the\n                // member name \"onmouseover\" is on the window's prototype\n                // so let's add the listener \"mouseover\", which is all lowercased\n                memberName = ln.slice(2);\n            }\n            else {\n                // custom event\n                // the JSX attribute could have been \"onMyCustomEvent\"\n                // so let's trim off the \"on\" prefix and lowercase the first character\n                // and add the listener \"myCustomEvent\"\n                // except for the first character, we keep the event name case\n                memberName = ln[2] + memberName.slice(3);\n            }\n            if (oldValue) {\n                plt.rel(elm, memberName, oldValue, false);\n            }\n            if (newValue) {\n                plt.ael(elm, memberName, newValue, false);\n            }\n        }\n        else {\n            // Set property if it exists and it's not a SVG\n            const isComplex = isComplexType(newValue);\n            if ((isProp || (isComplex && newValue !== null)) && !isSvg) {\n                try {\n                    if (!elm.tagName.includes('-')) {\n                        const n = newValue == null ? '' : newValue;\n                        // Workaround for Safari, moving the <input> caret when re-assigning the same valued\n                        if (memberName === 'list') {\n                            isProp = false;\n                        }\n                        else if (oldValue == null || elm[memberName] != n) {\n                            elm[memberName] = n;\n                        }\n                    }\n                    else {\n                        elm[memberName] = newValue;\n                    }\n                }\n                catch (e) { }\n            }\n            if (newValue == null || newValue === false) {\n                if (newValue !== false || elm.getAttribute(memberName) === '') {\n                    {\n                        elm.removeAttribute(memberName);\n                    }\n                }\n            }\n            else if ((!isProp || flags & 4 /* VNODE_FLAGS.isHost */ || isSvg) && !isComplex) {\n                newValue = newValue === true ? '' : newValue;\n                {\n                    elm.setAttribute(memberName, newValue);\n                }\n            }\n        }\n    }\n};\nconst parseClassListRegex = /\\s/;\nconst parseClassList = (value) => (!value ? [] : value.split(parseClassListRegex));\nconst updateElement = (oldVnode, newVnode, isSvgMode, memberName) => {\n    // if the element passed in is a shadow root, which is a document fragment\n    // then we want to be adding attrs/props to the shadow root's \"host\" element\n    // if it's not a shadow root, then we add attrs/props to the same element\n    const elm = newVnode.$elm$.nodeType === 11 /* NODE_TYPE.DocumentFragment */ && newVnode.$elm$.host\n        ? newVnode.$elm$.host\n        : newVnode.$elm$;\n    const oldVnodeAttrs = (oldVnode && oldVnode.$attrs$) || EMPTY_OBJ;\n    const newVnodeAttrs = newVnode.$attrs$ || EMPTY_OBJ;\n    {\n        // remove attributes no longer present on the vnode by setting them to undefined\n        for (memberName in oldVnodeAttrs) {\n            if (!(memberName in newVnodeAttrs)) {\n                setAccessor(elm, memberName, oldVnodeAttrs[memberName], undefined, isSvgMode, newVnode.$flags$);\n            }\n        }\n    }\n    // add new & update changed attributes\n    for (memberName in newVnodeAttrs) {\n        setAccessor(elm, memberName, oldVnodeAttrs[memberName], newVnodeAttrs[memberName], isSvgMode, newVnode.$flags$);\n    }\n};\n/**\n * Create a DOM Node corresponding to one of the children of a given VNode.\n *\n * @param oldParentVNode the parent VNode from the previous render\n * @param newParentVNode the parent VNode from the current render\n * @param childIndex the index of the VNode, in the _new_ parent node's\n * children, for which we will create a new DOM node\n * @param parentElm the parent DOM node which our new node will be a child of\n * @returns the newly created node\n */\nconst createElm = (oldParentVNode, newParentVNode, childIndex, parentElm) => {\n    // tslint:disable-next-line: prefer-const\n    const newVNode = newParentVNode.$children$[childIndex];\n    let i = 0;\n    let elm;\n    let childNode;\n    if (newVNode.$text$ !== null) {\n        // create text node\n        elm = newVNode.$elm$ = doc.createTextNode(newVNode.$text$);\n    }\n    else {\n        if (!isSvgMode) {\n            isSvgMode = newVNode.$tag$ === 'svg';\n        }\n        // create element\n        elm = newVNode.$elm$ = (doc.createElementNS(isSvgMode ? SVG_NS : HTML_NS, newVNode.$tag$)\n            );\n        if (isSvgMode && newVNode.$tag$ === 'foreignObject') {\n            isSvgMode = false;\n        }\n        // add css classes, attrs, props, listeners, etc.\n        {\n            updateElement(null, newVNode, isSvgMode);\n        }\n        if (isDef(scopeId) && elm['s-si'] !== scopeId) {\n            // if there is a scopeId and this is the initial render\n            // then let's add the scopeId as a css class\n            elm.classList.add((elm['s-si'] = scopeId));\n        }\n        if (newVNode.$children$) {\n            for (i = 0; i < newVNode.$children$.length; ++i) {\n                // create the node\n                childNode = createElm(oldParentVNode, newVNode, i);\n                // return node could have been null\n                if (childNode) {\n                    // append our new node\n                    elm.appendChild(childNode);\n                }\n            }\n        }\n        {\n            if (newVNode.$tag$ === 'svg') {\n                // Only reset the SVG context when we're exiting <svg> element\n                isSvgMode = false;\n            }\n            else if (elm.tagName === 'foreignObject') {\n                // Reenter SVG context when we're exiting <foreignObject> element\n                isSvgMode = true;\n            }\n        }\n    }\n    return elm;\n};\n/**\n * Create DOM nodes corresponding to a list of {@link d.Vnode} objects and\n * add them to the DOM in the appropriate place.\n *\n * @param parentElm the DOM node which should be used as a parent for the new\n * DOM nodes\n * @param before a child of the `parentElm` which the new children should be\n * inserted before (optional)\n * @param parentVNode the parent virtual DOM node\n * @param vnodes the new child virtual DOM nodes to produce DOM nodes for\n * @param startIdx the index in the child virtual DOM nodes at which to start\n * creating DOM nodes (inclusive)\n * @param endIdx the index in the child virtual DOM nodes at which to stop\n * creating DOM nodes (inclusive)\n */\nconst addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) => {\n    let containerElm = (parentElm);\n    let childNode;\n    if (containerElm.shadowRoot && containerElm.tagName === hostTagName) {\n        containerElm = containerElm.shadowRoot;\n    }\n    for (; startIdx <= endIdx; ++startIdx) {\n        if (vnodes[startIdx]) {\n            childNode = createElm(null, parentVNode, startIdx);\n            if (childNode) {\n                vnodes[startIdx].$elm$ = childNode;\n                containerElm.insertBefore(childNode, before);\n            }\n        }\n    }\n};\n/**\n * Remove the DOM elements corresponding to a list of {@link d.VNode} objects.\n * This can be used to, for instance, clean up after a list of children which\n * should no longer be shown.\n *\n * This function also handles some of Stencil's slot relocation logic.\n *\n * @param vnodes a list of virtual DOM nodes to remove\n * @param startIdx the index at which to start removing nodes (inclusive)\n * @param endIdx the index at which to stop removing nodes (inclusive)\n */\nconst removeVnodes = (vnodes, startIdx, endIdx) => {\n    for (let index = startIdx; index <= endIdx; ++index) {\n        const vnode = vnodes[index];\n        if (vnode) {\n            const elm = vnode.$elm$;\n            nullifyVNodeRefs(vnode);\n            if (elm) {\n                // remove the vnode's element from the dom\n                elm.remove();\n            }\n        }\n    }\n};\n/**\n * Reconcile the children of a new VNode with the children of an old VNode by\n * traversing the two collections of children, identifying nodes that are\n * conserved or changed, calling out to `patch` to make any necessary\n * updates to the DOM, and rearranging DOM nodes as needed.\n *\n * The algorithm for reconciling children works by analyzing two 'windows' onto\n * the two arrays of children (`oldCh` and `newCh`). We keep track of the\n * 'windows' by storing start and end indices and references to the\n * corresponding array entries. Initially the two 'windows' are basically equal\n * to the entire array, but we progressively narrow the windows until there are\n * no children left to update by doing the following:\n *\n * 1. Skip any `null` entries at the beginning or end of the two arrays, so\n *    that if we have an initial array like the following we'll end up dealing\n *    only with a window bounded by the highlighted elements:\n *\n *    [null, null, VNode1 , ... , VNode2, null, null]\n *                 ^^^^^^         ^^^^^^\n *\n * 2. Check to see if the elements at the head and tail positions are equal\n *    across the windows. This will basically detect elements which haven't\n *    been added, removed, or changed position, i.e. if you had the following\n *    VNode elements (represented as HTML):\n *\n *    oldVNode: `<div><p><span>HEY</span></p></div>`\n *    newVNode: `<div><p><span>THERE</span></p></div>`\n *\n *    Then when comparing the children of the `<div>` tag we check the equality\n *    of the VNodes corresponding to the `<p>` tags and, since they are the\n *    same tag in the same position, we'd be able to avoid completely\n *    re-rendering the subtree under them with a new DOM element and would just\n *    call out to `patch` to handle reconciling their children and so on.\n *\n * 3. Check, for both windows, to see if the element at the beginning of the\n *    window corresponds to the element at the end of the other window. This is\n *    a heuristic which will let us identify _some_ situations in which\n *    elements have changed position, for instance it _should_ detect that the\n *    children nodes themselves have not changed but merely moved in the\n *    following example:\n *\n *    oldVNode: `<div><element-one /><element-two /></div>`\n *    newVNode: `<div><element-two /><element-one /></div>`\n *\n *    If we find cases like this then we also need to move the concrete DOM\n *    elements corresponding to the moved children to write the re-order to the\n *    DOM.\n *\n * 4. Finally, if VNodes have the `key` attribute set on them we check for any\n *    nodes in the old children which have the same key as the first element in\n *    our window on the new children. If we find such a node we handle calling\n *    out to `patch`, moving relevant DOM nodes, and so on, in accordance with\n *    what we find.\n *\n * Finally, once we've narrowed our 'windows' to the point that either of them\n * collapse (i.e. they have length 0) we then handle any remaining VNode\n * insertion or deletion that needs to happen to get a DOM state that correctly\n * reflects the new child VNodes. If, for instance, after our window on the old\n * children has collapsed we still have more nodes on the new children that\n * we haven't dealt with yet then we need to add them, or if the new children\n * collapse but we still have unhandled _old_ children then we need to make\n * sure the corresponding DOM nodes are removed.\n *\n * @param parentElm the node into which the parent VNode is rendered\n * @param oldCh the old children of the parent node\n * @param newVNode the new VNode which will replace the parent\n * @param newCh the new children of the parent node\n */\nconst updateChildren = (parentElm, oldCh, newVNode, newCh) => {\n    let oldStartIdx = 0;\n    let newStartIdx = 0;\n    let oldEndIdx = oldCh.length - 1;\n    let oldStartVnode = oldCh[0];\n    let oldEndVnode = oldCh[oldEndIdx];\n    let newEndIdx = newCh.length - 1;\n    let newStartVnode = newCh[0];\n    let newEndVnode = newCh[newEndIdx];\n    let node;\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n        if (oldStartVnode == null) {\n            // VNode might have been moved left\n            oldStartVnode = oldCh[++oldStartIdx];\n        }\n        else if (oldEndVnode == null) {\n            oldEndVnode = oldCh[--oldEndIdx];\n        }\n        else if (newStartVnode == null) {\n            newStartVnode = newCh[++newStartIdx];\n        }\n        else if (newEndVnode == null) {\n            newEndVnode = newCh[--newEndIdx];\n        }\n        else if (isSameVnode(oldStartVnode, newStartVnode)) {\n            // if the start nodes are the same then we should patch the new VNode\n            // onto the old one, and increment our `newStartIdx` and `oldStartIdx`\n            // indices to reflect that. We don't need to move any DOM Nodes around\n            // since things are matched up in order.\n            patch(oldStartVnode, newStartVnode);\n            oldStartVnode = oldCh[++oldStartIdx];\n            newStartVnode = newCh[++newStartIdx];\n        }\n        else if (isSameVnode(oldEndVnode, newEndVnode)) {\n            // likewise, if the end nodes are the same we patch new onto old and\n            // decrement our end indices, and also likewise in this case we don't\n            // need to move any DOM Nodes.\n            patch(oldEndVnode, newEndVnode);\n            oldEndVnode = oldCh[--oldEndIdx];\n            newEndVnode = newCh[--newEndIdx];\n        }\n        else if (isSameVnode(oldStartVnode, newEndVnode)) {\n            patch(oldStartVnode, newEndVnode);\n            // We need to move the element for `oldStartVnode` into a position which\n            // will be appropriate for `newEndVnode`. For this we can use\n            // `.insertBefore` and `oldEndVnode.$elm$.nextSibling`. If there is a\n            // sibling for `oldEndVnode.$elm$` then we want to move the DOM node for\n            // `oldStartVnode` between `oldEndVnode` and it's sibling, like so:\n            //\n            // <old-start-node />\n            // <some-intervening-node />\n            // <old-end-node />\n            // <!-- ->              <-- `oldStartVnode.$elm$` should be inserted here\n            // <next-sibling />\n            //\n            // If instead `oldEndVnode.$elm$` has no sibling then we just want to put\n            // the node for `oldStartVnode` at the end of the children of\n            // `parentElm`. Luckily, `Node.nextSibling` will return `null` if there\n            // aren't any siblings, and passing `null` to `Node.insertBefore` will\n            // append it to the children of the parent element.\n            parentElm.insertBefore(oldStartVnode.$elm$, oldEndVnode.$elm$.nextSibling);\n            oldStartVnode = oldCh[++oldStartIdx];\n            newEndVnode = newCh[--newEndIdx];\n        }\n        else if (isSameVnode(oldEndVnode, newStartVnode)) {\n            patch(oldEndVnode, newStartVnode);\n            // We've already checked above if `oldStartVnode` and `newStartVnode` are\n            // the same node, so since we're here we know that they are not. Thus we\n            // can move the element for `oldEndVnode` _before_ the element for\n            // `oldStartVnode`, leaving `oldStartVnode` to be reconciled in the\n            // future.\n            parentElm.insertBefore(oldEndVnode.$elm$, oldStartVnode.$elm$);\n            oldEndVnode = oldCh[--oldEndIdx];\n            newStartVnode = newCh[++newStartIdx];\n        }\n        else {\n            {\n                // We either didn't find an element in the old children that matches\n                // the key of the first new child OR the build is not using `key`\n                // attributes at all. In either case we need to create a new element\n                // for the new node.\n                node = createElm(oldCh && oldCh[newStartIdx], newVNode, newStartIdx);\n                newStartVnode = newCh[++newStartIdx];\n            }\n            if (node) {\n                // if we created a new node then handle inserting it to the DOM\n                {\n                    oldStartVnode.$elm$.parentNode.insertBefore(node, oldStartVnode.$elm$);\n                }\n            }\n        }\n    }\n    if (oldStartIdx > oldEndIdx) {\n        // we have some more new nodes to add which don't match up with old nodes\n        addVnodes(parentElm, newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].$elm$, newVNode, newCh, newStartIdx, newEndIdx);\n    }\n    else if (newStartIdx > newEndIdx) {\n        // there are nodes in the `oldCh` array which no longer correspond to nodes\n        // in the new array, so lets remove them (which entails cleaning up the\n        // relevant DOM nodes)\n        removeVnodes(oldCh, oldStartIdx, oldEndIdx);\n    }\n};\n/**\n * Compare two VNodes to determine if they are the same\n *\n * **NB**: This function is an equality _heuristic_ based on the available\n * information set on the two VNodes and can be misleading under certain\n * circumstances. In particular, if the two nodes do not have `key` attrs\n * (available under `$key$` on VNodes) then the function falls back on merely\n * checking that they have the same tag.\n *\n * So, in other words, if `key` attrs are not set on VNodes which may be\n * changing order within a `children` array or something along those lines then\n * we could obtain a false negative and then have to do needless re-rendering\n * (i.e. we'd say two VNodes aren't equal when in fact they should be).\n *\n * @param leftVNode the first VNode to check\n * @param rightVNode the second VNode to check\n * @returns whether they're equal or not\n */\nconst isSameVnode = (leftVNode, rightVNode) => {\n    // compare if two vnode to see if they're \"technically\" the same\n    // need to have the same element tag, and same key to be the same\n    if (leftVNode.$tag$ === rightVNode.$tag$) {\n        return true;\n    }\n    return false;\n};\n/**\n * Handle reconciling an outdated VNode with a new one which corresponds to\n * it. This function handles flushing updates to the DOM and reconciling the\n * children of the two nodes (if any).\n *\n * @param oldVNode an old VNode whose DOM element and children we want to update\n * @param newVNode a new VNode representing an updated version of the old one\n */\nconst patch = (oldVNode, newVNode) => {\n    const elm = (newVNode.$elm$ = oldVNode.$elm$);\n    const oldChildren = oldVNode.$children$;\n    const newChildren = newVNode.$children$;\n    const tag = newVNode.$tag$;\n    const text = newVNode.$text$;\n    if (text === null) {\n        {\n            // test if we're rendering an svg element, or still rendering nodes inside of one\n            // only add this to the when the compiler sees we're using an svg somewhere\n            isSvgMode = tag === 'svg' ? true : tag === 'foreignObject' ? false : isSvgMode;\n        }\n        {\n            {\n                // either this is the first render of an element OR it's an update\n                // AND we already know it's possible it could have changed\n                // this updates the element's css classes, attrs, props, listeners, etc.\n                updateElement(oldVNode, newVNode, isSvgMode);\n            }\n        }\n        if (oldChildren !== null && newChildren !== null) {\n            // looks like there's child vnodes for both the old and new vnodes\n            // so we need to call `updateChildren` to reconcile them\n            updateChildren(elm, oldChildren, newVNode, newChildren);\n        }\n        else if (newChildren !== null) {\n            // no old child vnodes, but there are new child vnodes to add\n            if (oldVNode.$text$ !== null) {\n                // the old vnode was text, so be sure to clear it out\n                elm.textContent = '';\n            }\n            // add the new vnode children\n            addVnodes(elm, null, newVNode, newChildren, 0, newChildren.length - 1);\n        }\n        else if (oldChildren !== null) {\n            // no new child vnodes, but there are old child vnodes to remove\n            removeVnodes(oldChildren, 0, oldChildren.length - 1);\n        }\n        if (isSvgMode && tag === 'svg') {\n            isSvgMode = false;\n        }\n    }\n    else if (oldVNode.$text$ !== text) {\n        // update the text content for the text only vnode\n        // and also only if the text is different than before\n        elm.data = text;\n    }\n};\n/**\n * 'Nullify' any VDom `ref` callbacks on a VDom node or its children by\n * calling them with `null`. This signals that the DOM element corresponding to\n * the VDom node has been removed from the DOM.\n *\n * @param vNode a virtual DOM node\n */\nconst nullifyVNodeRefs = (vNode) => {\n    {\n        vNode.$attrs$ && vNode.$attrs$.ref && vNode.$attrs$.ref(null);\n        vNode.$children$ && vNode.$children$.map(nullifyVNodeRefs);\n    }\n};\n/**\n * The main entry point for Stencil's virtual DOM-based rendering engine\n *\n * Given a {@link d.HostRef} container and some virtual DOM nodes, this\n * function will handle creating a virtual DOM tree with a single root, patching\n * the current virtual DOM tree onto an old one (if any), dealing with slot\n * relocation, and reflecting attributes.\n *\n * @param hostRef data needed to root and render the virtual DOM tree, such as\n * the DOM node into which it should be rendered.\n * @param renderFnResults the virtual DOM nodes to be rendered\n */\nconst renderVdom = (hostRef, renderFnResults) => {\n    const hostElm = hostRef.$hostElement$;\n    const oldVNode = hostRef.$vnode$ || newVNode(null, null);\n    const rootVnode = isHost(renderFnResults) ? renderFnResults : h(null, null, renderFnResults);\n    hostTagName = hostElm.tagName;\n    rootVnode.$tag$ = null;\n    rootVnode.$flags$ |= 4 /* VNODE_FLAGS.isHost */;\n    hostRef.$vnode$ = rootVnode;\n    rootVnode.$elm$ = oldVNode.$elm$ = (hostElm.shadowRoot || hostElm );\n    {\n        scopeId = hostElm['s-sc'];\n    }\n    // synchronous patch\n    patch(oldVNode, rootVnode);\n};\nconst attachToAncestor = (hostRef, ancestorComponent) => {\n    if (ancestorComponent && !hostRef.$onRenderResolve$ && ancestorComponent['s-p']) {\n        ancestorComponent['s-p'].push(new Promise((r) => (hostRef.$onRenderResolve$ = r)));\n    }\n};\nconst scheduleUpdate = (hostRef, isInitialLoad) => {\n    {\n        hostRef.$flags$ |= 16 /* HOST_FLAGS.isQueuedForUpdate */;\n    }\n    if (hostRef.$flags$ & 4 /* HOST_FLAGS.isWaitingForChildren */) {\n        hostRef.$flags$ |= 512 /* HOST_FLAGS.needsRerender */;\n        return;\n    }\n    attachToAncestor(hostRef, hostRef.$ancestorComponent$);\n    // there is no ancestor component or the ancestor component\n    // has already fired off its lifecycle update then\n    // fire off the initial update\n    const dispatch = () => dispatchHooks(hostRef, isInitialLoad);\n    return writeTask(dispatch) ;\n};\n/**\n * Dispatch initial-render and update lifecycle hooks, enqueuing calls to\n * component lifecycle methods like `componentWillLoad` as well as\n * {@link updateComponent}, which will kick off the virtual DOM re-render.\n *\n * @param hostRef a reference to a host DOM node\n * @param isInitialLoad whether we're on the initial load or not\n * @returns an empty Promise which is used to enqueue a series of operations for\n * the component\n */\nconst dispatchHooks = (hostRef, isInitialLoad) => {\n    const endSchedule = createTime('scheduleUpdate', hostRef.$cmpMeta$.$tagName$);\n    const instance = hostRef.$lazyInstance$ ;\n    // We're going to use this variable together with `enqueue` to implement a\n    // little promise-based queue. We start out with it `undefined`. When we add\n    // the first function to the queue we'll set this variable to be that\n    // function's return value. When we attempt to add subsequent values to the\n    // queue we'll check that value and, if it was a `Promise`, we'll then chain\n    // the new function off of that `Promise` using `.then()`. This will give our\n    // queue two nice properties:\n    //\n    // 1. If all functions added to the queue are synchronous they'll be called\n    //    synchronously right away.\n    // 2. If all functions added to the queue are asynchronous they'll all be\n    //    called in order after `dispatchHooks` exits.\n    let maybePromise;\n    if (isInitialLoad) {\n        {\n            hostRef.$flags$ |= 256 /* HOST_FLAGS.isListenReady */;\n            if (hostRef.$queuedListeners$) {\n                hostRef.$queuedListeners$.map(([methodName, event]) => safeCall(instance, methodName, event));\n                hostRef.$queuedListeners$ = undefined;\n            }\n        }\n    }\n    endSchedule();\n    return enqueue(maybePromise, () => updateComponent(hostRef, instance, isInitialLoad));\n};\n/**\n * This function uses a Promise to implement a simple first-in, first-out queue\n * of functions to be called.\n *\n * The queue is ordered on the basis of the first argument. If it's\n * `undefined`, then nothing is on the queue yet, so the provided function can\n * be called synchronously (although note that this function may return a\n * `Promise`). The idea is that then the return value of that enqueueing\n * operation is kept around, so that if it was a `Promise` then subsequent\n * functions can be enqueued by calling this function again with that `Promise`\n * as the first argument.\n *\n * @param maybePromise either a `Promise` which should resolve before the next function is called or an 'empty' sentinel\n * @param fn a function to enqueue\n * @returns either a `Promise` or the return value of the provided function\n */\nconst enqueue = (maybePromise, fn) => isPromisey(maybePromise) ? maybePromise.then(fn) : fn();\n/**\n * Check that a value is a `Promise`. To check, we first see if the value is an\n * instance of the `Promise` global. In a few circumstances, in particular if\n * the global has been overwritten, this is could be misleading, so we also do\n * a little 'duck typing' check to see if the `.then` property of the value is\n * defined and a function.\n *\n * @param maybePromise it might be a promise!\n * @returns whether it is or not\n */\nconst isPromisey = (maybePromise) => maybePromise instanceof Promise ||\n    (maybePromise && maybePromise.then && typeof maybePromise.then === 'function');\nconst updateComponent = async (hostRef, instance, isInitialLoad) => {\n    var _a;\n    const elm = hostRef.$hostElement$;\n    const endUpdate = createTime('update', hostRef.$cmpMeta$.$tagName$);\n    const rc = elm['s-rc'];\n    if (isInitialLoad) {\n        // DOM WRITE!\n        attachStyles(hostRef);\n    }\n    const endRender = createTime('render', hostRef.$cmpMeta$.$tagName$);\n    {\n        callRender(hostRef, instance);\n    }\n    if (rc) {\n        // ok, so turns out there are some child host elements\n        // waiting on this parent element to load\n        // let's fire off all update callbacks waiting\n        rc.map((cb) => cb());\n        elm['s-rc'] = undefined;\n    }\n    endRender();\n    endUpdate();\n    {\n        const childrenPromises = (_a = elm['s-p']) !== null && _a !== void 0 ? _a : [];\n        const postUpdate = () => postUpdateComponent(hostRef);\n        if (childrenPromises.length === 0) {\n            postUpdate();\n        }\n        else {\n            Promise.all(childrenPromises).then(postUpdate);\n            hostRef.$flags$ |= 4 /* HOST_FLAGS.isWaitingForChildren */;\n            childrenPromises.length = 0;\n        }\n    }\n};\nconst callRender = (hostRef, instance, elm) => {\n    try {\n        instance = instance.render() ;\n        {\n            hostRef.$flags$ &= ~16 /* HOST_FLAGS.isQueuedForUpdate */;\n        }\n        {\n            hostRef.$flags$ |= 2 /* HOST_FLAGS.hasRendered */;\n        }\n        {\n            {\n                // looks like we've got child nodes to render into this host element\n                // or we need to update the css class/attrs on the host element\n                // DOM WRITE!\n                {\n                    renderVdom(hostRef, instance);\n                }\n            }\n        }\n    }\n    catch (e) {\n        consoleError(e, hostRef.$hostElement$);\n    }\n    return null;\n};\nconst postUpdateComponent = (hostRef) => {\n    const tagName = hostRef.$cmpMeta$.$tagName$;\n    const elm = hostRef.$hostElement$;\n    const endPostUpdate = createTime('postUpdate', tagName);\n    const instance = hostRef.$lazyInstance$ ;\n    const ancestorComponent = hostRef.$ancestorComponent$;\n    if (!(hostRef.$flags$ & 64 /* HOST_FLAGS.hasLoadedComponent */)) {\n        hostRef.$flags$ |= 64 /* HOST_FLAGS.hasLoadedComponent */;\n        {\n            // DOM WRITE!\n            addHydratedFlag(elm);\n        }\n        {\n            safeCall(instance, 'componentDidLoad');\n        }\n        endPostUpdate();\n        {\n            hostRef.$onReadyResolve$(elm);\n            if (!ancestorComponent) {\n                appDidLoad();\n            }\n        }\n    }\n    else {\n        endPostUpdate();\n    }\n    {\n        hostRef.$onInstanceResolve$(elm);\n    }\n    // load events fire from bottom to top\n    // the deepest elements load first then bubbles up\n    {\n        if (hostRef.$onRenderResolve$) {\n            hostRef.$onRenderResolve$();\n            hostRef.$onRenderResolve$ = undefined;\n        }\n        if (hostRef.$flags$ & 512 /* HOST_FLAGS.needsRerender */) {\n            nextTick(() => scheduleUpdate(hostRef, false));\n        }\n        hostRef.$flags$ &= ~(4 /* HOST_FLAGS.isWaitingForChildren */ | 512 /* HOST_FLAGS.needsRerender */);\n    }\n    // ( •_•)\n    // ( •_•)>⌐■-■\n    // (⌐■_■)\n};\nconst forceUpdate = (ref) => {\n    {\n        const hostRef = getHostRef(ref);\n        const isConnected = hostRef.$hostElement$.isConnected;\n        if (isConnected &&\n            (hostRef.$flags$ & (2 /* HOST_FLAGS.hasRendered */ | 16 /* HOST_FLAGS.isQueuedForUpdate */)) === 2 /* HOST_FLAGS.hasRendered */) {\n            scheduleUpdate(hostRef, false);\n        }\n        // Returns \"true\" when the forced update was successfully scheduled\n        return isConnected;\n    }\n};\nconst appDidLoad = (who) => {\n    // on appload\n    // we have finish the first big initial render\n    {\n        addHydratedFlag(doc.documentElement);\n    }\n    nextTick(() => emitEvent(win, 'appload', { detail: { namespace: NAMESPACE } }));\n};\nconst safeCall = (instance, method, arg) => {\n    if (instance && instance[method]) {\n        try {\n            return instance[method](arg);\n        }\n        catch (e) {\n            consoleError(e);\n        }\n    }\n    return undefined;\n};\nconst addHydratedFlag = (elm) => elm.classList.add('hydrated')\n    ;\nconst getValue = (ref, propName) => getHostRef(ref).$instanceValues$.get(propName);\nconst setValue = (ref, propName, newVal, cmpMeta) => {\n    // check our new property value against our internal value\n    const hostRef = getHostRef(ref);\n    const oldVal = hostRef.$instanceValues$.get(propName);\n    const flags = hostRef.$flags$;\n    const instance = hostRef.$lazyInstance$ ;\n    newVal = parsePropertyValue(newVal, cmpMeta.$members$[propName][0]);\n    // explicitly check for NaN on both sides, as `NaN === NaN` is always false\n    const areBothNaN = Number.isNaN(oldVal) && Number.isNaN(newVal);\n    const didValueChange = newVal !== oldVal && !areBothNaN;\n    if ((!(flags & 8 /* HOST_FLAGS.isConstructingInstance */) || oldVal === undefined) && didValueChange) {\n        // gadzooks! the property's value has changed!!\n        // set our new value!\n        hostRef.$instanceValues$.set(propName, newVal);\n        if (instance) {\n            if ((flags & (2 /* HOST_FLAGS.hasRendered */ | 16 /* HOST_FLAGS.isQueuedForUpdate */)) === 2 /* HOST_FLAGS.hasRendered */) {\n                // looks like this value actually changed, so we've got work to do!\n                // but only if we've already rendered, otherwise just chill out\n                // queue that we need to do an update, but don't worry about queuing\n                // up millions cuz this function ensures it only runs once\n                scheduleUpdate(hostRef, false);\n            }\n        }\n    }\n};\n/**\n * Attach a series of runtime constructs to a compiled Stencil component\n * constructor, including getters and setters for the `@Prop` and `@State`\n * decorators, callbacks for when attributes change, and so on.\n *\n * @param Cstr the constructor for a component that we need to process\n * @param cmpMeta metadata collected previously about the component\n * @param flags a number used to store a series of bit flags\n * @returns a reference to the same constructor passed in (but now mutated)\n */\nconst proxyComponent = (Cstr, cmpMeta, flags) => {\n    if (cmpMeta.$members$) {\n        // It's better to have a const than two Object.entries()\n        const members = Object.entries(cmpMeta.$members$);\n        const prototype = Cstr.prototype;\n        members.map(([memberName, [memberFlags]]) => {\n            if ((memberFlags & 31 /* MEMBER_FLAGS.Prop */ ||\n                    ((flags & 2 /* PROXY_FLAGS.proxyState */) && memberFlags & 32 /* MEMBER_FLAGS.State */))) {\n                // proxyComponent - prop\n                Object.defineProperty(prototype, memberName, {\n                    get() {\n                        // proxyComponent, get value\n                        return getValue(this, memberName);\n                    },\n                    set(newValue) {\n                        // proxyComponent, set value\n                        setValue(this, memberName, newValue, cmpMeta);\n                    },\n                    configurable: true,\n                    enumerable: true,\n                });\n            }\n            else if (flags & 1 /* PROXY_FLAGS.isElementConstructor */ &&\n                memberFlags & 64 /* MEMBER_FLAGS.Method */) {\n                // proxyComponent - method\n                Object.defineProperty(prototype, memberName, {\n                    value(...args) {\n                        const ref = getHostRef(this);\n                        return ref.$onInstancePromise$.then(() => ref.$lazyInstance$[memberName](...args));\n                    },\n                });\n            }\n        });\n        if ((flags & 1 /* PROXY_FLAGS.isElementConstructor */)) {\n            const attrNameToPropName = new Map();\n            prototype.attributeChangedCallback = function (attrName, _oldValue, newValue) {\n                plt.jmp(() => {\n                    const propName = attrNameToPropName.get(attrName);\n                    //  In a web component lifecycle the attributeChangedCallback runs prior to connectedCallback\n                    //  in the case where an attribute was set inline.\n                    //  ```html\n                    //    <my-component some-attribute=\"some-value\"></my-component>\n                    //  ```\n                    //\n                    //  There is an edge case where a developer sets the attribute inline on a custom element and then\n                    //  programmatically changes it before it has been upgraded as shown below:\n                    //\n                    //  ```html\n                    //    <!-- this component has _not_ been upgraded yet -->\n                    //    <my-component id=\"test\" some-attribute=\"some-value\"></my-component>\n                    //    <script>\n                    //      // grab non-upgraded component\n                    //      el = document.querySelector(\"#test\");\n                    //      el.someAttribute = \"another-value\";\n                    //      // upgrade component\n                    //      customElements.define('my-component', MyComponent);\n                    //    </script>\n                    //  ```\n                    //  In this case if we do not unshadow here and use the value of the shadowing property, attributeChangedCallback\n                    //  will be called with `newValue = \"some-value\"` and will set the shadowed property (this.someAttribute = \"another-value\")\n                    //  to the value that was set inline i.e. \"some-value\" from above example. When\n                    //  the connectedCallback attempts to unshadow it will use \"some-value\" as the initial value rather than \"another-value\"\n                    //\n                    //  The case where the attribute was NOT set inline but was not set programmatically shall be handled/unshadowed\n                    //  by connectedCallback as this attributeChangedCallback will not fire.\n                    //\n                    //  https://developers.google.com/web/fundamentals/web-components/best-practices#lazy-properties\n                    //\n                    //  TODO(STENCIL-16) we should think about whether or not we actually want to be reflecting the attributes to\n                    //  properties here given that this goes against best practices outlined here\n                    //  https://developers.google.com/web/fundamentals/web-components/best-practices#avoid-reentrancy\n                    if (this.hasOwnProperty(propName)) {\n                        newValue = this[propName];\n                        delete this[propName];\n                    }\n                    else if (prototype.hasOwnProperty(propName) &&\n                        typeof this[propName] === 'number' &&\n                        this[propName] == newValue) {\n                        // if the propName exists on the prototype of `Cstr`, this update may be a result of Stencil using native\n                        // APIs to reflect props as attributes. Calls to `setAttribute(someElement, propName)` will result in\n                        // `propName` to be converted to a `DOMString`, which may not be what we want for other primitive props.\n                        return;\n                    }\n                    this[propName] = newValue === null && typeof this[propName] === 'boolean' ? false : newValue;\n                });\n            };\n            // create an array of attributes to observe\n            // and also create a map of html attribute name to js property name\n            Cstr.observedAttributes = members\n                .filter(([_, m]) => m[0] & 15 /* MEMBER_FLAGS.HasAttribute */) // filter to only keep props that should match attributes\n                .map(([propName, m]) => {\n                const attrName = m[1] || propName;\n                attrNameToPropName.set(attrName, propName);\n                return attrName;\n            });\n        }\n    }\n    return Cstr;\n};\nconst initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId, Cstr) => {\n    // initializeComponent\n    if ((hostRef.$flags$ & 32 /* HOST_FLAGS.hasInitializedComponent */) === 0) {\n        // Let the runtime know that the component has been initialized\n        hostRef.$flags$ |= 32 /* HOST_FLAGS.hasInitializedComponent */;\n        {\n            // lazy loaded components\n            // request the component's implementation to be\n            // wired up with the host element\n            Cstr = loadModule(cmpMeta);\n            if (Cstr.then) {\n                // Await creates a micro-task avoid if possible\n                const endLoad = uniqueTime();\n                Cstr = await Cstr;\n                endLoad();\n            }\n            if (!Cstr.isProxied) {\n                proxyComponent(Cstr, cmpMeta, 2 /* PROXY_FLAGS.proxyState */);\n                Cstr.isProxied = true;\n            }\n            const endNewInstance = createTime('createInstance', cmpMeta.$tagName$);\n            // ok, time to construct the instance\n            // but let's keep track of when we start and stop\n            // so that the getters/setters don't incorrectly step on data\n            {\n                hostRef.$flags$ |= 8 /* HOST_FLAGS.isConstructingInstance */;\n            }\n            // construct the lazy-loaded component implementation\n            // passing the hostRef is very important during\n            // construction in order to directly wire together the\n            // host element and the lazy-loaded instance\n            try {\n                new Cstr(hostRef);\n            }\n            catch (e) {\n                consoleError(e);\n            }\n            {\n                hostRef.$flags$ &= ~8 /* HOST_FLAGS.isConstructingInstance */;\n            }\n            endNewInstance();\n        }\n        if (Cstr.style) {\n            // this component has styles but we haven't registered them yet\n            let style = Cstr.style;\n            const scopeId = getScopeId(cmpMeta);\n            if (!styles.has(scopeId)) {\n                const endRegisterStyles = createTime('registerStyles', cmpMeta.$tagName$);\n                registerStyle(scopeId, style, !!(cmpMeta.$flags$ & 1 /* CMP_FLAGS.shadowDomEncapsulation */));\n                endRegisterStyles();\n            }\n        }\n    }\n    // we've successfully created a lazy instance\n    const ancestorComponent = hostRef.$ancestorComponent$;\n    const schedule = () => scheduleUpdate(hostRef, true);\n    if (ancestorComponent && ancestorComponent['s-rc']) {\n        // this is the initial load and this component it has an ancestor component\n        // but the ancestor component has NOT fired its will update lifecycle yet\n        // so let's just cool our jets and wait for the ancestor to continue first\n        // this will get fired off when the ancestor component\n        // finally gets around to rendering its lazy self\n        // fire off the initial update\n        ancestorComponent['s-rc'].push(schedule);\n    }\n    else {\n        schedule();\n    }\n};\nconst connectedCallback = (elm) => {\n    if ((plt.$flags$ & 1 /* PLATFORM_FLAGS.isTmpDisconnected */) === 0) {\n        const hostRef = getHostRef(elm);\n        const cmpMeta = hostRef.$cmpMeta$;\n        const endConnected = createTime('connectedCallback', cmpMeta.$tagName$);\n        if (!(hostRef.$flags$ & 1 /* HOST_FLAGS.hasConnected */)) {\n            // first time this component has connected\n            hostRef.$flags$ |= 1 /* HOST_FLAGS.hasConnected */;\n            {\n                // find the first ancestor component (if there is one) and register\n                // this component as one of the actively loading child components for its ancestor\n                let ancestorComponent = elm;\n                while ((ancestorComponent = ancestorComponent.parentNode || ancestorComponent.host)) {\n                    // climb up the ancestors looking for the first\n                    // component that hasn't finished its lifecycle update yet\n                    if (ancestorComponent['s-p']) {\n                        // we found this components first ancestor component\n                        // keep a reference to this component's ancestor component\n                        attachToAncestor(hostRef, (hostRef.$ancestorComponent$ = ancestorComponent));\n                        break;\n                    }\n                }\n            }\n            // Lazy properties\n            // https://developers.google.com/web/fundamentals/web-components/best-practices#lazy-properties\n            if (cmpMeta.$members$) {\n                Object.entries(cmpMeta.$members$).map(([memberName, [memberFlags]]) => {\n                    if (memberFlags & 31 /* MEMBER_FLAGS.Prop */ && elm.hasOwnProperty(memberName)) {\n                        const value = elm[memberName];\n                        delete elm[memberName];\n                        elm[memberName] = value;\n                    }\n                });\n            }\n            {\n                initializeComponent(elm, hostRef, cmpMeta);\n            }\n        }\n        else {\n            // not the first time this has connected\n            // reattach any event listeners to the host\n            // since they would have been removed when disconnected\n            addHostEventListeners(elm, hostRef, cmpMeta.$listeners$);\n        }\n        endConnected();\n    }\n};\nconst disconnectedCallback = (elm) => {\n    if ((plt.$flags$ & 1 /* PLATFORM_FLAGS.isTmpDisconnected */) === 0) {\n        const hostRef = getHostRef(elm);\n        const instance = hostRef.$lazyInstance$ ;\n        {\n            if (hostRef.$rmListeners$) {\n                hostRef.$rmListeners$.map((rmListener) => rmListener());\n                hostRef.$rmListeners$ = undefined;\n            }\n        }\n        {\n            safeCall(instance, 'disconnectedCallback');\n        }\n    }\n};\nconst bootstrapLazy = (lazyBundles, options = {}) => {\n    var _a;\n    const endBootstrap = createTime();\n    const cmpTags = [];\n    const exclude = options.exclude || [];\n    const customElements = win.customElements;\n    const head = doc.head;\n    const metaCharset = /*@__PURE__*/ head.querySelector('meta[charset]');\n    const visibilityStyle = /*@__PURE__*/ doc.createElement('style');\n    const deferredConnectedCallbacks = [];\n    let appLoadFallback;\n    let isBootstrapping = true;\n    Object.assign(plt, options);\n    plt.$resourcesUrl$ = new URL(options.resourcesUrl || './', doc.baseURI).href;\n    lazyBundles.map((lazyBundle) => {\n        lazyBundle[1].map((compactMeta) => {\n            const cmpMeta = {\n                $flags$: compactMeta[0],\n                $tagName$: compactMeta[1],\n                $members$: compactMeta[2],\n                $listeners$: compactMeta[3],\n            };\n            {\n                cmpMeta.$members$ = compactMeta[2];\n            }\n            {\n                cmpMeta.$listeners$ = compactMeta[3];\n            }\n            const tagName = cmpMeta.$tagName$;\n            const HostElement = class extends HTMLElement {\n                // StencilLazyHost\n                constructor(self) {\n                    // @ts-ignore\n                    super(self);\n                    self = this;\n                    registerHost(self, cmpMeta);\n                    if (cmpMeta.$flags$ & 1 /* CMP_FLAGS.shadowDomEncapsulation */) {\n                        // this component is using shadow dom\n                        // and this browser supports shadow dom\n                        // add the read-only property \"shadowRoot\" to the host element\n                        // adding the shadow root build conditionals to minimize runtime\n                        {\n                            {\n                                self.attachShadow({ mode: 'open' });\n                            }\n                        }\n                    }\n                }\n                connectedCallback() {\n                    if (appLoadFallback) {\n                        clearTimeout(appLoadFallback);\n                        appLoadFallback = null;\n                    }\n                    if (isBootstrapping) {\n                        // connectedCallback will be processed once all components have been registered\n                        deferredConnectedCallbacks.push(this);\n                    }\n                    else {\n                        plt.jmp(() => connectedCallback(this));\n                    }\n                }\n                disconnectedCallback() {\n                    plt.jmp(() => disconnectedCallback(this));\n                }\n                componentOnReady() {\n                    return getHostRef(this).$onReadyPromise$;\n                }\n            };\n            cmpMeta.$lazyBundleId$ = lazyBundle[0];\n            if (!exclude.includes(tagName) && !customElements.get(tagName)) {\n                cmpTags.push(tagName);\n                customElements.define(tagName, proxyComponent(HostElement, cmpMeta, 1 /* PROXY_FLAGS.isElementConstructor */));\n            }\n        });\n    });\n    {\n        visibilityStyle.innerHTML = cmpTags + HYDRATED_CSS;\n        visibilityStyle.setAttribute('data-styles', '');\n        // Apply CSP nonce to the style tag if it exists\n        const nonce = (_a = plt.$nonce$) !== null && _a !== void 0 ? _a : queryNonceMetaTagContent(doc);\n        if (nonce != null) {\n            visibilityStyle.setAttribute('nonce', nonce);\n        }\n        head.insertBefore(visibilityStyle, metaCharset ? metaCharset.nextSibling : head.firstChild);\n    }\n    // Process deferred connectedCallbacks now all components have been registered\n    isBootstrapping = false;\n    if (deferredConnectedCallbacks.length) {\n        deferredConnectedCallbacks.map((host) => host.connectedCallback());\n    }\n    else {\n        {\n            plt.jmp(() => (appLoadFallback = setTimeout(appDidLoad, 30)));\n        }\n    }\n    // Fallback appLoad event\n    endBootstrap();\n};\nconst addHostEventListeners = (elm, hostRef, listeners, attachParentListeners) => {\n    if (listeners) {\n        listeners.map(([flags, name, method]) => {\n            const target = getHostListenerTarget(elm, flags) ;\n            const handler = hostListenerProxy(hostRef, method);\n            const opts = hostListenerOpts(flags);\n            plt.ael(target, name, handler, opts);\n            (hostRef.$rmListeners$ = hostRef.$rmListeners$ || []).push(() => plt.rel(target, name, handler, opts));\n        });\n    }\n};\nconst hostListenerProxy = (hostRef, methodName) => (ev) => {\n    try {\n        {\n            if (hostRef.$flags$ & 256 /* HOST_FLAGS.isListenReady */) {\n                // instance is ready, let's call it's member method for this event\n                hostRef.$lazyInstance$[methodName](ev);\n            }\n            else {\n                (hostRef.$queuedListeners$ = hostRef.$queuedListeners$ || []).push([methodName, ev]);\n            }\n        }\n    }\n    catch (e) {\n        consoleError(e);\n    }\n};\nconst getHostListenerTarget = (elm, flags) => {\n    if (flags & 16 /* LISTENER_FLAGS.TargetBody */)\n        return doc.body;\n    return elm;\n};\n// prettier-ignore\nconst hostListenerOpts = (flags) => (flags & 2 /* LISTENER_FLAGS.Capture */) !== 0;\n/**\n * Assigns the given value to the nonce property on the runtime platform object.\n * During runtime, this value is used to set the nonce attribute on all dynamically created script and style tags.\n * @param nonce The value to be assigned to the platform nonce property.\n * @returns void\n */\nconst setNonce = (nonce) => (plt.$nonce$ = nonce);\nconst hostRefs = /*@__PURE__*/ new WeakMap();\nconst getHostRef = (ref) => hostRefs.get(ref);\nconst registerInstance = (lazyInstance, hostRef) => hostRefs.set((hostRef.$lazyInstance$ = lazyInstance), hostRef);\nconst registerHost = (elm, cmpMeta) => {\n    const hostRef = {\n        $flags$: 0,\n        $hostElement$: elm,\n        $cmpMeta$: cmpMeta,\n        $instanceValues$: new Map(),\n    };\n    {\n        hostRef.$onInstancePromise$ = new Promise((r) => (hostRef.$onInstanceResolve$ = r));\n    }\n    {\n        hostRef.$onReadyPromise$ = new Promise((r) => (hostRef.$onReadyResolve$ = r));\n        elm['s-p'] = [];\n        elm['s-rc'] = [];\n    }\n    addHostEventListeners(elm, hostRef, cmpMeta.$listeners$);\n    return hostRefs.set(elm, hostRef);\n};\nconst isMemberInElement = (elm, memberName) => memberName in elm;\nconst consoleError = (e, el) => (0, console.error)(e, el);\nconst cmpModules = /*@__PURE__*/ new Map();\nconst loadModule = (cmpMeta, hostRef, hmrVersionId) => {\n    // loadModuleImport\n    const exportName = cmpMeta.$tagName$.replace(/-/g, '_');\n    const bundleId = cmpMeta.$lazyBundleId$;\n    const module = cmpModules.get(bundleId) ;\n    if (module) {\n        return module[exportName];\n    }\n    \n    if (!hmrVersionId || !BUILD.hotModuleReplacement) {\n      const processMod = importedModule => {\n        cmpModules.set(bundleId, importedModule);\n        return importedModule[exportName];\n      }\n      switch(bundleId) {\n        \n        case 'pwa-action-sheet':\n          return import(\n            /* webpackMode: \"lazy\" */\n            './pwa-action-sheet.entry.js').then(processMod, consoleError);\n        case 'pwa-camera-modal':\n          return import(\n            /* webpackMode: \"lazy\" */\n            './pwa-camera-modal.entry.js').then(processMod, consoleError);\n        case 'pwa-toast':\n          return import(\n            /* webpackMode: \"lazy\" */\n            './pwa-toast.entry.js').then(processMod, consoleError);\n        case 'pwa-camera-modal-instance':\n          return import(\n            /* webpackMode: \"lazy\" */\n            './pwa-camera-modal-instance.entry.js').then(processMod, consoleError);\n        case 'pwa-camera':\n          return import(\n            /* webpackMode: \"lazy\" */\n            './pwa-camera.entry.js').then(processMod, consoleError);\n      }\n    }\n    return import(\n    /* @vite-ignore */\n    /* webpackInclude: /\\.entry\\.js$/ */\n    /* webpackExclude: /\\.system\\.entry\\.js$/ */\n    /* webpackMode: \"lazy\" */\n    `./${bundleId}.entry.js${''}`).then((importedModule) => {\n        {\n            cmpModules.set(bundleId, importedModule);\n        }\n        return importedModule[exportName];\n    }, consoleError);\n};\nconst styles = /*@__PURE__*/ new Map();\nconst win = typeof window !== 'undefined' ? window : {};\nconst doc = win.document || { head: {} };\nconst plt = {\n    $flags$: 0,\n    $resourcesUrl$: '',\n    jmp: (h) => h(),\n    raf: (h) => requestAnimationFrame(h),\n    ael: (el, eventName, listener, opts) => el.addEventListener(eventName, listener, opts),\n    rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts),\n    ce: (eventName, opts) => new CustomEvent(eventName, opts),\n};\nconst promiseResolve = (v) => Promise.resolve(v);\nconst supportsConstructableStylesheets = /*@__PURE__*/ (() => {\n        try {\n            new CSSStyleSheet();\n            return typeof new CSSStyleSheet().replaceSync === 'function';\n        }\n        catch (e) { }\n        return false;\n    })()\n    ;\nconst queueDomReads = [];\nconst queueDomWrites = [];\nconst queueTask = (queue, write) => (cb) => {\n    queue.push(cb);\n    if (!queuePending) {\n        queuePending = true;\n        if (write && plt.$flags$ & 4 /* PLATFORM_FLAGS.queueSync */) {\n            nextTick(flush);\n        }\n        else {\n            plt.raf(flush);\n        }\n    }\n};\nconst consume = (queue) => {\n    for (let i = 0; i < queue.length; i++) {\n        try {\n            queue[i](performance.now());\n        }\n        catch (e) {\n            consoleError(e);\n        }\n    }\n    queue.length = 0;\n};\nconst flush = () => {\n    // always force a bunch of medium callbacks to run, but still have\n    // a throttle on how many can run in a certain time\n    // DOM READS!!!\n    consume(queueDomReads);\n    // DOM WRITES!!!\n    {\n        consume(queueDomWrites);\n        if ((queuePending = queueDomReads.length > 0)) {\n            // still more to do yet, but we've run out of time\n            // let's let this thing cool off and try again in the next tick\n            plt.raf(flush);\n        }\n    }\n};\nconst nextTick = /*@__PURE__*/ (cb) => promiseResolve().then(cb);\nconst writeTask = /*@__PURE__*/ queueTask(queueDomWrites, true);\n\nexport { Host as H, bootstrapLazy as b, createEvent as c, forceUpdate as f, getElement as g, h, promiseResolve as p, registerInstance as r, setNonce as s };\n"],"mappings":"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","names":["doc","scopeId","isSvgMode","newVNode","h"],"x_google_ignoreList":[0]}