https://www.postauto.ch/assets/paf-timetable/1.18.0/esm/index-Dqx-QtpR.js

24// src/utils/es2022-rewire-class-members.ts
25var reWireGetterSetter = (instance, hostRef) => {
26  var _a;
27  const cmpMeta = hostRef.$cmpMeta$;
28  const members = Object.entries((_a = cmpMeta.$members$) != null ? _a : {});
29  members.map(([memberName, [memberFlags]]) => {
30    if ((memberFlags & 31 /* Prop */ || memberFlags & 32 /* State */)) {
31      const ogValue = instance[memberName];
32      const ogDescriptor = getPropertyDescriptor(Object.getPrototypeOf(instance), memberName, true) || Object.getOwnPropertyDescriptor(instance, memberName);
33      if (ogDescriptor) {
34        Object.defineProperty(instance, memberName, {
35          get() {
36            return ogDescriptor.get.call(this);
37          },
38          set(newValue) {
39            ogDescriptor.set.call(this, newValue);
40          },
41          configurable: true,
42          enumerable: true
43        });
44      }
45      if (hostRef.$instanceValues$.has(memberName)) {
46        instance[memberName] = hostRef.$instanceValues$.get(memberName);
47      } else if (ogValue !== void 0) {
48        instance[memberName] = ogValue;
49      }
50    }
51  });
52};
53
54// src/client/client-host-ref.ts
55var getHostRef = (ref) => {
56  if (ref.__stencil__getHostRef) {
57    return ref.__stencil__getHostRef();
58  }
59  return void 0;
60};
61var registerInstance = (lazyInstance, hostRef) => {
62  if (!hostRef) return;
63  lazyInstance.__stencil__getHostRef = () => hostRef;
64  hostRef.$lazyInstance$ = lazyInstance;
65  if (hostRef.$cmpMeta$.$flags$ & 512 /* hasModernPropertyDecls */ && (BUILD.state)) {
66    reWireGetterSetter(lazyInstance, hostRef);
67  }
68};
69var registerHost = (hostElement, cmpMeta) => {
70  const hostRef = {
71    $flags$: 0,
72    $hostElement$: hostElement,
73    $cmpMeta$: cmpMeta,
74    $instanceValues$: /* @__PURE__ */ new Map(),
75    $serializerValues$: /* @__PURE__ */ new Map()
76  };
77  {
78    hostRef.$onReadyPromise$ = new Promise((r) => hostRef.$onReadyResolve$ = r);
79    hostElement["s-p"] = [];
80    hostElement["s-rc"] = [];
81  }
82  {
83    hostRef.$fetchedCbList$ = [];
84  }
85  const ref = hostRef;
86  hostElement.__stencil__getHostRef = () => ref;
87  return ref;
88};
89var isMemberInElement = (elm, memberName) => memberName in elm;
90var consoleError = (e, el) => (0, console.error)(e, el);
91

124// src/client/client-style.ts
125var styles = /* @__PURE__ */ new Map();
126var HYDRATED_CSS = "{visibility:hidden}.hydrated{visibility:inherit}";
127var SLOT_FB_CSS = "slot-fb{display:contents}slot-fb[hidden]{display:none}";
128var XLINK_NS = "http://www.w3.org/1999/xlink";
129var win = typeof window !== "undefined" ? window : {};
130var plt = {
131  $flags$: 0,
132  $resourcesUrl$: "",
133  jmp: (h2) => h2(),
134  raf: (h2) => requestAnimationFrame(h2),
135  ael: (el, eventName, listener, opts) => el.addEventListener(eventName, listener, opts),
136  rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts),
137  ce: (eventName, opts) => new CustomEvent(eventName, opts)
138};
139var supportsListenerOptions = /* @__PURE__ */ (() => {
140  var _a;
141  let supportsListenerOptions2 = false;
142  try {
143    (_a = win.document) == null ? void 0 : _a.addEventListener(
144      "e",
145      null,
146      Object.defineProperty({}, "passive", {
147        get() {
148          supportsListenerOptions2 = true;
149        }
150      })
151    );
152  } catch (e) {
153  }
154  return supportsListenerOptions2;
155})();
156var promiseResolve = (v) => Promise.resolve(v);
157var supportsConstructableStylesheets = /* @__PURE__ */ (() => {
158  try {
159    if (!win.document.adoptedStyleSheets) {
160      return false;
161    }
162    new CSSStyleSheet();
163    return typeof new CSSStyleSheet().replaceSync === "function";
164  } catch (e) {
165  }
166  return false;
167})() ;
168var supportsMutableAdoptedStyleSheets = supportsConstructableStylesheets ? /* @__PURE__ */ (() => !!win.document && Object.getOwnPropertyDescriptor(win.document.adoptedStyleSheets, "length").writable)() : false;
169var queuePending = false;
170var queueDomReads = [];
171var queueDomWrites = [];
172var queueTask = (queue, write) => (cb) => {
173  queue.push(cb);
174  if (!queuePending) {
175    queuePending = true;
176    if (write && plt.$flags$ & 4 /* queueSync */) {
177      nextTick(flush);
178    } else {
179      plt.raf(flush);
180    }
181  }
182};
183var consume = (queue) => {
184  for (let i2 = 0; i2 < queue.length; i2++) {
185    try {
186      queue[i2](performance.now());
187    } catch (e) {
188      consoleError(e);
189    }
190  }
191  queue.length = 0;
192};
193var flush = () => {
194  consume(queueDomReads);
195  {
196    consume(queueDomWrites);
197    if (queuePending = queueDomReads.length > 0) {
198      plt.raf(flush);
199    }
200  }
201};
202var nextTick = (cb) => promiseResolve().then(cb);
203var writeTask = /* @__PURE__ */ queueTask(queueDomWrites, true);
204

217// src/utils/shadow-root.ts
218var globalStyleSheet;
219function createShadowRoot(cmpMeta) {
220  var _a;
221  const opts = { mode: "open" };
222  const shadowRoot = this.attachShadow(opts);
223  if (globalStyleSheet === void 0) globalStyleSheet = (_a = createStyleSheetIfNeededAndSupported()) != null ? _a : null;
224  if (globalStyleSheet) {
225    if (supportsMutableAdoptedStyleSheets) {
226      shadowRoot.adoptedStyleSheets.push(globalStyleSheet);
227    } else {
228      shadowRoot.adoptedStyleSheets = [...shadowRoot.adoptedStyleSheets, globalStyleSheet];
229    }
230  }
231}
232var createTime = (fnName, tagName = "") => {
233  {
234    return () => {
235      return;
236    };
237  }
238};
239var uniqueTime = (key, measureText) => {
240  {
241    return () => {
242      return;
243    };
244  }
245};
246

253// src/runtime/styles.ts
254var rootAppliedStyles = /* @__PURE__ */ new WeakMap();
255var registerStyle = (scopeId2, cssText, allowCS) => {
256  let style = styles.get(scopeId2);
257  if (supportsConstructableStylesheets && allowCS) {
258    style = style || new CSSStyleSheet();
259    if (typeof style === "string") {
260      style = cssText;
261    } else {
262      style.replaceSync(cssText);
263    }
264  } else {
265    style = cssText;
266  }
267  styles.set(scopeId2, style);
268};
269var addStyle = (styleContainerNode, cmpMeta, mode) => {
270  var _a, _b, _c;
271  const scopeId2 = getScopeId(cmpMeta);
272  const style = styles.get(scopeId2);
273  if (!win.document) {
274    return scopeId2;
275  }
276  styleContainerNode = styleContainerNode.nodeType === 11 /* DocumentFragment */ ? styleContainerNode : win.document;
277  if (style) {
278    if (typeof style === "string") {
279      styleContainerNode = styleContainerNode.head || styleContainerNode;
280      let appliedStyles = rootAppliedStyles.get(styleContainerNode);
281      let styleElm;
282      if (!appliedStyles) {
283        rootAppliedStyles.set(styleContainerNode, appliedStyles = /* @__PURE__ */ new Set());
284      }
285      if (!appliedStyles.has(scopeId2)) {
286        styleElm = win.document.createElement("style");
287        styleElm.textContent = style;
288        const nonce = (_a = plt.$nonce$) != null ? _a : queryNonceMetaTagContent(win.document);
289        if (nonce != null) {
290          styleElm.setAttribute("nonce", nonce);
291        }
292        if (!(cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */)) {
293          if (styleContainerNode.nodeName === "HEAD") {
294            const preconnectLinks = styleContainerNode.querySelectorAll("link[rel=preconnect]");
295            const referenceNode2 = preconnectLinks.length > 0 ? preconnectLinks[preconnectLinks.length - 1].nextSibling : styleContainerNode.querySelector("style");
296            styleContainerNode.insertBefore(
297              styleElm,
298              (referenceNode2 == null ? void 0 : referenceNode2.parentNode) === styleContainerNode ? referenceNode2 : null
299            );
300          } else if ("host" in styleContainerNode) {
301            if (supportsConstructableStylesheets) {
302              const currentWindow = (_b = styleContainerNode.defaultView) != null ? _b : styleContainerNode.ownerDocument.defaultView;
303              const stylesheet = new currentWindow.CSSStyleSheet();
304              stylesheet.replaceSync(style);
305              if (supportsMutableAdoptedStyleSheets) {
306                styleContainerNode.adoptedStyleSheets.unshift(stylesheet);
307              } else {
308                styleContainerNode.adoptedStyleSheets = [stylesheet, ...styleContainerNode.adoptedStyleSheets];
309              }
310            } else {
311              const existingStyleContainer = styleContainerNode.querySelector("style");
312              if (existingStyleContainer && true) {
313                existingStyleContainer.textContent = style + existingStyleContainer.textContent;
314              } else {
315                styleContainerNode.prepend(styleElm);
316              }
317            }
318          } else {
319            styleContainerNode.append(styleElm);
320          }
321        }
322        if (cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) {
323          styleContainerNode.insertBefore(styleElm, null);
324        }
325        if (cmpMeta.$flags$ & 4 /* hasSlotRelocation */) {
326          styleElm.textContent += SLOT_FB_CSS;
327        }
328        if (appliedStyles) {
329          appliedStyles.add(scopeId2);
330        }
331      }
332    } else {
333      let appliedStyles = rootAppliedStyles.get(styleContainerNode);
334      if (!appliedStyles) {
335        rootAppliedStyles.set(styleContainerNode, appliedStyles = /* @__PURE__ */ new Set());
336      }
337      if (!appliedStyles.has(scopeId2)) {
338        const currentWindow = (_c = styleContainerNode.defaultView) != null ? _c : styleContainerNode.ownerDocument.defaultView;
339        let stylesheet;
340        if (style.constructor === currentWindow.CSSStyleSheet) {
341          stylesheet = style;
342        } else {
343          stylesheet = new currentWindow.CSSStyleSheet();
344          for (let i2 = 0; i2 < style.cssRules.length; i2++) {
345            stylesheet.insertRule(style.cssRules[i2].cssText, i2);
346          }
347        }
348        if (supportsMutableAdoptedStyleSheets) {
349          styleContainerNode.adoptedStyleSheets.push(stylesheet);
350        } else {
351          styleContainerNode.adoptedStyleSheets = [...styleContainerNode.adoptedStyleSheets, stylesheet];
352        }
353        appliedStyles.add(scopeId2);
354      }
355    }
356  }
357  return scopeId2;
358};
359var attachStyles = (hostRef) => {
360  const cmpMeta = hostRef.$cmpMeta$;
361  const elm = hostRef.$hostElement$;
362  const flags = cmpMeta.$flags$;
363  const endAttachStyles = createTime("attachStyles", cmpMeta.$tagName$);
364  const scopeId2 = addStyle(
365    elm.shadowRoot ? elm.shadowRoot : elm.getRootNode(),
366    cmpMeta);
367  if (flags & 10 /* needsScopedEncapsulation */) {
368    elm["s-sc"] = scopeId2;
369    elm.classList.add(scopeId2 + "-h");
370  }
371  endAttachStyles();
372};
373var getScopeId = (cmp, mode) => "sc-" + (cmp.$tagName$);
374var isComplexType = (o) => {
375  o = typeof o;
376  return o === "object" || o === "function";
377};
378

379// src/runtime/vdom/h.ts
380var h = (nodeName, vnodeData, ...children) => {
381  if (typeof nodeName === "string") {
382    nodeName = transformTag(nodeName);
383  }
384  let child = null;
385  let key = null;
386  let simple = false;
387  let lastSimple = false;
388  const vNodeChildren = [];
389  const walk = (c) => {
390    for (let i2 = 0; i2 < c.length; i2++) {
391      child = c[i2];
392      if (Array.isArray(child)) {
393        walk(child);
394      } else if (child != null && typeof child !== "boolean") {
395        if (simple = typeof nodeName !== "function" && !isComplexType(child)) {
396          child = String(child);
397        }
398        if (simple && lastSimple) {
399          vNodeChildren[vNodeChildren.length - 1].$text$ += child;
400        } else {
401          vNodeChildren.push(simple ? newVNode(null, child) : child);
402        }
403        lastSimple = simple;
404      }
405    }
406  };
407  walk(children);
408  if (vnodeData) {
409    if (vnodeData.key) {
410      key = vnodeData.key;
411    }
412    {
413      const classData = vnodeData.className || vnodeData.class;
414      if (classData) {
415        vnodeData.class = typeof classData !== "object" ? classData : Object.keys(classData).filter((k) => classData[k]).join(" ");
416      }
417    }
418  }
419  if (typeof nodeName === "function") {
420    return nodeName(
421      vnodeData === null ? {} : vnodeData,
422      vNodeChildren,
423      vdomFnUtils
424    );
425  }
426  const vnode = newVNode(nodeName, null);
427  vnode.$attrs$ = vnodeData;
428  if (vNodeChildren.length > 0) {
429    vnode.$children$ = vNodeChildren;
430  }
431  {
432    vnode.$key$ = key;
433  }
434  return vnode;
435};
436var newVNode = (tag, text) => {
437  const vnode = {
438    $flags$: 0,
439    $tag$: tag,
440    // Normalize undefined to null to prevent rendering "undefined" as text
441    $text$: text != null ? text : null,
442    $elm$: null,
443    $children$: null
444  };
445  {
446    vnode.$attrs$ = null;
447  }
448  {
449    vnode.$key$ = null;
450  }
451  return vnode;
452};
453var Host = {};
454var isHost = (node) => node && node.$tag$ === Host;
455var vdomFnUtils = {
456  forEach: (children, cb) =>

486// src/runtime/normalize-watchers.ts
487var normalizeWatchers = (raw) => {
488  if (!raw) return void 0;
489  const keys = Object.keys(raw);
490  if (keys.length === 0) return void 0;
491  let hasLegacy = false;
492  for (const propName of keys) {
493    if (hasLegacy) break;
494    for (const h2 of raw[propName]) {
495      if (typeof h2 === "string") {
496        hasLegacy = true;
497        break;
498      }
499    }
500  }
501  if (!hasLegacy) return raw;
502  const out = {};
503  for (const propName of keys) {
504    out[propName] = raw[propName].map(
505      (h2) => typeof h2 === "string" ? { [h2]: 0 } : h2
506    );
507  }
508  return out;
509};
510

511// src/runtime/parse-property-value.ts
512var parsePropertyValue = (propValue, propType, isFormAssociated) => {
513  if (propValue != null && !isComplexType(propValue)) {
514    if (propType & 4 /* Boolean */) {
515      {
516        return propValue === "false" ? false : propValue === "" || !!propValue;
517      }
518    }
519    if (propType & 2 /* Number */) {
520      return typeof propValue === "string" ? parseFloat(propValue) : typeof propValue === "number" ? propValue : NaN;
521    }
522    if (propType & 1 /* String */) {
523      return String(propValue);
524    }
525    return propValue;
526  }
527  return propValue;
528};
529var getElement = (ref) => {
530  var _a;
531  return (_a = getHostRef(ref)) == null ? void 0 : _a.$hostElement$ ;
532};
533

534// src/runtime/event-emitter.ts
535var createEvent = (ref, name, flags) => {
536  const elm = getElement(ref);
537  return {
538    emit: (detail) => {
539      return emitEvent(elm, name, {
540        bubbles: true,
541        composed: true,
542        cancelable: true,
543        detail
544      });
545    }
546  };
547};
548var emitEvent = (elm, name, opts) => {
549  const ev = plt.ce(name, opts);
550  elm.dispatchEvent(ev);
551  return ev;
552};
553var setAccessor = (elm, memberName, oldValue, newValue, isSvg, flags, initialRender) => {
554  if (oldValue === newValue) {
555    return;
556  }
557  let isProp = isMemberInElement(elm, memberName);
558  let ln = memberName.toLowerCase();
559  if (memberName === "class") {
560    const classList = elm.classList;
561    const oldClasses = parseClassList(oldValue);
562    let newClasses = parseClassList(newValue);
563    {
564      classList.remove(...oldClasses.filter((c) => c && !newClasses.includes(c)));
565      classList.add(...newClasses.filter((c) => c && !oldClasses.includes(c)));
566    }
567  } else if (memberName === "style") {
568    {
569      for (const prop in oldValue) {
570        if (!newValue || newValue[prop] == null) {
571          if (prop.includes("-")) {
572            elm.style.removeProperty(prop);
573          } else {
574            elm.style[prop] = "";
575          }
576        }
577      }
578    }
579    for (const prop in newValue) {
580      if (!oldValue || newValue[prop] !== oldValue[prop]) {
581        if (prop.includes("-")) {
582          elm.style.setProperty(prop, newValue[prop]);
583        } else {
584          elm.style[prop] = newValue[prop];
585        }
586      }
587    }
588  } else if (memberName === "key") ; else if (memberName === "ref") {
589    if (newValue) {
590      queueRefAttachment(newValue, elm);
591    }
592  } else if ((!isProp ) && memberName[0] === "o" && memberName[1] === "n") {
593    if (memberName[2] === "-") {
594      memberName = memberName.slice(3);
595    } else if (isMemberInElement(win, ln)) {
596      memberName = ln.slice(2);
597    } else {
598      memberName = ln[2] + memberName.slice(3);
599    }
600    if (oldValue || newValue) {
601      const capture = memberName.endsWith(CAPTURE_EVENT_SUFFIX);
602      memberName = memberName.replace(CAPTURE_EVENT_REGEX, "");
603      if (oldValue) {
604        plt.rel(elm, memberName, oldValue, capture);
605      }
606      if (newValue) {
607        plt.ael(elm, memberName, newValue, capture);
608      }
609    }
610  } else if (memberName[0] === "a" && memberName.startsWith("attr:")) {
611    const propName = memberName.slice(5);
612    let attrName;
613    {
614      const hostRef = getHostRef(elm);
615      if (hostRef && hostRef.$cmpMeta$ && hostRef.$cmpMeta$.$members$) {
616        const memberMeta = hostRef.$cmpMeta$.$members$[propName];
617        if (memberMeta && memberMeta[1]) {
618          attrName = memberMeta[1];
619        }
620      }
621    }
622    if (!attrName) {
623      attrName = propName.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
624    }
625    if (newValue == null || newValue === false) {
626      if (newValue !== false || elm.getAttribute(attrName) === "") {
627        elm.removeAttribute(attrName);
628      }
629    } else {
630      elm.setAttribute(attrName, newValue === true ? "" : newValue);
631    }
632    return;
633  } else if (memberName[0] === "p" && memberName.startsWith("prop:")) {
634    const propName = memberName.slice(5);
635    try {
636      elm[propName] = newValue;
637    } catch (e) {
638    }
639    return;
640  } else {
641    const isComplex = isComplexType(newValue);
642    if ((isProp || isComplex && newValue !== null) && !isSvg) {
643      try {
644        if (!elm.tagName.includes("-")) {
645          const n = newValue == null ? "" : newValue;
646          if (memberName === "list") {
647            isProp = false;
648          } else if (oldValue == null || elm[memberName] !== n) {
649            if (typeof elm.__lookupSetter__(memberName) === "function") {
650              elm[memberName] = n;
651            } else {
652              elm.setAttribute(memberName, n);
653            }
654          }
655        } else if (elm[memberName] !== newValue) {
656          elm[memberName] = newValue;
657        }
658      } catch (e) {
659      }
660    }
661    let xlink = false;
662    {
663      if (ln !== (ln = ln.replace(/^xlink\:?/, ""))) {
664        memberName = ln;
665        xlink = true;
666      }
667    }
668    if (newValue == null || newValue === false) {
669      if (newValue !== false || elm.getAttribute(memberName) === "") {
670        if (xlink) {
671          elm.removeAttributeNS(XLINK_NS, memberName);
672        } else {
673          elm.removeAttribute(memberName);
674        }
675      }
676    } else if ((!isProp || flags & 4 /* isHost */ || isSvg) && !isComplex && elm.nodeType === 1 /* ElementNode */) {
677      newValue = newValue === true ? "" : newValue;
678      if (xlink) {
679        elm.setAttributeNS(XLINK_NS, memberName, newValue);
680      } else {
681        elm.setAttribute(memberName, newValue);
682      }
683    }
684  }
685};
686var parseClassListRegex = /\s/;
687var parseClassList = (value) => {
688  if (typeof value === "object" && value && "baseVal" in value) {
689    value = value.baseVal;
690  }
691  if (!value || typeof value !== "string") {
692    return [];
693  }
694  return value.split(parseClassListRegex);
695};
696var CAPTURE_EVENT_SUFFIX = "Capture";
697var CAPTURE_EVENT_REGEX = new RegExp(CAPTURE_EVENT_SUFFIX + "$");
698

699// src/runtime/vdom/update-element.ts
700var updateElement = (oldVnode, newVnode, isSvgMode2, isInitialRender) => {
701  const elm = newVnode.$elm$.nodeType === 11 /* DocumentFragment */ && newVnode.$elm$.host ? newVnode.$elm$.host : newVnode.$elm$;
702  const oldVnodeAttrs = oldVnode && oldVnode.$attrs$ || {};
703  const newVnodeAttrs = newVnode.$attrs$ || {};
704  {
705    for (const memberName of sortedAttrNames(Object.keys(oldVnodeAttrs))) {
706      if (!(memberName in newVnodeAttrs)) {
707        setAccessor(
708          elm,
709          memberName,
710          oldVnodeAttrs[memberName],
711          void 0,
712          isSvgMode2,
713          newVnode.$flags$);
714      }
715    }
716  }
717  for (const memberName of sortedAttrNames(Object.keys(newVnodeAttrs))) {
718    setAccessor(
719      elm,
720      memberName,
721      oldVnodeAttrs[memberName],
722      newVnodeAttrs[memberName],
723      isSvgMode2,
724      newVnode.$flags$);
725  }
726};
727function sortedAttrNames(attrNames) {
728  return attrNames.includes("ref") ? (
729    // we need to sort these to ensure that `'ref'` is the last attr
730    [...attrNames.filter((attr) => attr !== "ref"), "ref"]
731  ) : (
732    // no need to sort, return the original array
733    attrNames
734  );
735}
736var hostTagName;
737var useNativeShadowDom = false;
738var isSvgMode = false;
739var refCallbacksToRemove = [];
740var refCallbacksToAttach = [];
741var createElm = (oldParentVNode, newParentVNode, childIndex) => {
742  const newVNode2 = newParentVNode.$children$[childIndex];
743  let i2 = 0;
744  let elm;
745  let childNode;
746  if (newVNode2.$text$ != null) {
747    elm = newVNode2.$elm$ = win.document.createTextNode(newVNode2.$text$);
748  } else {
749    if (!isSvgMode) {
750      isSvgMode = newVNode2.$tag$ === "svg";
751    }
752    if (!win.document) {
753      throw new Error("You are trying to render a Stencil component in an environment that doesn't support the DOM.");
754    }
755    elm = newVNode2.$elm$ = win.document.createElementNS(
756      isSvgMode ? SVG_NS : HTML_NS,
757      newVNode2.$tag$
758    ) ;
759    if (isSvgMode && newVNode2.$tag$ === "foreignObject") {
760      isSvgMode = false;
761    }
762    {
763      updateElement(null, newVNode2, isSvgMode);
764    }
765    if (newVNode2.$children$) {
766      const appendTarget = newVNode2.$tag$ === "template" ? elm.content : elm;
767      for (i2 = 0; i2 < newVNode2.$children$.length; ++i2) {
768        childNode = createElm(oldParentVNode, newVNode2, i2);
769        if (childNode) {
770          appendTarget.appendChild(childNode);
771        }
772      }
773    }
774    {
775      if (newVNode2.$tag$ === "svg") {
776        isSvgMode = false;
777      } else if (elm.tagName === "foreignObject") {
778        isSvgMode = true;
779      }
780    }
781  }
782  elm["s-hn"] = hostTagName;
783  return elm;
784};
785var relocateToHostRoot = (parentElm) => {
786  plt.$flags$ |= 1 /* isTmpDisconnected */;
787  const host = parentElm.closest(hostTagName.toLowerCase());
788  if (host != null) {
789    const contentRefNode = Array.from(host.__childNodes || host.childNodes).find(
790      (ref) => ref["s-cr"]
791    );
792    const childNodeArray = Array.from(
793      parentElm.__childNodes || parentElm.childNodes
794    );
795    for (const childNode of contentRefNode ? childNodeArray.reverse() : childNodeArray) {
796      if (childNode["s-sh"] != null) {
797        insertBefore(host, childNode, contentRefNode != null ? contentRefNode : null);
798        childNode["s-sh"] = void 0;
799      }
800    }
801  }
802  plt.$flags$ &= -2 /* isTmpDisconnected */;
803};
804var addVnodes = (parentElm, before, parentVNode, vnodes, startIdx, endIdx) => {
805  let containerElm = parentElm;
806  let childNode;
807  if (containerElm.shadowRoot && containerElm.tagName === hostTagName) {
808    containerElm = containerElm.shadowRoot;
809  }
810  if (parentVNode.$tag$ === "template") {
811    containerElm = containerElm.content;
812  }
813  for (; startIdx <= endIdx; ++startIdx) {
814    if (vnodes[startIdx]) {
815      childNode = createElm(null, parentVNode, startIdx);
816      if (childNode) {
817        vnodes[startIdx].$elm$ = childNode;
818        insertBefore(containerElm, childNode, before);
819      }
820    }
821  }
822};
823var removeVnodes = (vnodes, startIdx, endIdx) => {
824  for (let index = startIdx; index <= endIdx; ++index) {
825    const vnode = vnodes[index];
826    if (vnode) {
827      const elm = vnode.$elm$;
828      nullifyVNodeRefs(vnode);
829      if (elm) {
830        elm.remove();
831      }
832    }
833  }
834};
835var updateChildren = (parentElm, oldCh, newVNode2, newCh, isInitialRender = false) => {
836  let oldStartIdx = 0;
837  let newStartIdx = 0;
838  let idxInOld = 0;
839  let i2 = 0;
840  let oldEndIdx = oldCh.length - 1;
841  let oldStartVnode = oldCh[0];
842  let oldEndVnode = oldCh[oldEndIdx];
843  let newEndIdx = newCh.length - 1;
844  let newStartVnode = newCh[0];
845  let newEndVnode = newCh[newEndIdx];
846  let node;
847  let elmToMove;
848  const containerElm = newVNode2.$tag$ === "template" ? parentElm.content : parentElm;
849  while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
850    if (oldStartVnode == null) {
851      oldStartVnode = oldCh[++oldStartIdx];
852    } else if (oldEndVnode == null) {
853      oldEndVnode = oldCh[--oldEndIdx];
854    } else if (newStartVnode == null) {
855      newStartVnode = newCh[++newStartIdx];
856    } else if (newEndVnode == null) {
857      newEndVnode = newCh[--newEndIdx];
858    } else if (isSameVnode(oldStartVnode, newStartVnode, isInitialRender)) {
859      patch(oldStartVnode, newStartVnode, isInitialRender);
860      oldStartVnode = oldCh[++oldStartIdx];
861      newStartVnode = newCh[++newStartIdx];
862    } else if (isSameVnode(oldEndVnode, newEndVnode, isInitialRender)) {
863      patch(oldEndVnode, newEndVnode, isInitialRender);
864      oldEndVnode = oldCh[--oldEndIdx];
865      newEndVnode = newCh[--newEndIdx];
866    } else if (isSameVnode(oldStartVnode, newEndVnode, isInitialRender)) {
867      patch(oldStartVnode, newEndVnode, isInitialRender);
868      insertBefore(containerElm, oldStartVnode.$elm$, oldEndVnode.$elm$.nextSibling);
869      oldStartVnode = oldCh[++oldStartIdx];
870      newEndVnode = newCh[--newEndIdx];
871    } else if (isSameVnode(oldEndVnode, newStartVnode, isInitialRender)) {
872      patch(oldEndVnode, newStartVnode, isInitialRender);
873      insertBefore(containerElm, oldEndVnode.$elm$, oldStartVnode.$elm$);
874      oldEndVnode = oldCh[--oldEndIdx];
875      newStartVnode = newCh[++newStartIdx];
876    } else {
877      idxInOld = -1;
878      {
879        for (i2 = oldStartIdx; i2 <= oldEndIdx; ++i2) {

880          if (oldCh[i2] && oldCh[i2].$key$ !== null && oldCh[i2].$key$ === newStartVnode.$key$) {
881            idxInOld = i2;
882            break;
883          }
884        }
885      }
886      if (idxInOld >= 0) {
887        elmToMove = oldCh[idxInOld];
888        if (elmToMove.$tag$ !== newStartVnode.$tag$) {
889          node = createElm(oldCh && oldCh[newStartIdx], newVNode2, idxInOld);
890        } else {
891          patch(elmToMove, newStartVnode, isInitialRender);
892          oldCh[idxInOld] = void 0;
893          node = elmToMove.$elm$;
894        }
895        newStartVnode = newCh[++newStartIdx];
896      } else {
897        node = createElm(oldCh && oldCh[newStartIdx], newVNode2, newStartIdx);
898        newStartVnode = newCh[++newStartIdx];
899      }
900      if (node) {
901        {
902          insertBefore(oldStartVnode.$elm$.parentNode, node, oldStartVnode.$elm$);
903        }
904      }
905    }
906  }
907  if (oldStartIdx > oldEndIdx) {
908    addVnodes(
909      parentElm,
910      newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].$elm$,
911      newVNode2,
912      newCh,
913      newStartIdx,
914      newEndIdx
915    );
916  } else if (newStartIdx > newEndIdx) {
917    removeVnodes(oldCh, oldStartIdx, oldEndIdx);
918  }
919};
920var isSameVnode = (leftVNode, rightVNode, isInitialRender = false) => {
921  if (leftVNode.$tag$ === rightVNode.$tag$) {
922    if (!isInitialRender) {
923      return leftVNode.$key$ === rightVNode.$key$;
924    }
925    if (isInitialRender && !leftVNode.$key$ && rightVNode.$key$) {
926      leftVNode.$key$ = rightVNode.$key$;
927    }
928    return true;
929  }
930  return false;
931};
932var patch = (oldVNode, newVNode2, isInitialRender = false) => {
933  const elm = newVNode2.$elm$ = oldVNode.$elm$;
934  const oldChildren = oldVNode.$children$;
935  const newChildren = newVNode2.$children$;
936  const tag = newVNode2.$tag$;
937  const text = newVNode2.$text$;
938  if (text == null) {
939    {
940      isSvgMode = tag === "svg" ? true : tag === "foreignObject" ? false : isSvgMode;
941    }
942    {
943      if (tag === "slot" && !useNativeShadowDom) {
944        if (oldVNode.$name$ !== newVNode2.$name$) {
945          newVNode2.$elm$["s-sn"] = newVNode2.$name$ || "";
946          relocateToHostRoot(newVNode2.$elm$.parentElement);
947        }
948      }
949      updateElement(oldVNode, newVNode2, isSvgMode);
950    }
951    if (oldChildren !== null && newChildren !== null) {
952      updateChildren(elm, oldChildren, newVNode2, newChildren, isInitialRender);
953    } else if (newChildren !== null) {
954      if (oldVNode.$text$ !== null) {
955        elm.textContent = "";
956      }
957      addVnodes(elm, null, newVNode2, newChildren, 0, newChildren.length - 1);
958    } else if (
959      // don't do this on initial render as it can cause non-hydrated content to be removed
960      !isInitialRender && BUILD.updatable && oldChildren !== null
961    ) {
962      removeVnodes(oldChildren, 0, oldChildren.length - 1);
963    } else ;
964    if (isSvgMode && tag === "svg") {
965      isSvgMode = false;
966    }
967  } else if (oldVNode.$text$ !== text) {
968    elm.data = text;
969  }
970};
971var nullifyVNodeRefs = (vNode) => {
972  {
973    if (vNode.$attrs$ && vNode.$attrs$.ref) {
974      refCallbacksToRemove.push(() => vNode.$attrs$.ref(null));
975    }
976    vNode.$children$ && vNode.$children$.map(nullifyVNodeRefs);
977  }
978};
979var queueRefAttachment = (refCallback, elm) => {
980  {
981    refCallbacksToAttach.push(() => refCallback(elm));
982  }
983};
984var flushQueuedRefCallbacks = () => {
985  {
986    refCallbacksToRemove.forEach((cb) => cb());
987    refCallbacksToRemove.length = 0;
988    refCallbacksToAttach.forEach((cb) => cb());
989    refCallbacksToAttach.length = 0;
990  }
991};
992var insertBefore = (parent, newNode, reference, isInitialLoad) => {
993  if (parent.__insertBefore) {
994    return parent.__insertBefore(newNode, reference);
995  } else {
996    return parent == null ? void 0 : parent.insertBefore(newNode, reference);
997  }
998};
999var renderVdom = (hostRef, renderFnResults, isInitialLoad = false) => {
1000  const hostElm = hostRef.$hostElement$;
1001  const cmpMeta = hostRef.$cmpMeta$;
1002  const oldVNode = hostRef.$vnode$ || newVNode(null, null);
1003  const isHostElement = isHost(renderFnResults);
1004  const rootVnode = isHostElement ? renderFnResults : h(null, null, renderFnResults);
1005  hostTagName = hostElm.tagName;
1006  if (cmpMeta.$attrsToReflect$) {
1007    rootVnode.$attrs$ = rootVnode.$attrs$ || {};
1008    cmpMeta.$attrsToReflect$.forEach(([propName, attribute]) => {
1009      {
1010        rootVnode.$attrs$[attribute] = hostElm[propName];
1011      }
1012    });

1030// src/runtime/update-component.ts
1031var attachToAncestor = (hostRef, ancestorComponent) => {
1032  if (ancestorComponent && !hostRef.$onRenderResolve$ && ancestorComponent["s-p"]) {
1033    const index = ancestorComponent["s-p"].push(
1034      new Promise(
1035        (r) => hostRef.$onRenderResolve$ = () => {
1036          ancestorComponent["s-p"].splice(index - 1, 1);
1037          r();
1038        }
1039      )
1040    );
1041  }
1042};
1043var scheduleUpdate = (hostRef, isInitialLoad) => {
1044  {
1045    hostRef.$flags$ |= 16 /* isQueuedForUpdate */;
1046  }
1047  if (hostRef.$flags$ & 4 /* isWaitingForChildren */) {
1048    hostRef.$flags$ |= 512 /* needsRerender */;
1049    return;
1050  }
1051  attachToAncestor(hostRef, hostRef.$ancestorComponent$);
1052  const dispatch = () => dispatchHooks(hostRef, isInitialLoad);
1053  if (isInitialLoad) {
1054    queueMicrotask(() => {
1055      dispatch();
1056    });
1057    return;
1058  }
1059  return writeTask(dispatch) ;
1060};
1061var dispatchHooks = (hostRef, isInitialLoad) => {
1062  const elm = hostRef.$hostElement$;
1063  const endSchedule = createTime("scheduleUpdate", hostRef.$cmpMeta$.$tagName$);
1064  const instance = hostRef.$lazyInstance$ ;
1065  if (!instance) {
1066    throw new Error(
1067      `Can't render component <${elm.tagName.toLowerCase()} /> with invalid Stencil runtime! Make sure this imported component is compiled with a \`externalRuntime: true\` flag. For more information, please refer to https://stenciljs.com/docs/custom-elements#externalruntime`
1068    );
1069  }
1070  let maybePromise;
1071  if (isInitialLoad) {
1072    {
1073      {
1074        hostRef.$flags$ |= 256 /* isListenReady */;
1075        if (hostRef.$queuedListeners$) {
1076          hostRef.$queuedListeners$.map(([methodName, event]) => safeCall(instance, methodName, event, elm));
1077          hostRef.$queuedListeners$ = void 0;
1078        }
1079      }
1080      if (hostRef.$fetchedCbList$.length) {
1081        hostRef.$fetchedCbList$.forEach((cb) => cb(elm));
1082      }
1083    }
1084    maybePromise = safeCall(instance, "componentWillLoad", void 0, elm);
1085  } else {
1086    maybePromise = safeCall(instance, "componentWillUpdate", void 0, elm);
1087  }
1088  maybePromise = enqueue(maybePromise, () => safeCall(instance, "componentWillRender", void 0, elm));
1089  endSchedule();
1090  return enqueue(maybePromise, () => updateComponent(hostRef, instance, isInitialLoad));
1091};
1092var enqueue = (maybePromise, fn) => isPromisey(maybePromise) ? maybePromise.then(fn).catch((err) => {
1093  console.error(err);
1094  fn();
1095}) : fn();
1096var isPromisey = (maybePromise) => maybePromise instanceof Promise || maybePromise && maybePromise.then && typeof maybePromise.then === "function";
1097var updateComponent = async (hostRef, instance, isInitialLoad) => {
1098  var _a;
1099  const elm = hostRef.$hostElement$;
1100  const endUpdate = createTime("update", hostRef.$cmpMeta$.$tagName$);
1101  const rc = elm["s-rc"];
1102  if (isInitialLoad) {
1103    attachStyles(hostRef);
1104  }
1105  const endRender = createTime("render", hostRef.$cmpMeta$.$tagName$);
1106  {
1107    callRender(hostRef, instance, elm, isInitialLoad);
1108  }
1109  if (rc) {
1110    rc.map((cb) => cb());
1111    elm["s-rc"] = void 0;
1112  }
1113  endRender();
1114  endUpdate();
1115  {
1116    const childrenPromises = (_a = elm["s-p"]) != null ? _a : [];
1117    const postUpdate = () => postUpdateComponent(hostRef);
1118    if (childrenPromises.length === 0) {
1119      postUpdate();
1120    } else {
1121      Promise.all(childrenPromises).then(postUpdate).catch(postUpdate);
1122      hostRef.$flags$ |= 4 /* isWaitingForChildren */;
1123      childrenPromises.length = 0;
1124    }
1125  }
1126};
1127var callRender = (hostRef, instance, elm, isInitialLoad) => {
1128  try {
1129    instance = instance.render() ;
1130    {
1131      hostRef.$flags$ &= -17 /* isQueuedForUpdate */;
1132    }
1133    {
1134      hostRef.$flags$ |= 2 /* hasRendered */;
1135    }
1136    {
1137      {
1138        {
1139          renderVdom(hostRef, instance, isInitialLoad);
1140        }
1141      }
1142    }
1143  } catch (e) {
1144    consoleError(e, hostRef.$hostElement$);
1145  }
1146  return null;
1147};
1148var postUpdateComponent = (hostRef) => {
1149  const tagName = hostRef.$cmpMeta$.$tagName$;
1150  const elm = hostRef.$hostElement$;
1151  const endPostUpdate = createTime("postUpdate", tagName);

1152  const instance = hostRef.$lazyInstance$ ;
1153  const ancestorComponent = hostRef.$ancestorComponent$;
1154  safeCall(instance, "componentDidRender", void 0, elm);
1155  if (!(hostRef.$flags$ & 64 /* hasLoadedComponent */)) {
1156    hostRef.$flags$ |= 64 /* hasLoadedComponent */;
1157    {
1158      addHydratedFlag(elm);
1159    }
1160    safeCall(instance, "componentDidLoad", void 0, elm);
1161    endPostUpdate();
1162    {
1163      hostRef.$onReadyResolve$(elm);
1164      if (!ancestorComponent) {
1165        appDidLoad();
1166      }
1167    }
1168  } else {
1169    safeCall(instance, "componentDidUpdate", void 0, elm);
1170    endPostUpdate();
1171  }
1172  {
1173    if (hostRef.$onRenderResolve$) {
1174      hostRef.$onRenderResolve$();
1175      hostRef.$onRenderResolve$ = void 0;
1176    }
1177    if (hostRef.$flags$ & 512 /* needsRerender */) {
1178      nextTick(() => scheduleUpdate(hostRef, false));
1179    }
1180    hostRef.$flags$ &= -517;
1181  }
1182};
1183var appDidLoad = (who) => {
1184  nextTick(() => emitEvent(win, "appload", { detail: { namespace: NAMESPACE } }));
1185};
1186var safeCall = (instance, method, arg, elm) => {
1187  if (instance && instance[method]) {
1188    try {
1189      return instance[method](arg);
1190    } catch (e) {
1191      consoleError(e, elm);
1192    }
1193  }
1194  return void 0;
1195};
1196var addHydratedFlag = (elm) => {
1197  var _a;
1198  return elm.classList.add((_a = BUILD.hydratedSelectorName) != null ? _a : "hydrated") ;
1199};
1200
1201// src/runtime/set-value.ts
1202var getValue = (ref, propName) => getHostRef(ref).$instanceValues$.get(propName);
1203var setValue = (ref, propName, newVal, cmpMeta) => {
1204  const hostRef = getHostRef(ref);
1205  if (!hostRef) {
1206    return;
1207  }
1208  if (!hostRef) {
1209    throw new Error(
1210      `Couldn't find host element for "${cmpMeta.$tagName$}" as it is unknown to this Stencil runtime. This usually happens when integrating a 3rd party Stencil component with another Stencil component or application. Please reach out to the maintainers of the 3rd party Stencil component or report this on the Stencil Discord server (https://chat.stenciljs.com) or comment on this similar [GitHub issue](https://github.com/stenciljs/core/issues/5457).`
1211    );
1212  }
1213  const elm = hostRef.$hostElement$ ;
1214  const oldVal = hostRef.$instanceValues$.get(propName);
1215  const flags = hostRef.$flags$;
1216  const instance = hostRef.$lazyInstance$ ;
1217  newVal = parsePropertyValue(
1218    newVal,
1219    cmpMeta.$members$[propName][0]);
1220  const areBothNaN = Number.isNaN(oldVal) && Number.isNaN(newVal);
1221  const didValueChange = newVal !== oldVal && !areBothNaN;
1222  if ((!(flags & 8 /* isConstructingInstance */) || oldVal === void 0) && didValueChange) {
1223    hostRef.$instanceValues$.set(propName, newVal);
1224    if (cmpMeta.$watchers$) {
1225      const watchMethods = cmpMeta.$watchers$[propName];
1226      if (watchMethods) {
1227        watchMethods.map((watcher) => {
1228          try {
1229            const [[watchMethodName, watcherFlags]] = Object.entries(watcher);
1230            if (flags & 128 /* isWatchReady */ || watcherFlags & 1 /* Immediate */) {
1231              if (!instance) {
1232                hostRef.$fetchedCbList$.push(() => {
1233                  hostRef.$lazyInstance$[watchMethodName](newVal, oldVal, propName);
1234                });
1235              } else {
1236                instance[watchMethodName](newVal, oldVal, propName);
1237              }
1238            }
1239          } catch (e) {
1240            consoleError(e, elm);
1241          }
1242        });
1243      }
1244    }
1245    if (flags & 2 /* hasRendered */) {
1246      if (instance.componentShouldUpdate) {
1247        const shouldUpdate = instance.componentShouldUpdate(newVal, oldVal, propName);
1248        if (shouldUpdate === false && !(flags & 16 /* isQueuedForUpdate */)) {
1249          return;
1250        }
1251      }
1252      if (!(flags & 16 /* isQueuedForUpdate */)) {
1253        scheduleUpdate(hostRef, false);
1254      }
1255    }
1256  }
1257};
1258
1259// src/runtime/proxy-component.ts
1260var proxyComponent = (Cstr, cmpMeta, flags) => {
1261  var _a, _b;
1262  const prototype = Cstr.prototype;
1263  if (cmpMeta.$members$ || BUILD.propChangeCallback) {
1264    {
1265      if (Cstr.watchers && !cmpMeta.$watchers$) {
1266        cmpMeta.$watchers$ = normalizeWatchers(Cstr.watchers);
1267      }
1268      if (Cstr.deserializers && !cmpMeta.$deserializers$) {
1269        cmpMeta.$deserializers$ = Cstr.deserializers;
1270      }
1271      if (Cstr.serializers && !cmpMeta.$serializers$) {
1272        cmpMeta.$serializers$ = Cstr.serializers;
1273      }
1274    }
1275    const members = Object.entries((_a = cmpMeta.$members$) != null ? _a : {});
1276    members.map(([memberName, [memberFlags]]) => {
1277      if ((memberFlags & 31 /* Prop */ || (flags & 2 /* proxyState */) && memberFlags & 32 /* State */)) {
1278        const { get: origGetter, set: origSetter } = getPropertyDescriptor(prototype, memberName) || {};
1279        if (origGetter) cmpMeta.$members$[memberName][0] |= 2048 /* Getter */;
1280        if (origSetter) cmpMeta.$members$[memberName][0] |= 4096 /* Setter */;
1281        if (flags & 1 /* isElementConstructor */ || !origGetter) {
1282          Object.defineProperty(prototype, memberName, {
1283            get() {
1284              {
1285                if ((cmpMeta.$members$[memberName][0] & 2048 /* Getter */) === 0) {
1286                  return getValue(this, memberName);
1287                }
1288                const ref = getHostRef(this);
1289                const instance = ref ? ref.$lazyInstance$ : prototype;
1290                if (!instance) return;
1291                return instance[memberName];
1292              }
1293            },
1294            configurable: true,
1295            enumerable: true
1296          });
1297        }
1298        Object.defineProperty(prototype, memberName, {
1299          set(newValue) {
1300            const ref = getHostRef(this);
1301            if (!ref) {
1302              return;
1303            }
1304            if (origSetter) {
1305              const currentValue = memberFlags & 32 /* State */ ? this[memberName] : ref.$hostElement$[memberName];
1306              if (typeof currentValue === "undefined" && ref.$instanceValues$.get(memberName)) {
1307                newValue = ref.$instanceValues$.get(memberName);
1308              }
1309              origSetter.apply(this, [
1310                parsePropertyValue(
1311                  newValue,
1312                  memberFlags)
1313              ]);
1314              newValue = memberFlags & 32 /* State */ ? this[memberName] : ref.$hostElement$[memberName];
1315              setValue(this, memberName, newValue, cmpMeta);
1316              return;
1317            }
1318            {
1319              if ((flags & 1 /* isElementConstructor */) === 0 || (cmpMeta.$members$[memberName][0] & 4096 /* Setter */) === 0) {
1320                setValue(this, memberName, newValue, cmpMeta);
1321                if (flags & 1 /* isElementConstructor */ && !ref.$lazyInstance$) {
1322                  ref.$fetchedCbList$.push(() => {
1323                    if (cmpMeta.$members$[memberName][0] & 4096 /* Setter */ && ref.$lazyInstance$[memberName] !== ref.$instanceValues$.get(memberName)) {
1324                      ref.$lazyInstance$[memberName] = newValue;
1325                    }
1326                  });
1327                }
1328                return;
1329              }
1330              const setterSetVal = () => {
1331                const currentValue = ref.$lazyInstance$[memberName];
1332                if (!ref.$instanceValues$.get(memberName) && currentValue) {
1333                  ref.$instanceValues$.set(memberName, currentValue);
1334                }
1335                ref.$lazyInstance$[memberName] = parsePropertyValue(
1336                  newValue,
1337                  memberFlags);
1338                setValue(this, memberName, ref.$lazyInstance$[memberName], cmpMeta);
1339              };
1340              if (ref.$lazyInstance$) {
1341                setterSetVal();
1342              } else {
1343                ref.$fetchedCbList$.push(() => {
1344                  setterSetVal();
1345                });
1346              }
1347            }
1348          }
1349        });
1350      }
1351    });
1352    if ((flags & 1 /* isElementConstructor */)) {
1353      const attrNameToPropName = /* @__PURE__ */ new Map();
1354      prototype.attributeChangedCallback = function(attrName, oldValue, newValue) {
1355        plt.jmp(() => {
1356          var _a2;
1357          const propName = attrNameToPropName.get(attrName);
1358          const hostRef = getHostRef(this);
1359          if (this.hasOwnProperty(propName) && BUILD.lazyLoad) {
1360            newValue = this[propName];
1361            delete this[propName];
1362          }
1363          if (prototype.hasOwnProperty(propName) && typeof this[propName] === "number" && // cast type to number to avoid TS compiler issues
1364          this[propName] == newValue) {
1365            return;
1366          } else if (propName == null) {
1367            const flags2 = hostRef == null ? void 0 : hostRef.$flags$;
1368            if (hostRef && flags2 && !(flags2 & 8 /* isConstructingInstance */) && newValue !== oldValue) {
1369              const instance = hostRef.$lazyInstance$ ;
1370              const entry = (_a2 = cmpMeta.$watchers$) == null ? void 0 : _a2[attrName];
1371              entry == null ? void 0 : entry.forEach((watcher) => {
1372                const [[watchMethodName, watcherFlags]] = Object.entries(watcher);
1373                if (instance[watchMethodName] != null && (flags2 & 128 /* isWatchReady */ || watcherFlags & 1 /* Immediate */)) {
1374                  instance[watchMethodName].call(instance, newValue, oldValue, attrName);
1375                }
1376              });
1377            }
1378            return;
1379          }
1380          const propFlags = members.find(([m]) => m === propName);
1381          const isBooleanTarget = propFlags && propFlags[1][0] & 4 /* Boolean */;
1382          const isSpuriousBooleanRemoval = isBooleanTarget && newValue === null && this[propName] === void 0;
1383          if (isBooleanTarget) {
1384            newValue = newValue === null || newValue === "false" ? false : true;
1385          }
1386          const propDesc = Object.getOwnPropertyDescriptor(prototype, propName);
1387          if (!isSpuriousBooleanRemoval && newValue != this[propName] && (!propDesc.get || !!propDesc.set)) {
1388            this[propName] = newValue;
1389          }
1390        });
1391      };
1392      Cstr.observedAttributes = Array.from(
1393        /* @__PURE__ */ new Set([
1394          ...Object.keys((_b = cmpMeta.$watchers$) != null ? _b : {}),
1395          ...members.filter(([_, m]) => m[0] & 31 /* HasAttribute */).map(([propName, m]) => {
1396            var _a2;
1397            const attrName = m[1] || propName;
1398            attrNameToPropName.set(attrName, propName);
1399            if (m[0] & 512 /* ReflectAttr */) {
1400              (_a2 = cmpMeta.$attrsToReflect$) == null ? void 0 : _a2.push([propName, attrName]);
1401            }
1402            return attrName;
1403          })
1404        ])
1405      );
1406    }
1407  }
1408  return Cstr;
1409};
1410
1411// src/runtime/initialize-component.ts
1412var initializeComponent = async (elm, hostRef, cmpMeta, hmrVersionId) => {
1413  let Cstr;
1414  try {
1415    if ((hostRef.$flags$ & 32 /* hasInitializedComponent */) === 0) {
1416      hostRef.$flags$ |= 32 /* hasInitializedComponent */;
1417      const bundleId = cmpMeta.$lazyBundleId$;
1418      if (bundleId) {
1419        const CstrImport = loadModule(cmpMeta, hostRef);
1420        if (CstrImport && "then" in CstrImport) {
1421          const endLoad = uniqueTime();
1422          Cstr = await CstrImport;
1423          endLoad();
1424        } else {
1425          Cstr = CstrImport;
1426        }
1427        if (!Cstr) {
1428          throw new Error(`Constructor for "${cmpMeta.$tagName$}#${hostRef.$modeName$}" was not found`);
1429        }
1430        if (!Cstr.isProxied) {
1431          {
1432            cmpMeta.$watchers$ = normalizeWatchers(Cstr.watchers);
1433            cmpMeta.$serializers$ = Cstr.serializers;
1434            cmpMeta.$deserializers$ = Cstr.deserializers;
1435          }
1436          proxyComponent(Cstr, cmpMeta, 2 /* proxyState */);
1437          Cstr.isProxied = true;
1438        }
1439        const endNewInstance = createTime("createInstance", cmpMeta.$tagName$);
1440        {
1441          hostRef.$flags$ |= 8 /* isConstructingInstance */;
1442        }
1443        try {
1444          new Cstr(hostRef);
1445        } catch (e) {
1446          consoleError(e, elm);
1447        }
1448        {
1449          hostRef.$flags$ &= -9 /* isConstructingInstance */;
1450        }
1451        {
1452          hostRef.$flags$ |= 128 /* isWatchReady */;
1453        }
1454        endNewInstance();
1455        {
1456          fireConnectedCallback(hostRef.$lazyInstance$, elm);
1457        }
1458      } else {
1459        Cstr = elm.constructor;
1460        const cmpTag = elm.localName;
1461        customElements.whenDefined(cmpTag).then(() => hostRef.$flags$ |= 128 /* isWatchReady */);
1462      }
1463      if (Cstr && Cstr.style) {
1464        let style;
1465        if (typeof Cstr.style === "string") {
1466          style = Cstr.style;
1467        }
1468        const scopeId2 = getScopeId(cmpMeta);
1469        if (!styles.has(scopeId2) || BUILD.hotModuleReplacement) {
1470          const endRegisterStyles = createTime("registerStyles", cmpMeta.$tagName$);
1471          registerStyle(scopeId2, style, !!(cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */));
1472          endRegisterStyles();
1473        }
1474      }
1475    }
1476    const ancestorComponent = hostRef.$ancestorComponent$;
1477    const schedule = () => scheduleUpdate(hostRef, true);
1478    if (ancestorComponent && ancestorComponent["s-rc"]) {
1479      ancestorComponent["s-rc"].push(schedule);
1480    } else {
1481      schedule();
1482    }
1483  } catch (e) {
1484    consoleError(e, elm);
1485    if (hostRef.$onRenderResolve$) {
1486      hostRef.$onRenderResolve$();
1487      hostRef.$onRenderResolve$ = void 0;
1488    }
1489    if (hostRef.$onReadyResolve$) {
1490      hostRef.$onReadyResolve$(elm);
1491    }
1492  }
1493};
1494var fireConnectedCallback = (instance, elm) => {
1495  {
1496    safeCall(instance, "connectedCallback", void 0, elm);
1497  }
1498};
1499

1500// src/runtime/connected-callback.ts
1501var connectedCallback = (elm) => {
1502  if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) {
1503    const hostRef = getHostRef(elm);
1504    if (!hostRef) {
1505      return;
1506    }
1507    const cmpMeta = hostRef.$cmpMeta$;
1508    const endConnected = createTime("connectedCallback", cmpMeta.$tagName$);
1509    if (!(hostRef.$flags$ & 1 /* hasConnected */)) {
1510      hostRef.$flags$ |= 1 /* hasConnected */;
1511      {
1512        let ancestorComponent = elm;
1513        while (ancestorComponent = ancestorComponent.parentNode || ancestorComponent.host) {
1514          if (ancestorComponent["s-p"]) {
1515            attachToAncestor(hostRef, hostRef.$ancestorComponent$ = ancestorComponent);
1516            break;
1517          }
1518        }
1519      }
1520      if (cmpMeta.$members$) {
1521        Object.entries(cmpMeta.$members$).map(([memberName, [memberFlags]]) => {
1522          if (memberFlags & 31 /* Prop */ && Object.prototype.hasOwnProperty.call(elm, memberName)) {
1523            const value = elm[memberName];
1524            delete elm[memberName];
1525            elm[memberName] = value;
1526          }
1527        });
1528      }
1529      {
1530        initializeComponent(elm, hostRef, cmpMeta);
1531      }
1532    } else {
1533      addHostEventListeners(elm, hostRef, cmpMeta.$listeners$);
1534      if (hostRef == null ? void 0 : hostRef.$lazyInstance$) {
1535        fireConnectedCallback(hostRef.$lazyInstance$, elm);
1536      } else if (hostRef == null ? void 0 : hostRef.$onReadyPromise$) {
1537        hostRef.$onReadyPromise$.then(() => fireConnectedCallback(hostRef.$lazyInstance$, elm));
1538      }
1539    }
1540    endConnected();
1541  }
1542};
1543var disconnectInstance = (instance, elm) => {
1544  {
1545    safeCall(instance, "disconnectedCallback", void 0, elm || instance);
1546  }
1547};
1548var disconnectedCallback = async (elm) => {
1549  if ((plt.$flags$ & 1 /* isTmpDisconnected */) === 0) {
1550    const hostRef = getHostRef(elm);
1551    {
1552      if (hostRef == null ? void 0 : hostRef.$rmListeners$) {
1553        hostRef.$rmListeners$.map((rmListener) => rmListener());
1554        hostRef.$rmListeners$ = void 0;
1555      }
1556    }
1557    if (hostRef == null ? void 0 : hostRef.$lazyInstance$) {
1558      disconnectInstance(hostRef.$lazyInstance$, elm);
1559    } else if (hostRef == null ? void 0 : hostRef.$onReadyPromise$) {
1560      hostRef.$onReadyPromise$.then(() => disconnectInstance(hostRef.$lazyInstance$, elm));
1561    }
1562  }
1563  if (rootAppliedStyles.has(elm)) {
1564    rootAppliedStyles.delete(elm);
1565  }
1566  if (elm.shadowRoot && rootAppliedStyles.has(elm.shadowRoot)) {
1567    rootAppliedStyles.delete(elm.shadowRoot);
1568  }
1569};
1570
1571// src/runtime/bootstrap-lazy.ts
1572var bootstrapLazy = (lazyBundles, options = {}) => {
1573  var _a;
1574  if (!win.document) {
1575    console.warn("Stencil: No document found. Skipping bootstrapping lazy components.");
1576    return;
1577  }
1578  const endBootstrap = createTime();
1579  const cmpTags = [];
1580  const exclude = options.exclude || [];
1581  const customElements2 = win.customElements;
1582  const head = win.document.head;
1583  const metaCharset = /* @__PURE__ */ head.querySelector("meta[charset]");
1584  const dataStyles = /* @__PURE__ */ win.document.createElement("style");
1585  const deferredConnectedCallbacks = [];
1586  let appLoadFallback;
1587  let isBootstrapping = true;
1588  Object.assign(plt, options);
1589  plt.$resourcesUrl$ = new URL(options.resourcesUrl || "./", win.document.baseURI).href;
1590  lazyBundles.map((lazyBundle) => {
1591    lazyBundle[1].map((compactMeta) => {
1592      var _a2, _b;
1593      const cmpMeta = {
1594        $flags$: compactMeta[0],
1595        $tagName$: compactMeta[1],
1596        $members$: compactMeta[2],
1597        $listeners$: compactMeta[3]
1598      };
1599      {
1600        cmpMeta.$members$ = compactMeta[2];
1601      }
1602      {
1603        cmpMeta.$listeners$ = compactMeta[3];
1604      }
1605      {
1606        cmpMeta.$attrsToReflect$ = [];
1607      }
1608      {
1609        cmpMeta.$watchers$ = normalizeWatchers(compactMeta[4]);
1610        cmpMeta.$serializers$ = (_a2 = compactMeta[5]) != null ? _a2 : {};
1611        cmpMeta.$deserializers$ = (_b = compactMeta[6]) != null ? _b : {};
1612      }
1613      const tagName = transformTag(cmpMeta.$tagName$);
1614      const HostElement = class extends HTMLElement {
1615        ["s-p"];
1616        ["s-rc"];
1617        hasRegisteredEventListeners = false;
1618        // StencilLazyHost
1619        constructor(self) {
1620          super(self);
1621          self = this;
1622          registerHost(self, cmpMeta);
1623          if (cmpMeta.$flags$ & 1 /* shadowDomEncapsulation */) {
1624            {
1625              if (!self.shadowRoot) {
1626                createShadowRoot.call(self, cmpMeta);
1627              } else {
1628                if (self.shadowRoot.mode !== "open") {
1629                  throw new Error(
1630                    `Unable to re-use existing shadow root for ${cmpMeta.$tagName$}! Mode is set to ${self.shadowRoot.mode} but Stencil only supports open shadow roots.`
1631                  );
1632                }
1633              }
1634            }
1635          }
1636        }
1637        connectedCallback() {
1638          const hostRef = getHostRef(this);
1639          if (!hostRef) {
1640            return;
1641          }
1642          if (!this.hasRegisteredEventListeners) {
1643            this.hasRegisteredEventListeners = true;
1644            addHostEventListeners(this, hostRef, cmpMeta.$listeners$);
1645          }
1646          if (appLoadFallback) {
1647            clearTimeout(appLoadFallback);
1648            appLoadFallback = null;
1649          }
1650          if (isBootstrapping) {
1651            deferredConnectedCallbacks.push(this);
1652          } else {
1653            plt.jmp(() => connectedCallback(this));
1654          }
1655        }
1656        disconnectedCallback() {
1657          plt.jmp(() => disconnectedCallback(this));
1658          plt.raf(() => {
1659            var _a3;
1660            const hostRef = getHostRef(this);
1661            if (!hostRef) {
1662              return;
1663            }
1664            const i2 = deferredConnectedCallbacks.findIndex((host) => host === this);
1665            if (i2 > -1) {
1666              deferredConnectedCallbacks.splice(i2, 1);
1667            }
1668            if (((_a3 = hostRef == null ? void 0 : hostRef.$vnode$) == null ? void 0 : _a3.$elm$) instanceof Node && !hostRef.$vnode$.$elm$.isConnected) {
1669              delete hostRef.$vnode$.$elm$;
1670            }
1671          });
1672        }
1673        componentOnReady() {
1674          var _a3;
1675          return (_a3 = getHostRef(this)) == null ? void 0 : _a3.$onReadyPromise$;
1676        }
1677      };
1678      cmpMeta.$lazyBundleId$ = lazyBundle[0];
1679      if (!exclude.includes(tagName) && !customElements2.get(tagName)) {
1680        cmpTags.push(tagName);
1681        customElements2.define(
1682          tagName,
1683          proxyComponent(HostElement, cmpMeta, 1 /* isElementConstructor */)
1684        );
1685      }
1686    });

1687  });
1688  if (cmpTags.length > 0) {
1689    {
1690      dataStyles.textContent += cmpTags.sort() + HYDRATED_CSS;
1691    }
1692    if (dataStyles.innerHTML.length) {
1693      dataStyles.setAttribute("data-styles", "");
1694      const nonce = (_a = plt.$nonce$) != null ? _a : queryNonceMetaTagContent(win.document);
1695      if (nonce != null) {
1696        dataStyles.setAttribute("nonce", nonce);
1697      }
1698      head.insertBefore(dataStyles, metaCharset ? metaCharset.nextSibling : head.firstChild);
1699    }
1700  }
1701  isBootstrapping = false;
1702  if (deferredConnectedCallbacks.length) {
1703    deferredConnectedCallbacks.map((host) => host.connectedCallback());
1704  } else {
1705    {
1706      plt.jmp(() => appLoadFallback = setTimeout(appDidLoad, 30));
1707    }
1708  }
1709  endBootstrap();
1710};
1711

1712// src/runtime/fragment.ts
1713var Fragment = (_, children) => children;
1714var addHostEventListeners = (elm, hostRef, listeners, attachParentListeners) => {
1715  if (listeners && win.document) {
1716    listeners.map(([flags, name, method]) => {
1717      const target = elm;
1718      const handler = hostListenerProxy(hostRef, method);
1719      const opts = hostListenerOpts(flags);
1720      plt.ael(target, name, handler, opts);
1721      (hostRef.$rmListeners$ = hostRef.$rmListeners$ || []).push(() => plt.rel(target, name, handler, opts));
1722    });
1723  }
1724};
1725var hostListenerProxy = (hostRef, methodName) => (ev) => {
1726  var _a;
1727  try {
1728    {
1729      if (hostRef.$flags$ & 256 /* isListenReady */) {
1730        (_a = hostRef.$lazyInstance$) == null ? void 0 : _a[methodName](ev);
1731      } else {
1732        (hostRef.$queuedListeners$ = hostRef.$queuedListeners$ || []).push([methodName, ev]);
1733      }
1734    }
1735  } catch (e) {
1736    consoleError(e, hostRef.$hostElement$);
1737  }
1738};
1739var hostListenerOpts = (flags) => supportsListenerOptions ? {
1740  passive: (flags & 1 /* Passive */) !== 0,
1741  capture: (flags & 2 /* Capture */) !== 0
1742} : (flags & 2 /* Capture */) !== 0;
1743