{"version":3,"sources":["node_modules/@header-footer/bahf-header-footer-fallback/dist/esm/index-27a36e79.js"],"sourcesContent":["const NAMESPACE = 'bahf-header-footer-fallback';\nlet scopeId;\nlet isSvgMode = false;\nlet queuePending = false;\nconst win = typeof window !== 'undefined' ? window : {};\nconst doc = win.document || {\n head: {}\n};\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 supportsShadow = true;\nconst promiseResolve = v => Promise.resolve(v);\nconst supportsConstructibleStylesheets = /*@__PURE__*/(() => {\n try {\n new CSSStyleSheet();\n return typeof new CSSStyleSheet().replace === 'function';\n } catch (e) {}\n return false;\n})();\nconst ORG_LOCATION_ID = 'o';\nconst SLOT_NODE_ID = 's';\nconst TEXT_NODE_ID = 't';\nconst HYDRATE_ID = 's-id';\nconst HYDRATED_STYLE_ID = 'sty-id';\nconst HYDRATE_CHILD_ID = 'c-id';\nconst HYDRATED_CSS = '{visibility:hidden}.hydrated{visibility:inherit}';\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 rootAppliedStyles = new WeakMap();\nconst registerStyle = (scopeId, cssText, allowCS) => {\n let style = styles.get(scopeId);\n if (supportsConstructibleStylesheets && allowCS) {\n style = style || new CSSStyleSheet();\n style.replace(cssText);\n } else {\n style = cssText;\n }\n styles.set(scopeId, style);\n};\nconst addStyle = (styleContainerNode, cmpMeta, mode, hostElm) => {\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 /* 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 if (styleContainerNode.host && (styleElm = styleContainerNode.querySelector(`[${HYDRATED_STYLE_ID}=\"${scopeId}\"]`))) {\n // This is only happening on native shadow-dom, do not needs CSS var shim\n styleElm.innerHTML = style;\n } else {\n {\n styleElm = doc.createElement('style');\n styleElm.innerHTML = style;\n }\n styleContainerNode.insertBefore(styleElm, styleContainerNode.querySelector('link'));\n }\n if (appliedStyles) {\n appliedStyles.add(scopeId);\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.getRootNode(), cmpMeta);\n if (flags & 10 /* 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 if (flags & 2 /* scopedCssEncapsulation */) {\n elm.classList.add(scopeId + '-s');\n }\n }\n endAttachStyles();\n};\nconst getScopeId = (cmp, mode) => 'sc-' + cmp.$tagName$;\n/**\n * Default style mode id\n */\n/**\n * Reusable empty obj/array\n * Don't add values to these!!\n */\nconst EMPTY_OBJ = {};\nconst isDef = v => v != null;\nconst isComplexType = o => {\n // https://jsperf.com/typeof-fn-object/5\n o = typeof o;\n return o === 'object' || o === 'function';\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// const stack: any[] = [];\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 } 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 } 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 = typeof classData !== 'object' ? classData : Object.keys(classData).filter(k => classData[k]).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};\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 = {};\nconst isHost = node => node && node.$tag$ === Host;\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 } 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 } 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 } else {\n elm.style[prop] = newValue[prop];\n }\n }\n }\n } else if (memberName === 'ref') {\n // minifier will clean this up\n if (newValue) {\n newValue(elm);\n }\n } else if (!isProp && memberName[0] === 'o' && 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 // // listens for \"click\"\n // // listens for \"Click\"\n // // listens for \"ionChange\"\n // // listens for \"EVENTS\"\n memberName = memberName.slice(3);\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 } 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 } 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 caret when re-assigning the same valued\n if (memberName === 'list') {\n isProp = false;\n } else if (oldValue == null || elm[memberName] != n) {\n elm[memberName] = n;\n }\n } else {\n elm[memberName] = newValue;\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 } else if ((!isProp || flags & 4 /* 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 /* DocumentFragment */ && newVnode.$elm$.host ? newVnode.$elm$.host : 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};\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 } else {\n // create element\n elm = newVNode.$elm$ = doc.createElement(newVNode.$tag$);\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 return elm;\n};\nconst addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) => {\n let containerElm = parentElm;\n let childNode;\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};\nconst removeVnodes = (vnodes, startIdx, endIdx, vnode, elm) => {\n for (; startIdx <= endIdx; ++startIdx) {\n if (vnode = vnodes[startIdx]) {\n elm = vnode.$elm$;\n callNodeRefs(vnode);\n // remove the vnode's element from the dom\n elm.remove();\n }\n }\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 } else if (oldEndVnode == null) {\n oldEndVnode = oldCh[--oldEndIdx];\n } else if (newStartVnode == null) {\n newStartVnode = newCh[++newStartIdx];\n } else if (newEndVnode == null) {\n newEndVnode = newCh[--newEndIdx];\n } else if (isSameVnode(oldStartVnode, newStartVnode)) {\n patch(oldStartVnode, newStartVnode);\n oldStartVnode = oldCh[++oldStartIdx];\n newStartVnode = newCh[++newStartIdx];\n } else if (isSameVnode(oldEndVnode, newEndVnode)) {\n patch(oldEndVnode, newEndVnode);\n oldEndVnode = oldCh[--oldEndIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (isSameVnode(oldStartVnode, newEndVnode)) {\n patch(oldStartVnode, newEndVnode);\n parentElm.insertBefore(oldStartVnode.$elm$, oldEndVnode.$elm$.nextSibling);\n oldStartVnode = oldCh[++oldStartIdx];\n newEndVnode = newCh[--newEndIdx];\n } else if (isSameVnode(oldEndVnode, newStartVnode)) {\n patch(oldEndVnode, newStartVnode);\n parentElm.insertBefore(oldEndVnode.$elm$, oldStartVnode.$elm$);\n oldEndVnode = oldCh[--oldEndIdx];\n newStartVnode = newCh[++newStartIdx];\n } else {\n {\n // new element\n node = createElm(oldCh && oldCh[newStartIdx], newVNode, newStartIdx);\n newStartVnode = newCh[++newStartIdx];\n }\n if (node) {\n {\n oldStartVnode.$elm$.parentNode.insertBefore(node, oldStartVnode.$elm$);\n }\n }\n }\n }\n if (oldStartIdx > oldEndIdx) {\n addVnodes(parentElm, newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].$elm$, newVNode, newCh, newStartIdx, newEndIdx);\n } else if (newStartIdx > newEndIdx) {\n removeVnodes(oldCh, oldStartIdx, oldEndIdx);\n }\n};\nconst isSameVnode = (vnode1, vnode2) => {\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 (vnode1.$tag$ === vnode2.$tag$) {\n return true;\n }\n return false;\n};\nconst patch = (oldVNode, newVNode) => {\n const elm = newVNode.$elm$ = oldVNode.$elm$;\n const oldChildren = oldVNode.$children$;\n const newChildren = newVNode.$children$;\n const text = newVNode.$text$;\n if (text === null) {\n // element node\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 updateChildren(elm, oldChildren, newVNode, newChildren);\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 } 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 } 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};\nconst callNodeRefs = vNode => {\n {\n vNode.$attrs$ && vNode.$attrs$.ref && vNode.$attrs$.ref(null);\n vNode.$children$ && vNode.$children$.map(callNodeRefs);\n }\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 rootVnode.$tag$ = null;\n rootVnode.$flags$ |= 4 /* isHost */;\n hostRef.$vnode$ = rootVnode;\n rootVnode.$elm$ = oldVNode.$elm$ = hostElm;\n {\n scopeId = hostElm['s-sc'];\n }\n // synchronous patch\n patch(oldVNode, rootVnode);\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 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 /* isQueuedForUpdate */;\n }\n if (hostRef.$flags$ & 4 /* isWaitingForChildren */) {\n hostRef.$flags$ |= 512 /* 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};\nconst dispatchHooks = (hostRef, isInitialLoad) => {\n const endSchedule = createTime('scheduleUpdate', hostRef.$cmpMeta$.$tagName$);\n const instance = hostRef.$lazyInstance$;\n let promise;\n if (isInitialLoad) {\n {\n promise = safeCall(instance, 'componentWillLoad');\n }\n }\n endSchedule();\n return then(promise, () => updateComponent(hostRef, instance, isInitialLoad));\n};\nconst updateComponent = async (hostRef, instance, isInitialLoad) => {\n // updateComponent\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 = elm['s-p'];\n const postUpdate = () => postUpdateComponent(hostRef);\n if (childrenPromises.length === 0) {\n postUpdate();\n } else {\n Promise.all(childrenPromises).then(postUpdate);\n hostRef.$flags$ |= 4 /* isWaitingForChildren */;\n childrenPromises.length = 0;\n }\n }\n};\nconst callRender = (hostRef, instance, elm) => {\n try {\n instance = instance.render();\n {\n hostRef.$flags$ &= ~16 /* isQueuedForUpdate */;\n }\n {\n hostRef.$flags$ |= 2 /* 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 } 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 {\n safeCall(instance, 'componentDidRender');\n }\n if (!(hostRef.$flags$ & 64 /* hasLoadedComponent */)) {\n hostRef.$flags$ |= 64 /* hasLoadedComponent */;\n {\n // DOM WRITE!\n addHydratedFlag(elm);\n }\n endPostUpdate();\n {\n hostRef.$onReadyResolve$(elm);\n if (!ancestorComponent) {\n appDidLoad();\n }\n }\n } else {\n endPostUpdate();\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 /* needsRerender */) {\n nextTick(() => scheduleUpdate(hostRef, false));\n }\n hostRef.$flags$ &= ~(4 /* isWaitingForChildren */ | 512 /* needsRerender */);\n }\n // ( •_•)\n // ( •_•)>⌐■-■\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', {\n detail: {\n namespace: NAMESPACE\n }\n }));\n};\nconst safeCall = (instance, method, arg) => {\n if (instance && instance[method]) {\n try {\n return instance[method](arg);\n } catch (e) {\n consoleError(e);\n }\n }\n return undefined;\n};\nconst then = (promise, thenFn) => {\n return promise && promise.then ? promise.then(thenFn) : thenFn();\n};\nconst addHydratedFlag = elm => elm.classList.add('hydrated');\nconst initializeClientHydrate = (hostElm, tagName, hostId, hostRef) => {\n const endHydrate = createTime('hydrateClient', tagName);\n const shadowRoot = hostElm.shadowRoot;\n const childRenderNodes = [];\n const slotNodes = [];\n const shadowRootNodes = null;\n const vnode = hostRef.$vnode$ = newVNode(tagName, null);\n if (!plt.$orgLocNodes$) {\n initializeDocumentHydrate(doc.body, plt.$orgLocNodes$ = new Map());\n }\n hostElm[HYDRATE_ID] = hostId;\n hostElm.removeAttribute(HYDRATE_ID);\n clientHydrate(vnode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, hostElm, hostId);\n childRenderNodes.map(c => {\n const orgLocationId = c.$hostId$ + '.' + c.$nodeId$;\n const orgLocationNode = plt.$orgLocNodes$.get(orgLocationId);\n const node = c.$elm$;\n if (orgLocationNode && supportsShadow && orgLocationNode['s-en'] === '') {\n orgLocationNode.parentNode.insertBefore(node, orgLocationNode.nextSibling);\n }\n if (!shadowRoot) {\n node['s-hn'] = tagName;\n if (orgLocationNode) {\n node['s-ol'] = orgLocationNode;\n node['s-ol']['s-nr'] = node;\n }\n }\n plt.$orgLocNodes$.delete(orgLocationId);\n });\n endHydrate();\n};\nconst clientHydrate = (parentVNode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, node, hostId) => {\n let childNodeType;\n let childIdSplt;\n let childVNode;\n let i;\n if (node.nodeType === 1 /* ElementNode */) {\n childNodeType = node.getAttribute(HYDRATE_CHILD_ID);\n if (childNodeType) {\n // got the node data from the element's attribute\n // `${hostId}.${nodeId}.${depth}.${index}`\n childIdSplt = childNodeType.split('.');\n if (childIdSplt[0] === hostId || childIdSplt[0] === '0') {\n childVNode = {\n $flags$: 0,\n $hostId$: childIdSplt[0],\n $nodeId$: childIdSplt[1],\n $depth$: childIdSplt[2],\n $index$: childIdSplt[3],\n $tag$: node.tagName.toLowerCase(),\n $elm$: node,\n $attrs$: null,\n $children$: null,\n $key$: null,\n $name$: null,\n $text$: null\n };\n childRenderNodes.push(childVNode);\n node.removeAttribute(HYDRATE_CHILD_ID);\n // this is a new child vnode\n // so ensure its parent vnode has the vchildren array\n if (!parentVNode.$children$) {\n parentVNode.$children$ = [];\n }\n // add our child vnode to a specific index of the vnode's children\n parentVNode.$children$[childVNode.$index$] = childVNode;\n // this is now the new parent vnode for all the next child checks\n parentVNode = childVNode;\n if (shadowRootNodes && childVNode.$depth$ === '0') {\n shadowRootNodes[childVNode.$index$] = childVNode.$elm$;\n }\n }\n }\n // recursively drill down, end to start so we can remove nodes\n for (i = node.childNodes.length - 1; i >= 0; i--) {\n clientHydrate(parentVNode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, node.childNodes[i], hostId);\n }\n if (node.shadowRoot) {\n // keep drilling down through the shadow root nodes\n for (i = node.shadowRoot.childNodes.length - 1; i >= 0; i--) {\n clientHydrate(parentVNode, childRenderNodes, slotNodes, shadowRootNodes, hostElm, node.shadowRoot.childNodes[i], hostId);\n }\n }\n } else if (node.nodeType === 8 /* CommentNode */) {\n // `${COMMENT_TYPE}.${hostId}.${nodeId}.${depth}.${index}`\n childIdSplt = node.nodeValue.split('.');\n if (childIdSplt[1] === hostId || childIdSplt[1] === '0') {\n // comment node for either the host id or a 0 host id\n childNodeType = childIdSplt[0];\n childVNode = {\n $flags$: 0,\n $hostId$: childIdSplt[1],\n $nodeId$: childIdSplt[2],\n $depth$: childIdSplt[3],\n $index$: childIdSplt[4],\n $elm$: node,\n $attrs$: null,\n $children$: null,\n $key$: null,\n $name$: null,\n $tag$: null,\n $text$: null\n };\n if (childNodeType === TEXT_NODE_ID) {\n childVNode.$elm$ = node.nextSibling;\n if (childVNode.$elm$ && childVNode.$elm$.nodeType === 3 /* TextNode */) {\n childVNode.$text$ = childVNode.$elm$.textContent;\n childRenderNodes.push(childVNode);\n // remove the text comment since it's no longer needed\n node.remove();\n if (!parentVNode.$children$) {\n parentVNode.$children$ = [];\n }\n parentVNode.$children$[childVNode.$index$] = childVNode;\n if (shadowRootNodes && childVNode.$depth$ === '0') {\n shadowRootNodes[childVNode.$index$] = childVNode.$elm$;\n }\n }\n } else if (childVNode.$hostId$ === hostId) {\n // this comment node is specifcally for this host id\n if (childNodeType === SLOT_NODE_ID) {\n // `${SLOT_NODE_ID}.${hostId}.${nodeId}.${depth}.${index}.${slotName}`;\n childVNode.$tag$ = 'slot';\n if (childIdSplt[5]) {\n node['s-sn'] = childVNode.$name$ = childIdSplt[5];\n } else {\n node['s-sn'] = '';\n }\n node['s-sr'] = true;\n slotNodes.push(childVNode);\n if (!parentVNode.$children$) {\n parentVNode.$children$ = [];\n }\n parentVNode.$children$[childVNode.$index$] = childVNode;\n }\n }\n }\n } else if (parentVNode && parentVNode.$tag$ === 'style') {\n const vnode = newVNode(null, node.textContent);\n vnode.$elm$ = node;\n vnode.$index$ = '0';\n parentVNode.$children$ = [vnode];\n }\n};\nconst initializeDocumentHydrate = (node, orgLocNodes) => {\n if (node.nodeType === 1 /* ElementNode */) {\n let i = 0;\n for (; i < node.childNodes.length; i++) {\n initializeDocumentHydrate(node.childNodes[i], orgLocNodes);\n }\n if (node.shadowRoot) {\n for (i = 0; i < node.shadowRoot.childNodes.length; i++) {\n initializeDocumentHydrate(node.shadowRoot.childNodes[i], orgLocNodes);\n }\n }\n } else if (node.nodeType === 8 /* CommentNode */) {\n const childIdSplt = node.nodeValue.split('.');\n if (childIdSplt[0] === ORG_LOCATION_ID) {\n orgLocNodes.set(childIdSplt[1] + '.' + childIdSplt[2], node);\n node.nodeValue = '';\n // useful to know if the original location is\n // the root light-dom of a shadow dom component\n node['s-en'] = childIdSplt[3];\n }\n }\n};\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 * \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 & 1 /* 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 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 /* 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 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* 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};\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 /* Prop */ || flags & 2 /* proxyState */ && memberFlags & 32 /* 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 });\n if (flags & 1 /* 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 // \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 // \n // \n // \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 } else if (prototype.hasOwnProperty(propName) && typeof this[propName] === 'number' && 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.filter(([_, m]) => m[0] & 15 /* 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 /* hasInitializedComponent */) === 0) {\n {\n // we haven't initialized this element yet\n hostRef.$flags$ |= 32 /* hasInitializedComponent */;\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 /* 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 /* 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 } catch (e) {\n consoleError(e);\n }\n {\n hostRef.$flags$ &= ~8 /* 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 /* 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 } else {\n schedule();\n }\n};\nconst connectedCallback = elm => {\n if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) {\n const hostRef = getHostRef(elm);\n const cmpMeta = hostRef.$cmpMeta$;\n const endConnected = createTime('connectedCallback', cmpMeta.$tagName$);\n if (!(hostRef.$flags$ & 1 /* hasConnected */)) {\n // first time this component has connected\n hostRef.$flags$ |= 1 /* hasConnected */;\n let hostId;\n {\n hostId = elm.getAttribute(HYDRATE_ID);\n if (hostId) {\n initializeClientHydrate(elm, cmpMeta.$tagName$, hostId, hostRef);\n }\n }\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.nodeType === 1 /* ElementNode */ && ancestorComponent.hasAttribute('s-id') && ancestorComponent['s-p'] || 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 /* 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 endConnected();\n }\n};\nconst disconnectedCallback = elm => {\n if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) {\n getHostRef(elm);\n }\n};\nconst bootstrapLazy = (lazyBundles, options = {}) => {\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 {\n // If the app is already hydrated there is not point to disable the\n // async queue. This will improve the first input delay\n plt.$flags$ |= 2 /* appLoaded */;\n }\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 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 }\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 } 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 /* isElementConstructor */));\n }\n });\n });\n {\n visibilityStyle.innerHTML = cmpTags + HYDRATED_CSS;\n visibilityStyle.setAttribute('data-styles', '');\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 } else {\n {\n plt.jmp(() => appLoadFallback = setTimeout(appDidLoad, 30));\n }\n }\n // Fallback appLoad event\n endBootstrap();\n};\nconst hostRefs = 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.$onReadyPromise$ = new Promise(r => hostRef.$onReadyResolve$ = r);\n elm['s-p'] = [];\n elm['s-rc'] = [];\n }\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 /*!__STENCIL_STATIC_IMPORT_SWITCH__*/\n return import(/* @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 = new Map();\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 /* queueSync */) {\n nextTick(flush);\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 } 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);\nexport { Host as H, bootstrapLazy as b, h, promiseResolve as p, registerInstance as r };"],"mappings":"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","names":["NAMESPACE","scopeId","isSvgMode","queuePending","win","doc","plt","h","el","eventName","listener","opts","supportsShadow","promiseResolve","v","supportsConstructibleStylesheets","ORG_LOCATION_ID","SLOT_NODE_ID","TEXT_NODE_ID","HYDRATE_ID","HYDRATED_STYLE_ID","HYDRATE_CHILD_ID","HYDRATED_CSS","createTime","fnName","tagName","uniqueTime","key","measureText","rootAppliedStyles","registerStyle","cssText","allowCS","style","styles","addStyle","styleContainerNode","cmpMeta","mode","hostElm","getScopeId","appliedStyles","styleElm","attachStyles","hostRef","elm","flags","endAttachStyles","cmp","EMPTY_OBJ","isDef","isComplexType","o","nodeName","vnodeData","children","child","simple","lastSimple","vNodeChildren","walk","c","i","newVNode","classData","k","vnode","tag","text","Host","isHost","node","setAccessor","memberName","oldValue","newValue","isSvg","isProp","isMemberInElement","ln","classList","oldClasses","parseClassList","newClasses","prop","isComplex","n","parseClassListRegex","value","updateElement","oldVnode","newVnode","oldVnodeAttrs","newVnodeAttrs","createElm","oldParentVNode","newParentVNode","childIndex","parentElm","childNode","addVnodes","before","parentVNode","vnodes","startIdx","endIdx","containerElm","removeVnodes","callNodeRefs","updateChildren","oldCh","newCh","oldStartIdx","newStartIdx","oldEndIdx","oldStartVnode","oldEndVnode","newEndIdx","newStartVnode","newEndVnode","isSameVnode","patch","vnode1","vnode2","oldVNode","oldChildren","newChildren","vNode","renderVdom","renderFnResults","rootVnode","emitEvent","name","ev","attachToAncestor","ancestorComponent","r","scheduleUpdate","isInitialLoad","writeTask","dispatchHooks","endSchedule","instance","promise","safeCall","then","updateComponent","__async","endUpdate","rc","endRender","callRender","cb","childrenPromises","postUpdate","postUpdateComponent","e","consoleError","endPostUpdate","addHydratedFlag","appDidLoad","nextTick","who","method","arg","thenFn","initializeClientHydrate","hostId","endHydrate","shadowRoot","childRenderNodes","slotNodes","shadowRootNodes","initializeDocumentHydrate","clientHydrate","orgLocationId","orgLocationNode","childNodeType","childIdSplt","childVNode","orgLocNodes","parsePropertyValue","propValue","propType","getValue","ref","propName","getHostRef","setValue","newVal","oldVal","areBothNaN","didValueChange","proxyComponent","Cstr","members","prototype","memberFlags","attrNameToPropName","attrName","_oldValue","_","m","initializeComponent","hmrVersionId","loadModule","endLoad","endNewInstance","endRegisterStyles","schedule","connectedCallback","endConnected","disconnectedCallback","bootstrapLazy","lazyBundles","options","endBootstrap","cmpTags","exclude","customElements","head","metaCharset","visibilityStyle","deferredConnectedCallbacks","appLoadFallback","isBootstrapping","lazyBundle","compactMeta","HostElement","self","registerHost","host","hostRefs","registerInstance","lazyInstance","cmpModules","exportName","bundleId","module","globImport_entry_js","importedModule","queueDomReads","queueDomWrites","queueTask","queue","write","flush","consume"],"x_google_ignoreList":[0]}