@stencil/core 4.38.3-dev.1764651902.52bdcb8 → 4.38.3-dev.1764738304.c6bb6f1

package/internal/hydrate/runner.js

@@ -1,5 +1,5 @@
 /*
- Stencil Hydrate Runner v4.38.3-dev.1764651902.52bdcb8 | MIT Licensed | https://stenciljs.com
+ Stencil Hydrate Runner v4.38.3-dev.1764738304.c6bb6f1 | MIT Licensed | https://stenciljs.com
  */
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -7,6 +7,63 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/client/client-build.ts
+import { BUILD } from "@stencil/core/internal/app-data";
+var Build = {
+  isDev: BUILD.isDev ? true : false,
+  isBrowser: true,
+  isServer: false,
+  isTesting: BUILD.isTesting ? true : false
+};
+
+// src/client/client-host-ref.ts
+import { BUILD as BUILD3 } from "@stencil/core/internal/app-data";
+
+// src/utils/constants.ts
+var PrimitiveType = /* @__PURE__ */ ((PrimitiveType2) => {
+  PrimitiveType2["Undefined"] = "undefined";
+  PrimitiveType2["Null"] = "null";
+  PrimitiveType2["String"] = "string";
+  PrimitiveType2["Number"] = "number";
+  PrimitiveType2["SpecialNumber"] = "number";
+  PrimitiveType2["Boolean"] = "boolean";
+  PrimitiveType2["BigInt"] = "bigint";
+  return PrimitiveType2;
+})(PrimitiveType || {});
+var NonPrimitiveType = /* @__PURE__ */ ((NonPrimitiveType2) => {
+  NonPrimitiveType2["Array"] = "array";
+  NonPrimitiveType2["Date"] = "date";
+  NonPrimitiveType2["Map"] = "map";
+  NonPrimitiveType2["Object"] = "object";
+  NonPrimitiveType2["RegularExpression"] = "regexp";
+  NonPrimitiveType2["Set"] = "set";
+  NonPrimitiveType2["Channel"] = "channel";
+  NonPrimitiveType2["Symbol"] = "symbol";
+  return NonPrimitiveType2;
+})(NonPrimitiveType || {});
+var TYPE_CONSTANT = "type";
+var VALUE_CONSTANT = "value";
+var SERIALIZED_PREFIX = "serialized:";
+
+// src/utils/es2022-rewire-class-members.ts
+import { BUILD as BUILD2 } from "@stencil/core/internal/app-data";
+
+// src/client/client-load-module.ts
+import { BUILD as BUILD5 } from "@stencil/core/internal/app-data";
+
+// src/client/client-log.ts
+import { BUILD as BUILD4 } from "@stencil/core/internal/app-data";
+var STENCIL_DEV_MODE = BUILD4.isTesting ? ["STENCIL:"] : [
+  "%cstencil",
+  "color: white;background:#4c47ff;font-weight: bold; font-size:10px; padding:2px 6px; border-radius: 5px"
+];
+
+// src/client/client-style.ts
+var modeResolutionChain = [];
+
+// src/client/client-task-queue.ts
+import { BUILD as BUILD7 } from "@stencil/core/internal/app-data";
+
 // src/runtime/runtime-constants.ts
 var CONTENT_REF_ID = "r";
 var ORG_LOCATION_ID = "o";
@@ -17,369 +74,958 @@ var HYDRATED_STYLE_ID = "sty-id";
 var STENCIL_DOC_DATA = "_stencilDocData";
 var XLINK_NS = "http://www.w3.org/1999/xlink";
 
-// src/mock-doc/attribute.ts
-var attrHandler = {
-  get(obj, prop) {
-    if (prop in obj) {
-      return obj[prop];
-    }
-    if (typeof prop !== "symbol" && !isNaN(prop)) {
-      return obj.__items[prop];
-    }
-    return void 0;
-  }
+// src/client/client-window.ts
+import { BUILD as BUILD6 } from "@stencil/core/internal/app-data";
+var win = typeof window !== "undefined" ? window : {};
+var H = win.HTMLElement || class {
 };
-var createAttributeProxy = (caseInsensitive) => new Proxy(new MockAttributeMap(caseInsensitive), attrHandler);
-var MockAttributeMap = class {
-  constructor(caseInsensitive = false) {
-    this.caseInsensitive = caseInsensitive;
-    this.__items = [];
+var supportsShadow = BUILD6.shadowDom;
+var supportsConstructableStylesheets = BUILD6.constructableCSS ? /* @__PURE__ */ (() => {
+  try {
+    new CSSStyleSheet();
+    return typeof new CSSStyleSheet().replaceSync === "function";
+  } catch (e) {
   }
-  get length() {
-    return this.__items.length;
+  return false;
+})() : false;
+
+// src/client/index.ts
+import { BUILD as BUILD31, Env, NAMESPACE as NAMESPACE2 } from "@stencil/core/internal/app-data";
+
+// src/runtime/bootstrap-custom-element.ts
+import { BUILD as BUILD27 } from "@stencil/core/internal/app-data";
+
+// src/utils/helpers.ts
+var isString = (v) => typeof v === "string";
+
+// src/utils/local-value.ts
+var LocalValue = class _LocalValue {
+  constructor(type, value) {
+    if (type === "undefined" /* Undefined */ || type === "null" /* Null */) {
+      this.type = type;
+    } else {
+      this.type = type;
+      this.value = value;
+    }
   }
-  item(index) {
-    return this.__items[index] || null;
+  /**
+   * Creates a new LocalValue object with a string value.
+   *
+   * @param {string} value - The string value to be stored in the LocalValue object.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createStringValue(value) {
+    return new _LocalValue("string" /* String */, value);
   }
-  setNamedItem(attr) {
-    attr.namespaceURI = null;
-    this.setNamedItemNS(attr);
+  /**
+   * Creates a new LocalValue object with a number value.
+   *
+   * @param {number} value - The number value.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createNumberValue(value) {
+    return new _LocalValue("number" /* Number */, value);
   }
-  setNamedItemNS(attr) {
-    if (attr != null && attr.value != null) {
-      attr.value = String(attr.value);
+  /**
+   * Creates a new LocalValue object with a special number value.
+   *
+   * @param {number} value - The value of the special number.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createSpecialNumberValue(value) {
+    if (Number.isNaN(value)) {
+      return new _LocalValue("number" /* SpecialNumber */, "NaN");
     }
-    const existingAttr = this.__items.find((a) => a.name === attr.name && a.namespaceURI === attr.namespaceURI);
-    if (existingAttr != null) {
-      existingAttr.value = attr.value;
-    } else {
-      this.__items.push(attr);
+    if (Object.is(value, -0)) {
+      return new _LocalValue("number" /* SpecialNumber */, "-0");
     }
-  }
-  getNamedItem(attrName) {
-    if (this.caseInsensitive) {
-      attrName = attrName.toLowerCase();
+    if (value === Infinity) {
+      return new _LocalValue("number" /* SpecialNumber */, "Infinity");
     }
-    return this.getNamedItemNS(null, attrName);
-  }
-  getNamedItemNS(namespaceURI, attrName) {
-    namespaceURI = getNamespaceURI(namespaceURI);
-    return this.__items.find((attr) => attr.name === attrName && getNamespaceURI(attr.namespaceURI) === namespaceURI) || null;
-  }
-  removeNamedItem(attr) {
-    this.removeNamedItemNS(attr);
-  }
-  removeNamedItemNS(attr) {
-    for (let i = 0, ii = this.__items.length; i < ii; i++) {
-      if (this.__items[i].name === attr.name && this.__items[i].namespaceURI === attr.namespaceURI) {
-        this.__items.splice(i, 1);
-        break;
-      }
+    if (value === -Infinity) {
+      return new _LocalValue("number" /* SpecialNumber */, "-Infinity");
     }
+    return new _LocalValue("number" /* SpecialNumber */, value);
   }
-  [Symbol.iterator]() {
-    let i = 0;
-    return {
-      next: () => ({
-        done: i === this.length,
-        value: this.item(i++)
-      })
-    };
+  /**
+   * Creates a new LocalValue object with an undefined value.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createUndefinedValue() {
+    return new _LocalValue("undefined" /* Undefined */);
   }
-  get [Symbol.toStringTag]() {
-    return "MockAttributeMap";
+  /**
+   * Creates a new LocalValue object with a null value.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createNullValue() {
+    return new _LocalValue("null" /* Null */);
   }
-};
-function getNamespaceURI(namespaceURI) {
-  return namespaceURI === XLINK_NS ? null : namespaceURI;
-}
-function cloneAttributes(srcAttrs, sortByName = false) {
-  const dstAttrs = new MockAttributeMap(srcAttrs.caseInsensitive);
-  if (srcAttrs != null) {
-    const attrLen = srcAttrs.length;
-    if (sortByName && attrLen > 1) {
-      const sortedAttrs = [];
-      for (let i = 0; i < attrLen; i++) {
-        const srcAttr = srcAttrs.item(i);
-        const dstAttr = new MockAttr(srcAttr.name, srcAttr.value, srcAttr.namespaceURI);
-        sortedAttrs.push(dstAttr);
-      }
-      sortedAttrs.sort(sortAttributes).forEach((attr) => {
-        dstAttrs.setNamedItemNS(attr);
-      });
-    } else {
-      for (let i = 0; i < attrLen; i++) {
-        const srcAttr = srcAttrs.item(i);
-        const dstAttr = new MockAttr(srcAttr.name, srcAttr.value, srcAttr.namespaceURI);
-        dstAttrs.setNamedItemNS(dstAttr);
-      }
-    }
+  /**
+   * Creates a new LocalValue object with a boolean value.
+   *
+   * @param {boolean} value - The boolean value.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createBooleanValue(value) {
+    return new _LocalValue("boolean" /* Boolean */, value);
   }
-  return dstAttrs;
-}
-function sortAttributes(a, b) {
-  if (a.name < b.name) return -1;
-  if (a.name > b.name) return 1;
-  return 0;
-}
-var MockAttr = class {
-  constructor(attrName, attrValue, namespaceURI = null) {
-    this._name = attrName;
-    this._value = String(attrValue);
-    this._namespaceURI = namespaceURI;
+  /**
+   * Creates a new LocalValue object with a BigInt value.
+   *
+   * @param {BigInt} value - The BigInt value.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createBigIntValue(value) {
+    return new _LocalValue("bigint" /* BigInt */, value.toString());
   }
-  get name() {
-    return this._name;
+  /**
+   * Creates a new LocalValue object with an array.
+   *
+   * @param {Array} value - The array.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createArrayValue(value) {
+    return new _LocalValue("array" /* Array */, value);
   }
-  set name(value) {
-    this._name = value;
+  /**
+   * Creates a new LocalValue object with date value.
+   *
+   * @param {string} value - The date.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createDateValue(value) {
+    return new _LocalValue("date" /* Date */, value);
   }
-  get value() {
-    return this._value;
+  /**
+   * Creates a new LocalValue object of map value.
+   * @param {Map} map - The map.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createMapValue(map2) {
+    const value = [];
+    Array.from(map2.entries()).forEach(([key, val]) => {
+      value.push([_LocalValue.getArgument(key), _LocalValue.getArgument(val)]);
+    });
+    return new _LocalValue("map" /* Map */, value);
   }
-  set value(value) {
-    this._value = String(value);
+  /**
+   * Creates a new LocalValue object from the passed object.
+   *
+   * @param object the object to create a LocalValue from
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createObjectValue(object) {
+    const value = [];
+    Object.entries(object).forEach(([key, val]) => {
+      value.push([key, _LocalValue.getArgument(val)]);
+    });
+    return new _LocalValue("object" /* Object */, value);
   }
-  get nodeName() {
-    return this._name;
+  /**
+   * Creates a new LocalValue object of regular expression value.
+   *
+   * @param {string} value - The value of the regular expression.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createRegularExpressionValue(value) {
+    return new _LocalValue("regexp" /* RegularExpression */, value);
   }
-  set nodeName(value) {
-    this._name = value;
+  /**
+   * Creates a new LocalValue object with the specified value.
+   * @param {Set} value - The value to be set.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createSetValue(value) {
+    return new _LocalValue("set" /* Set */, value);
   }
-  get nodeValue() {
-    return this._value;
+  /**
+   * Creates a new LocalValue object with the given channel value
+   *
+   * @param {ChannelValue} value - The channel value.
+   * @returns {LocalValue} - The created LocalValue object.
+   */
+  static createChannelValue(value) {
+    return new _LocalValue("channel" /* Channel */, value);
   }
-  set nodeValue(value) {
-    this._value = String(value);
+  /**
+   * Creates a new LocalValue object with a Symbol value.
+   *
+   * @param {Symbol} symbol - The Symbol value
+   * @returns {LocalValue} - The created LocalValue object
+   */
+  static createSymbolValue(symbol) {
+    const description = symbol.description || "Symbol()";
+    return new _LocalValue("symbol" /* Symbol */, description);
   }
-  get namespaceURI() {
-    return this._namespaceURI;
+  static getArgument(argument) {
+    const type = typeof argument;
+    switch (type) {
+      case "string" /* String */:
+        return _LocalValue.createStringValue(argument);
+      case "number" /* Number */:
+        if (Number.isNaN(argument) || Object.is(argument, -0) || !Number.isFinite(argument)) {
+          return _LocalValue.createSpecialNumberValue(argument);
+        }
+        return _LocalValue.createNumberValue(argument);
+      case "boolean" /* Boolean */:
+        return _LocalValue.createBooleanValue(argument);
+      case "bigint" /* BigInt */:
+        return _LocalValue.createBigIntValue(argument);
+      case "undefined" /* Undefined */:
+        return _LocalValue.createUndefinedValue();
+      case "symbol" /* Symbol */:
+        return _LocalValue.createSymbolValue(argument);
+      case "object" /* Object */:
+        if (argument === null) {
+          return _LocalValue.createNullValue();
+        }
+        if (argument instanceof Date) {
+          return _LocalValue.createDateValue(argument);
+        }
+        if (argument instanceof Map) {
+          const map2 = [];
+          argument.forEach((value, key) => {
+            const objectKey = typeof key === "string" ? key : _LocalValue.getArgument(key);
+            const objectValue = _LocalValue.getArgument(value);
+            map2.push([objectKey, objectValue]);
+          });
+          return _LocalValue.createMapValue(argument);
+        }
+        if (argument instanceof Set) {
+          const set = [];
+          argument.forEach((value) => {
+            set.push(_LocalValue.getArgument(value));
+          });
+          return _LocalValue.createSetValue(set);
+        }
+        if (argument instanceof Array) {
+          const arr = [];
+          argument.forEach((value) => {
+            arr.push(_LocalValue.getArgument(value));
+          });
+          return _LocalValue.createArrayValue(arr);
+        }
+        if (argument instanceof RegExp) {
+          return _LocalValue.createRegularExpressionValue({
+            pattern: argument.source,
+            flags: argument.flags
+          });
+        }
+        return _LocalValue.createObjectValue(argument);
+    }
+    throw new Error(`Unsupported type: ${type}`);
   }
-  set namespaceURI(namespaceURI) {
-    this._namespaceURI = namespaceURI;
+  asMap() {
+    return {
+      [TYPE_CONSTANT]: this.type,
+      ...!(this.type === "null" /* Null */ || this.type === "undefined" /* Undefined */) ? { [VALUE_CONSTANT]: this.value } : {}
+    };
   }
 };
 
-// src/mock-doc/css-style-declaration.ts
-var MockCSSStyleDeclaration = class {
-  constructor() {
-    this._styles = /* @__PURE__ */ new Map();
-  }
-  setProperty(prop, value) {
-    prop = jsCaseToCssCase(prop);
-    if (value == null || value === "") {
-      this._styles.delete(prop);
+// src/utils/message-utils.ts
+var catchError = (diagnostics, err2, msg) => {
+  const diagnostic = {
+    level: "error",
+    type: "build",
+    header: "Build Error",
+    messageText: "build error",
+    lines: []
+  };
+  if (isString(msg)) {
+    diagnostic.messageText = msg.length ? msg : "UNKNOWN ERROR";
+  } else if (err2 != null) {
+    if (err2.stack != null) {
+      diagnostic.messageText = err2.stack.toString();
     } else {
-      this._styles.set(prop, String(value));
+      if (err2.message != null) {
+        diagnostic.messageText = err2.message.length ? err2.message : "UNKNOWN ERROR";
+      } else {
+        diagnostic.messageText = err2.toString();
+      }
     }
   }
-  getPropertyValue(prop) {
-    prop = jsCaseToCssCase(prop);
-    return String(this._styles.get(prop) || "");
-  }
-  removeProperty(prop) {
-    prop = jsCaseToCssCase(prop);
-    this._styles.delete(prop);
-  }
-  get length() {
-    return this._styles.size;
-  }
-  get cssText() {
-    const cssText = [];
-    this._styles.forEach((value, prop) => {
-      cssText.push(`${prop}: ${value};`);
-    });
-    return cssText.join(" ").trim();
-  }
-  set cssText(cssText) {
-    if (cssText == null || cssText === "") {
-      this._styles.clear();
-      return;
-    }
-    cssText.split(";").forEach((rule) => {
-      rule = rule.trim();
-      if (rule.length > 0) {
-        const splt = rule.split(":");
-        if (splt.length > 1) {
-          const prop = splt[0].trim();
-          const value = splt.slice(1).join(":").trim();
-          if (prop !== "" && value !== "") {
-            this._styles.set(jsCaseToCssCase(prop), value);
-          }
-        }
-      }
-    });
+  if (diagnostics != null && !shouldIgnoreError(diagnostic.messageText)) {
+    diagnostics.push(diagnostic);
   }
+  return diagnostic;
 };
-function createCSSStyleDeclaration() {
-  return new Proxy(new MockCSSStyleDeclaration(), cssProxyHandler);
-}
-var cssProxyHandler = {
-  get(cssStyle, prop) {
-    if (prop in cssStyle) {
-      return cssStyle[prop];
-    }
-    prop = cssCaseToJsCase(prop);
-    return cssStyle.getPropertyValue(prop);
-  },
-  set(cssStyle, prop, value) {
-    if (prop in cssStyle) {
-      cssStyle[prop] = value;
-    } else {
-      cssStyle.setProperty(prop, value);
-    }
-    return true;
+var hasError = (diagnostics) => {
+  if (diagnostics == null || diagnostics.length === 0) {
+    return false;
   }
+  return diagnostics.some((d) => d.level === "error" && d.type !== "runtime");
 };
-function cssCaseToJsCase(str) {
-  if (str.length > 1 && str.includes("-") === true) {
-    str = str.toLowerCase().split("-").map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
-    str = str.slice(0, 1).toLowerCase() + str.slice(1);
-  }
-  return str;
-}
-function jsCaseToCssCase(str) {
-  if (str.length > 1 && str.includes("-") === false && /[A-Z]/.test(str) === true) {
-    str = str.replace(/([A-Z])/g, (g) => " " + g[0]).trim().replace(/ /g, "-").toLowerCase();
-  }
-  return str;
-}
+var shouldIgnoreError = (msg) => {
+  return msg === TASK_CANCELED_MSG;
+};
+var TASK_CANCELED_MSG = `task canceled`;
 
-// src/mock-doc/custom-element-registry.ts
-var MockCustomElementRegistry = class {
-  constructor(win2) {
-    this.win = win2;
-  }
-  define(tagName, cstr, options) {
-    if (tagName.toLowerCase() !== tagName) {
-      throw new Error(
-        `Failed to execute 'define' on 'CustomElementRegistry': "${tagName}" is not a valid custom element name`
-      );
+// src/utils/regular-expression.ts
+var escapeRegExpSpecialCharacters = (text) => {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+
+// src/utils/remote-value.ts
+var RemoteValue = class _RemoteValue {
+  /**
+   * Deserializes a LocalValue serialized object back to its original JavaScript representation
+   *
+   * @param serialized The serialized LocalValue object
+   * @returns The original JavaScript value/object
+   */
+  static fromLocalValue(serialized) {
+    const type = serialized[TYPE_CONSTANT];
+    const value = VALUE_CONSTANT in serialized ? serialized[VALUE_CONSTANT] : void 0;
+    switch (type) {
+      case "string" /* String */:
+        return value;
+      case "boolean" /* Boolean */:
+        return value;
+      case "bigint" /* BigInt */:
+        return BigInt(value);
+      case "undefined" /* Undefined */:
+        return void 0;
+      case "null" /* Null */:
+        return null;
+      case "number" /* Number */:
+        if (value === "NaN") return NaN;
+        if (value === "-0") return -0;
+        if (value === "Infinity") return Infinity;
+        if (value === "-Infinity") return -Infinity;
+        return value;
+      case "array" /* Array */:
+        return value.map((item) => _RemoteValue.fromLocalValue(item));
+      case "date" /* Date */:
+        return new Date(value);
+      case "map" /* Map */:
+        const map2 = /* @__PURE__ */ new Map();
+        for (const [key, val] of value) {
+          const deserializedKey = typeof key === "object" && key !== null ? _RemoteValue.fromLocalValue(key) : key;
+          const deserializedValue = _RemoteValue.fromLocalValue(val);
+          map2.set(deserializedKey, deserializedValue);
+        }
+        return map2;
+      case "object" /* Object */:
+        const obj = {};
+        for (const [key, val] of value) {
+          obj[key] = _RemoteValue.fromLocalValue(val);
+        }
+        return obj;
+      case "regexp" /* RegularExpression */:
+        const { pattern, flags } = value;
+        return new RegExp(pattern, flags);
+      case "set" /* Set */:
+        const set = /* @__PURE__ */ new Set();
+        for (const item of value) {
+          set.add(_RemoteValue.fromLocalValue(item));
+        }
+        return set;
+      case "symbol" /* Symbol */:
+        return Symbol(value);
+      default:
+        throw new Error(`Unsupported type: ${type}`);
     }
-    if (this.__registry == null) {
-      this.__registry = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Utility method to deserialize multiple LocalValues at once
+   *
+   * @param serializedValues Array of serialized LocalValue objects
+   * @returns Array of deserialized JavaScript values
+   */
+  static fromLocalValueArray(serializedValues) {
+    return serializedValues.map((value) => _RemoteValue.fromLocalValue(value));
+  }
+  /**
+   * Verifies if the given object matches the structure of a serialized LocalValue
+   *
+   * @param obj Object to verify
+   * @returns boolean indicating if the object has LocalValue structure
+   */
+  static isLocalValueObject(obj) {
+    if (typeof obj !== "object" || obj === null) {
+      return false;
     }
-    this.__registry.set(tagName, { cstr, options });
-    if (this.__whenDefined != null) {
-      const whenDefinedResolveFns = this.__whenDefined.get(tagName);
-      if (whenDefinedResolveFns != null) {
-        whenDefinedResolveFns.forEach((whenDefinedResolveFn) => {
-          whenDefinedResolveFn();
-        });
-        whenDefinedResolveFns.length = 0;
-        this.__whenDefined.delete(tagName);
-      }
+    if (!obj.hasOwnProperty(TYPE_CONSTANT)) {
+      return false;
     }
-    const doc = this.win.document;
-    if (doc != null) {
-      const hosts = doc.querySelectorAll(tagName);
-      hosts.forEach((host) => {
-        if (upgradedElements.has(host) === false) {
-          tempDisableCallbacks.add(doc);
-          const upgradedCmp = createCustomElement(this, doc, tagName);
-          for (let i = 0; i < host.childNodes.length; i++) {
-            const childNode = host.childNodes[i];
-            childNode.remove();
-            upgradedCmp.appendChild(childNode);
-          }
-          tempDisableCallbacks.delete(doc);
-          if (proxyElements.has(host)) {
-            proxyElements.set(host, upgradedCmp);
-          }
-        }
-        fireConnectedCallback(host);
-      });
+    const type = obj[TYPE_CONSTANT];
+    const hasTypeProperty = Object.values({ ...PrimitiveType, ...NonPrimitiveType }).includes(type);
+    if (!hasTypeProperty) {
+      return false;
     }
-  }
-  get(tagName) {
-    if (this.__registry != null) {
-      const def = this.__registry.get(tagName.toLowerCase());
-      if (def != null) {
-        return def.cstr;
-      }
+    if (type !== "null" /* Null */ && type !== "undefined" /* Undefined */) {
+      return obj.hasOwnProperty(VALUE_CONSTANT);
     }
-    return void 0;
+    return true;
   }
-  getName(cstr) {
-    for (const [tagName, def] of this.__registry.entries()) {
-      if (def.cstr === cstr) {
-        return tagName;
-      }
+};
+
+// src/utils/result.ts
+var result_exports = {};
+__export(result_exports, {
+  err: () => err,
+  map: () => map,
+  ok: () => ok,
+  unwrap: () => unwrap,
+  unwrapErr: () => unwrapErr
+});
+var ok = (value) => ({
+  isOk: true,
+  isErr: false,
+  value
+});
+var err = (value) => ({
+  isOk: false,
+  isErr: true,
+  value
+});
+function map(result, fn) {
+  if (result.isOk) {
+    const val = fn(result.value);
+    if (val instanceof Promise) {
+      return val.then((newVal) => ok(newVal));
+    } else {
+      return ok(val);
     }
-    return void 0;
   }
-  upgrade(_rootNode) {
+  if (result.isErr) {
+    const value = result.value;
+    return err(value);
   }
-  clear() {
-    if (this.__registry != null) {
-      this.__registry.clear();
-    }
-    if (this.__whenDefined != null) {
-      this.__whenDefined.clear();
-    }
+  throw "should never get here";
+}
+var unwrap = (result) => {
+  if (result.isOk) {
+    return result.value;
+  } else {
+    throw result.value;
   }
-  whenDefined(tagName) {
-    tagName = tagName.toLowerCase();
-    if (this.__registry != null && this.__registry.has(tagName) === true) {
-      return Promise.resolve(this.__registry.get(tagName).cstr);
-    }
-    return new Promise((resolve) => {
-      if (this.__whenDefined == null) {
-        this.__whenDefined = /* @__PURE__ */ new Map();
-      }
-      let whenDefinedResolveFns = this.__whenDefined.get(tagName);
-      if (whenDefinedResolveFns == null) {
-        whenDefinedResolveFns = [];
-        this.__whenDefined.set(tagName, whenDefinedResolveFns);
-      }
-      whenDefinedResolveFns.push(resolve);
-    });
+};
+var unwrapErr = (result) => {
+  if (result.isErr) {
+    return result.value;
+  } else {
+    throw result.value;
   }
 };
-function createCustomElement(customElements2, ownerDocument, tagName) {
-  const Cstr = customElements2.get(tagName);
-  if (Cstr != null) {
-    const cmp = new Cstr(ownerDocument);
-    cmp.nodeName = tagName.toUpperCase();
-    upgradedElements.add(cmp);
-    return cmp;
+
+// src/utils/serialize.ts
+function serializeProperty(value) {
+  if (["string", "boolean", "undefined"].includes(typeof value) || typeof value === "number" && value !== Infinity && value !== -Infinity && !isNaN(value)) {
+    return value;
   }
-  const host = new Proxy(
-    {},
-    {
-      get(obj, prop) {
-        const elm2 = proxyElements.get(host);
-        if (elm2 != null) {
-          return elm2[prop];
-        }
-        return obj[prop];
-      },
-      set(obj, prop, val) {
-        const elm2 = proxyElements.get(host);
-        if (elm2 != null) {
-          elm2[prop] = val;
-        } else {
-          obj[prop] = val;
-        }
-        return true;
-      },
-      has(obj, prop) {
-        const elm2 = proxyElements.get(host);
-        if (prop in elm2) {
-          return true;
-        }
-        if (prop in obj) {
-          return true;
-        }
-        return false;
-      }
-    }
-  );
-  const elm = new MockHTMLElement(ownerDocument, tagName);
-  proxyElements.set(host, elm);
-  return host;
+  const arg = LocalValue.getArgument(value);
+  return SERIALIZED_PREFIX + btoa(JSON.stringify(arg));
 }
-var proxyElements = /* @__PURE__ */ new WeakMap();
+function deserializeProperty(value) {
+  if (typeof value !== "string" || !value.startsWith(SERIALIZED_PREFIX)) {
+    return value;
+  }
+  return RemoteValue.fromLocalValue(JSON.parse(atob(value.slice(SERIALIZED_PREFIX.length))));
+}
+
+// src/utils/shadow-root.ts
+import { BUILD as BUILD8 } from "@stencil/core/internal/app-data";
+
+// src/utils/util.ts
+var lowerPathParam = (fn) => (p) => fn(p.toLowerCase());
+var isDtsFile = lowerPathParam((p) => p.endsWith(".d.ts") || p.endsWith(".d.mts") || p.endsWith(".d.cts"));
+var isTsFile = lowerPathParam(
+  (p) => !isDtsFile(p) && (p.endsWith(".ts") || p.endsWith(".mts") || p.endsWith(".cts"))
+);
+var isTsxFile = lowerPathParam(
+  (p) => p.endsWith(".tsx") || p.endsWith(".mtsx") || p.endsWith(".ctsx")
+);
+var isJsxFile = lowerPathParam(
+  (p) => p.endsWith(".jsx") || p.endsWith(".mjsx") || p.endsWith(".cjsx")
+);
+var isJsFile = lowerPathParam((p) => p.endsWith(".js") || p.endsWith(".mjs") || p.endsWith(".cjs"));
+
+// src/runtime/connected-callback.ts
+import { BUILD as BUILD25 } from "@stencil/core/internal/app-data";
+
+// src/runtime/client-hydrate.ts
+import { BUILD as BUILD14 } from "@stencil/core/internal/app-data";
+
+// src/runtime/dom-extras.ts
+import { BUILD as BUILD10 } from "@stencil/core/internal/app-data";
+
+// src/runtime/slot-polyfill-utils.ts
+import { BUILD as BUILD9 } from "@stencil/core/internal/app-data";
+
+// src/runtime/profile.ts
+import { BUILD as BUILD11 } from "@stencil/core/internal/app-data";
+
+// src/runtime/styles.ts
+import { BUILD as BUILD12 } from "@stencil/core/internal/app-data";
+
+// src/runtime/vdom/h.ts
+import { BUILD as BUILD13 } from "@stencil/core/internal/app-data";
+
+// src/runtime/initialize-component.ts
+import { BUILD as BUILD24 } from "@stencil/core/internal/app-data";
+
+// src/utils/shadow-css.ts
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ *
+ * This file is a port of shadowCSS from `webcomponents.js` to TypeScript.
+ * https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js
+ * https://github.com/angular/angular/blob/master/packages/compiler/src/shadow_css.ts
+ */
+var _polyfillHost = "-shadowcsshost";
+var _polyfillSlotted = "-shadowcssslotted";
+var _polyfillHostContext = "-shadowcsscontext";
+var _parenSuffix = ")(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))?([^,{]*)";
+var _cssColonHostRe = new RegExp("(" + _polyfillHost + _parenSuffix, "gim");
+var _cssColonHostContextRe = new RegExp("(" + _polyfillHostContext + _parenSuffix, "gim");
+var _cssColonSlottedRe = new RegExp("(" + _polyfillSlotted + _parenSuffix, "gim");
+var _polyfillHostNoCombinator = _polyfillHost + "-no-combinator";
+var createSupportsRuleRe = (selector) => {
+  const safeSelector = escapeRegExpSpecialCharacters(selector);
+  return new RegExp(
+    // First capture group: match any context before the selector that's not inside @supports selector()
+    // Using negative lookahead to avoid matching inside @supports selector(...) condition
+    `(^|[^@]|@(?!supports\\s+selector\\s*\\([^{]*?${safeSelector}))(${safeSelector}\\b)`,
+    "g"
+  );
+};
+var _colonSlottedRe = createSupportsRuleRe("::slotted");
+var _colonHostRe = createSupportsRuleRe(":host");
+var _colonHostContextRe = createSupportsRuleRe(":host-context");
+
+// src/runtime/mode.ts
+var setMode = (handler) => modeResolutionChain.push(handler);
+
+// src/runtime/proxy-component.ts
+import { BUILD as BUILD23 } from "@stencil/core/internal/app-data";
+
+// src/runtime/set-value.ts
+import { BUILD as BUILD22 } from "@stencil/core/internal/app-data";
+
+// src/runtime/parse-property-value.ts
+import { BUILD as BUILD15 } from "@stencil/core/internal/app-data";
+
+// src/runtime/update-component.ts
+import { BUILD as BUILD21, NAMESPACE } from "@stencil/core/internal/app-data";
+
+// src/runtime/event-emitter.ts
+import { BUILD as BUILD17 } from "@stencil/core/internal/app-data";
+
+// src/runtime/element.ts
+import { BUILD as BUILD16 } from "@stencil/core/internal/app-data";
+
+// src/runtime/vdom/vdom-render.ts
+import { BUILD as BUILD20 } from "@stencil/core/internal/app-data";
+
+// src/runtime/vdom/update-element.ts
+import { BUILD as BUILD19 } from "@stencil/core/internal/app-data";
+
+// src/runtime/vdom/set-accessor.ts
+import { BUILD as BUILD18 } from "@stencil/core/internal/app-data";
+var CAPTURE_EVENT_SUFFIX = "Capture";
+var CAPTURE_EVENT_REGEX = new RegExp(CAPTURE_EVENT_SUFFIX + "$");
+
+// src/runtime/disconnected-callback.ts
+import { BUILD as BUILD26 } from "@stencil/core/internal/app-data";
+
+// src/runtime/bootstrap-lazy.ts
+import { BUILD as BUILD28 } from "@stencil/core/internal/app-data";
+
+// src/runtime/host-listener.ts
+import { BUILD as BUILD29 } from "@stencil/core/internal/app-data";
+
+// src/runtime/mixin.ts
+import { BUILD as BUILD30 } from "@stencil/core/internal/app-data";
+var baseClass = BUILD30.lazyLoad ? class {
+} : globalThis.HTMLElement || class {
+};
+
+// src/runtime/tag-transform.ts
+var tagTransformer = void 0;
+function transformTag(tag) {
+  if (!tagTransformer) return tag;
+  return tagTransformer(tag);
+}
+function setTagTransformer(transformer) {
+  if (tagTransformer) {
+    console.warn(`
+      A tagTransformer has already been set. 
+      Overwriting it may lead to error and unexpected results if your components have already been defined.
+    `);
+  }
+  tagTransformer = transformer;
+}
+
+// src/mock-doc/attribute.ts
+var attrHandler = {
+  get(obj, prop) {
+    if (prop in obj) {
+      return obj[prop];
+    }
+    if (typeof prop !== "symbol" && !isNaN(prop)) {
+      return obj.__items[prop];
+    }
+    return void 0;
+  }
+};
+var createAttributeProxy = (caseInsensitive) => new Proxy(new MockAttributeMap(caseInsensitive), attrHandler);
+var MockAttributeMap = class {
+  constructor(caseInsensitive = false) {
+    this.caseInsensitive = caseInsensitive;
+    this.__items = [];
+  }
+  get length() {
+    return this.__items.length;
+  }
+  item(index) {
+    return this.__items[index] || null;
+  }
+  setNamedItem(attr) {
+    attr.namespaceURI = null;
+    this.setNamedItemNS(attr);
+  }
+  setNamedItemNS(attr) {
+    if (attr != null && attr.value != null) {
+      attr.value = String(attr.value);
+    }
+    const existingAttr = this.__items.find((a) => a.name === attr.name && a.namespaceURI === attr.namespaceURI);
+    if (existingAttr != null) {
+      existingAttr.value = attr.value;
+    } else {
+      this.__items.push(attr);
+    }
+  }
+  getNamedItem(attrName) {
+    if (this.caseInsensitive) {
+      attrName = attrName.toLowerCase();
+    }
+    return this.getNamedItemNS(null, attrName);
+  }
+  getNamedItemNS(namespaceURI, attrName) {
+    namespaceURI = getNamespaceURI(namespaceURI);
+    return this.__items.find((attr) => attr.name === attrName && getNamespaceURI(attr.namespaceURI) === namespaceURI) || null;
+  }
+  removeNamedItem(attr) {
+    this.removeNamedItemNS(attr);
+  }
+  removeNamedItemNS(attr) {
+    for (let i = 0, ii = this.__items.length; i < ii; i++) {
+      if (this.__items[i].name === attr.name && this.__items[i].namespaceURI === attr.namespaceURI) {
+        this.__items.splice(i, 1);
+        break;
+      }
+    }
+  }
+  [Symbol.iterator]() {
+    let i = 0;
+    return {
+      next: () => ({
+        done: i === this.length,
+        value: this.item(i++)
+      })
+    };
+  }
+  get [Symbol.toStringTag]() {
+    return "MockAttributeMap";
+  }
+};
+function getNamespaceURI(namespaceURI) {
+  return namespaceURI === XLINK_NS ? null : namespaceURI;
+}
+function cloneAttributes(srcAttrs, sortByName = false) {
+  const dstAttrs = new MockAttributeMap(srcAttrs.caseInsensitive);
+  if (srcAttrs != null) {
+    const attrLen = srcAttrs.length;
+    if (sortByName && attrLen > 1) {
+      const sortedAttrs = [];
+      for (let i = 0; i < attrLen; i++) {
+        const srcAttr = srcAttrs.item(i);
+        const dstAttr = new MockAttr(srcAttr.name, srcAttr.value, srcAttr.namespaceURI);
+        sortedAttrs.push(dstAttr);
+      }
+      sortedAttrs.sort(sortAttributes).forEach((attr) => {
+        dstAttrs.setNamedItemNS(attr);
+      });
+    } else {
+      for (let i = 0; i < attrLen; i++) {
+        const srcAttr = srcAttrs.item(i);
+        const dstAttr = new MockAttr(srcAttr.name, srcAttr.value, srcAttr.namespaceURI);
+        dstAttrs.setNamedItemNS(dstAttr);
+      }
+    }
+  }
+  return dstAttrs;
+}
+function sortAttributes(a, b) {
+  if (a.name < b.name) return -1;
+  if (a.name > b.name) return 1;
+  return 0;
+}
+var MockAttr = class {
+  constructor(attrName, attrValue, namespaceURI = null) {
+    this._name = attrName;
+    this._value = String(attrValue);
+    this._namespaceURI = namespaceURI;
+  }
+  get name() {
+    return this._name;
+  }
+  set name(value) {
+    this._name = value;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(value) {
+    this._value = String(value);
+  }
+  get nodeName() {
+    return this._name;
+  }
+  set nodeName(value) {
+    this._name = value;
+  }
+  get nodeValue() {
+    return this._value;
+  }
+  set nodeValue(value) {
+    this._value = String(value);
+  }
+  get namespaceURI() {
+    return this._namespaceURI;
+  }
+  set namespaceURI(namespaceURI) {
+    this._namespaceURI = namespaceURI;
+  }
+};
+
+// src/mock-doc/css-style-declaration.ts
+var MockCSSStyleDeclaration = class {
+  constructor() {
+    this._styles = /* @__PURE__ */ new Map();
+  }
+  setProperty(prop, value) {
+    prop = jsCaseToCssCase(prop);
+    if (value == null || value === "") {
+      this._styles.delete(prop);
+    } else {
+      this._styles.set(prop, String(value));
+    }
+  }
+  getPropertyValue(prop) {
+    prop = jsCaseToCssCase(prop);
+    return String(this._styles.get(prop) || "");
+  }
+  removeProperty(prop) {
+    prop = jsCaseToCssCase(prop);
+    this._styles.delete(prop);
+  }
+  get length() {
+    return this._styles.size;
+  }
+  get cssText() {
+    const cssText = [];
+    this._styles.forEach((value, prop) => {
+      cssText.push(`${prop}: ${value};`);
+    });
+    return cssText.join(" ").trim();
+  }
+  set cssText(cssText) {
+    if (cssText == null || cssText === "") {
+      this._styles.clear();
+      return;
+    }
+    cssText.split(";").forEach((rule) => {
+      rule = rule.trim();
+      if (rule.length > 0) {
+        const splt = rule.split(":");
+        if (splt.length > 1) {
+          const prop = splt[0].trim();
+          const value = splt.slice(1).join(":").trim();
+          if (prop !== "" && value !== "") {
+            this._styles.set(jsCaseToCssCase(prop), value);
+          }
+        }
+      }
+    });
+  }
+};
+function createCSSStyleDeclaration() {
+  return new Proxy(new MockCSSStyleDeclaration(), cssProxyHandler);
+}
+var cssProxyHandler = {
+  get(cssStyle, prop) {
+    if (prop in cssStyle) {
+      return cssStyle[prop];
+    }
+    prop = cssCaseToJsCase(prop);
+    return cssStyle.getPropertyValue(prop);
+  },
+  set(cssStyle, prop, value) {
+    if (prop in cssStyle) {
+      cssStyle[prop] = value;
+    } else {
+      cssStyle.setProperty(prop, value);
+    }
+    return true;
+  }
+};
+function cssCaseToJsCase(str) {
+  if (str.length > 1 && str.includes("-") === true) {
+    str = str.toLowerCase().split("-").map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+    str = str.slice(0, 1).toLowerCase() + str.slice(1);
+  }
+  return str;
+}
+function jsCaseToCssCase(str) {
+  if (str.length > 1 && str.includes("-") === false && /[A-Z]/.test(str) === true) {
+    str = str.replace(/([A-Z])/g, (g) => " " + g[0]).trim().replace(/ /g, "-").toLowerCase();
+  }
+  return str;
+}
+
+// src/mock-doc/custom-element-registry.ts
+var MockCustomElementRegistry = class {
+  constructor(win2) {
+    this.win = win2;
+  }
+  define(tagName, cstr, options) {
+    if (tagName.toLowerCase() !== tagName) {
+      throw new Error(
+        `Failed to execute 'define' on 'CustomElementRegistry': "${tagName}" is not a valid custom element name`
+      );
+    }
+    if (this.__registry == null) {
+      this.__registry = /* @__PURE__ */ new Map();
+    }
+    this.__registry.set(tagName, { cstr, options });
+    if (this.__whenDefined != null) {
+      const whenDefinedResolveFns = this.__whenDefined.get(tagName);
+      if (whenDefinedResolveFns != null) {
+        whenDefinedResolveFns.forEach((whenDefinedResolveFn) => {
+          whenDefinedResolveFn();
+        });
+        whenDefinedResolveFns.length = 0;
+        this.__whenDefined.delete(tagName);
+      }
+    }
+    const doc = this.win.document;
+    if (doc != null) {
+      const hosts = doc.querySelectorAll(tagName);
+      hosts.forEach((host) => {
+        if (upgradedElements.has(host) === false) {
+          tempDisableCallbacks.add(doc);
+          const upgradedCmp = createCustomElement(this, doc, tagName);
+          for (let i = 0; i < host.childNodes.length; i++) {
+            const childNode = host.childNodes[i];
+            childNode.remove();
+            upgradedCmp.appendChild(childNode);
+          }
+          tempDisableCallbacks.delete(doc);
+          if (proxyElements.has(host)) {
+            proxyElements.set(host, upgradedCmp);
+          }
+        }
+        fireConnectedCallback2(host);
+      });
+    }
+  }
+  get(tagName) {
+    if (this.__registry != null) {
+      const def = this.__registry.get(tagName.toLowerCase());
+      if (def != null) {
+        return def.cstr;
+      }
+    }
+    return void 0;
+  }
+  getName(cstr) {
+    for (const [tagName, def] of this.__registry.entries()) {
+      if (def.cstr === cstr) {
+        return tagName;
+      }
+    }
+    return void 0;
+  }
+  upgrade(_rootNode) {
+  }
+  clear() {
+    if (this.__registry != null) {
+      this.__registry.clear();
+    }
+    if (this.__whenDefined != null) {
+      this.__whenDefined.clear();
+    }
+  }
+  whenDefined(tagName) {
+    tagName = tagName.toLowerCase();
+    if (this.__registry != null && this.__registry.has(tagName) === true) {
+      return Promise.resolve(this.__registry.get(tagName).cstr);
+    }
+    return new Promise((resolve) => {
+      if (this.__whenDefined == null) {
+        this.__whenDefined = /* @__PURE__ */ new Map();
+      }
+      let whenDefinedResolveFns = this.__whenDefined.get(tagName);
+      if (whenDefinedResolveFns == null) {
+        whenDefinedResolveFns = [];
+        this.__whenDefined.set(tagName, whenDefinedResolveFns);
+      }
+      whenDefinedResolveFns.push(resolve);
+    });
+  }
+};
+function createCustomElement(customElements2, ownerDocument, tagName) {
+  const Cstr = customElements2.get(tagName);
+  if (Cstr != null) {
+    const cmp = new Cstr(ownerDocument);
+    cmp.nodeName = tagName.toUpperCase();
+    upgradedElements.add(cmp);
+    return cmp;
+  }
+  const host = new Proxy(
+    {},
+    {
+      get(obj, prop) {
+        const elm2 = proxyElements.get(host);
+        if (elm2 != null) {
+          return elm2[prop];
+        }
+        return obj[prop];
+      },
+      set(obj, prop, val) {
+        const elm2 = proxyElements.get(host);
+        if (elm2 != null) {
+          elm2[prop] = val;
+        } else {
+          obj[prop] = val;
+        }
+        return true;
+      },
+      has(obj, prop) {
+        const elm2 = proxyElements.get(host);
+        if (prop in elm2) {
+          return true;
+        }
+        if (prop in obj) {
+          return true;
+        }
+        return false;
+      }
+    }
+  );
+  const elm = new MockHTMLElement(ownerDocument, tagName);
+  proxyElements.set(host, elm);
+  return host;
+}
+var proxyElements = /* @__PURE__ */ new WeakMap();
 var upgradedElements = /* @__PURE__ */ new WeakSet();
 function connectNode(ownerDocument, node) {
   node.ownerDocument = ownerDocument;
@@ -387,7 +1033,7 @@ function connectNode(ownerDocument, node) {
     if (ownerDocument != null && node.nodeName.includes("-")) {
       const win2 = ownerDocument.defaultView;
       if (win2 != null && typeof node.connectedCallback === "function" && node.isConnected) {
-        fireConnectedCallback(node);
+        fireConnectedCallback2(node);
       }
       const shadowRoot = node.shadowRoot;
       if (shadowRoot != null) {
@@ -405,7 +1051,7 @@ function connectNode(ownerDocument, node) {
     });
   }
 }
-function fireConnectedCallback(node) {
+function fireConnectedCallback2(node) {
   if (typeof node.connectedCallback === "function") {
     if (tempDisableCallbacks.has(node.ownerDocument) === false) {
       try {
@@ -455,7 +1101,7 @@ function dataset(elm) {
     const attr = attributes.item(i);
     const nodeName = attr.nodeName;
     if (nodeName.startsWith("data-")) {
-      ds[dashToPascalCase(nodeName)] = attr.nodeValue;
+      ds[dashToPascalCase2(nodeName)] = attr.nodeValue;
     }
   }
   return new Proxy(ds, {
@@ -472,7 +1118,7 @@ function dataset(elm) {
 function toDataAttribute(str) {
   return "data-" + String(str).replace(/([A-Z0-9])/g, (g) => " " + g[0]).trim().replace(/ /g, "-").toLowerCase();
 }
-function dashToPascalCase(str) {
+function dashToPascalCase2(str) {
   str = String(str).slice(5);
   return str.split("-").map((segment, index) => {
     if (index === 0) {
@@ -8824,14 +9470,14 @@ var jquery_default = (
   *
   * Date: 2023-12-11T17:55Z
   */
-  function(global2, factory) {
+  (function(global2, factory) {
     "use strict";
     if (true) {
       return factory(global2, true);
     } else {
       factory(global2);
     }
-  }({
+  })({
     document: {
       createElement() {
         return {};
@@ -10801,10 +11447,10 @@ var MockNode2 = class {
   insertBefore(newNode, referenceNode) {
     if (newNode.nodeType === 11 /* DOCUMENT_FRAGMENT_NODE */) {
       for (let i = 0, ii = newNode.childNodes.length; i < ii; i++) {
-        insertBefore(this, newNode.childNodes[i], referenceNode);
+        insertBefore2(this, newNode.childNodes[i], referenceNode);
       }
     } else {
-      insertBefore(this, newNode, referenceNode);
+      insertBefore2(this, newNode, referenceNode);
     }
     return newNode;
   }
@@ -11149,13 +11795,13 @@ var MockElement = class extends MockNode2 {
   }
   insertAdjacentElement(position, elm) {
     if (position === "beforebegin" && this.parentNode) {
-      insertBefore(this.parentNode, elm, this);
+      insertBefore2(this.parentNode, elm, this);
     } else if (position === "afterbegin") {
       this.prepend(elm);
     } else if (position === "beforeend") {
       this.appendChild(elm);
     } else if (position === "afterend" && this.parentNode) {
-      insertBefore(this.parentNode, elm, this.nextSibling);
+      insertBefore2(this.parentNode, elm, this.nextSibling);
     }
     return elm;
   }
@@ -11164,7 +11810,7 @@ var MockElement = class extends MockNode2 {
     if (position === "beforebegin") {
       while (frag.childNodes.length > 0) {
         if (this.parentNode) {
-          insertBefore(this.parentNode, frag.childNodes[0], this);
+          insertBefore2(this.parentNode, frag.childNodes[0], this);
         }
       }
     } else if (position === "afterbegin") {
@@ -11178,7 +11824,7 @@ var MockElement = class extends MockNode2 {
     } else if (position === "afterend") {
       while (frag.childNodes.length > 0) {
         if (this.parentNode) {
-          insertBefore(this.parentNode, frag.childNodes[frag.childNodes.length - 1], this.nextSibling);
+          insertBefore2(this.parentNode, frag.childNodes[frag.childNodes.length - 1], this.nextSibling);
         }
       }
     }
@@ -11186,13 +11832,13 @@ var MockElement = class extends MockNode2 {
   insertAdjacentText(position, text) {
     const elm = this.ownerDocument.createTextNode(text);
     if (position === "beforebegin" && this.parentNode) {
-      insertBefore(this.parentNode, elm, this);
+      insertBefore2(this.parentNode, elm, this);
     } else if (position === "afterbegin") {
       this.prepend(elm);
     } else if (position === "beforeend") {
       this.appendChild(elm);
     } else if (position === "afterend" && this.parentNode) {
-      insertBefore(this.parentNode, elm, this.nextSibling);
+      insertBefore2(this.parentNode, elm, this.nextSibling);
     }
   }
   hasAttribute(attrName) {
@@ -11607,7 +12253,7 @@ function resetElement(elm) {
   delete elm.__shadowRoot;
   delete elm.__style;
 }
-function insertBefore(parentNode, newNode, referenceNode) {
+function insertBefore2(parentNode, newNode, referenceNode) {
   if (newNode !== referenceNode) {
     newNode.remove();
     newNode.parentNode = parentNode;
@@ -13691,1096 +14337,466 @@ var MockWindow = class {
   }
   onmousemove() {
   }
-  onmouseout() {
-  }
-  onmouseover() {
-  }
-  onmouseup() {
-  }
-  onmousewheel() {
-  }
-  onpaste() {
-  }
-  onpause() {
-  }
-  onplay() {
-  }
-  onplaying() {
-  }
-  onpointercancel() {
-  }
-  onpointerdown() {
-  }
-  onpointerenter() {
-  }
-  onpointerleave() {
-  }
-  onpointermove() {
-  }
-  onpointerout() {
-  }
-  onpointerover() {
-  }
-  onpointerup() {
-  }
-  onprogress() {
-  }
-  onratechange() {
-  }
-  onreset() {
-  }
-  onresize() {
-  }
-  onscroll() {
-  }
-  onsearch() {
-  }
-  onseeked() {
-  }
-  onseeking() {
-  }
-  onselect() {
-  }
-  onselectstart() {
-  }
-  onstalled() {
-  }
-  onsubmit() {
-  }
-  onsuspend() {
-  }
-  ontimeupdate() {
-  }
-  ontoggle() {
-  }
-  onvolumechange() {
-  }
-  onwaiting() {
-  }
-  onwebkitfullscreenchange() {
-  }
-  onwebkitfullscreenerror() {
-  }
-  onwheel() {
-  }
-};
-addGlobalsToWindowPrototype(MockWindow.prototype);
-function resetWindowDefaults(win2) {
-  win2.__clearInterval = nativeClearInterval;
-  win2.__clearTimeout = nativeClearTimeout;
-  win2.__setInterval = nativeSetInterval;
-  win2.__setTimeout = nativeSetTimeout;
-  win2.__maxTimeout = 6e4;
-  win2.__allowInterval = true;
-  win2.URL = nativeURL;
-}
-function cloneWindow(srcWin, opts = {}) {
-  if (srcWin == null) {
-    return null;
-  }
-  const clonedWin = new MockWindow(false);
-  if (!opts.customElementProxy) {
-    srcWin.customElements = null;
+  onmouseout() {
   }
-  if (srcWin.document != null) {
-    const clonedDoc = new MockDocument(false, clonedWin);
-    clonedWin.document = clonedDoc;
-    clonedDoc.documentElement = srcWin.document.documentElement.cloneNode(true);
-  } else {
-    clonedWin.document = new MockDocument(null, clonedWin);
+  onmouseover() {
   }
-  return clonedWin;
-}
-function constrainTimeouts(win2) {
-  win2.__allowInterval = false;
-  win2.__maxTimeout = 0;
-}
-function resetWindow(win2) {
-  if (win2 != null) {
-    if (win2.__timeouts) {
-      win2.__timeouts.forEach((timeoutId) => {
-        nativeClearInterval(timeoutId);
-        nativeClearTimeout(timeoutId);
-      });
-      win2.__timeouts.clear();
-    }
-    if (win2.customElements && win2.customElements.clear) {
-      win2.customElements.clear();
-    }
-    resetDocument(win2.document);
-    resetPerformance(win2.performance);
-    for (const key in win2) {
-      if (win2.hasOwnProperty(key) && key !== "document" && key !== "performance" && key !== "customElements") {
-        delete win2[key];
-      }
-    }
-    resetWindowDefaults(win2);
-    resetWindowDimensions(win2);
-    resetEventListeners(win2);
-    if (win2.document != null) {
-      try {
-        win2.document.defaultView = win2;
-      } catch (e) {
-      }
-    }
-    win2.fetch = null;
-    win2.Headers = null;
-    win2.Request = null;
-    win2.Response = null;
-    win2.FetchError = null;
+  onmouseup() {
   }
-}
-function resetWindowDimensions(win2) {
-  try {
-    win2.devicePixelRatio = 1;
-    win2.innerHeight = 768;
-    win2.innerWidth = 1366;
-    win2.pageXOffset = 0;
-    win2.pageYOffset = 0;
-    win2.screenLeft = 0;
-    win2.screenTop = 0;
-    win2.screenX = 0;
-    win2.screenY = 0;
-    win2.scrollX = 0;
-    win2.scrollY = 0;
-    win2.screen = {
-      availHeight: win2.innerHeight,
-      availLeft: 0,
-      availTop: 0,
-      availWidth: win2.innerWidth,
-      colorDepth: 24,
-      height: win2.innerHeight,
-      keepAwake: false,
-      orientation: {
-        angle: 0,
-        type: "portrait-primary"
-      },
-      pixelDepth: 24,
-      width: win2.innerWidth
-    };
-  } catch (e) {
+  onmousewheel() {
   }
-}
-
-// src/mock-doc/document.ts
-var MockDocument = class _MockDocument extends MockHTMLElement {
-  constructor(html = null, win2 = null) {
-    super(null, null);
-    this.nodeName = "#document" /* DOCUMENT_NODE */;
-    this.nodeType = 9 /* DOCUMENT_NODE */;
-    this.defaultView = win2;
-    this.cookie = "";
-    this.referrer = "";
-    this.appendChild(this.createDocumentTypeNode());
-    if (typeof html === "string") {
-      const parsedDoc = parseDocumentUtil(this, html);
-      const documentElement = parsedDoc.children.find((elm) => elm.nodeName === "HTML");
-      if (documentElement != null) {
-        this.appendChild(documentElement);
-        setOwnerDocument(documentElement, this);
-      }
-    } else if (html !== false) {
-      const documentElement = new MockHTMLElement(this, "html");
-      this.appendChild(documentElement);
-      documentElement.appendChild(new MockHTMLElement(this, "head"));
-      documentElement.appendChild(new MockHTMLElement(this, "body"));
-    }
+  onpaste() {
   }
-  get dir() {
-    return this.documentElement.dir;
+  onpause() {
   }
-  set dir(value) {
-    this.documentElement.dir = value;
+  onplay() {
   }
-  get localName() {
-    throw new Error("Unimplemented");
+  onplaying() {
   }
-  get location() {
-    if (this.defaultView != null) {
-      return this.defaultView.location;
-    }
-    return null;
+  onpointercancel() {
   }
-  set location(val) {
-    if (this.defaultView != null) {
-      this.defaultView.location.href = val;
-    }
+  onpointerdown() {
   }
-  get baseURI() {
-    const baseNode = this.head.childNodes.find((node) => node.nodeName === "BASE");
-    if (baseNode) {
-      return baseNode.href;
-    }
-    return this.URL;
+  onpointerenter() {
   }
-  get URL() {
-    return this.location.href;
+  onpointerleave() {
   }
-  get styleSheets() {
-    return this.querySelectorAll("style");
+  onpointermove() {
   }
-  get scripts() {
-    return this.querySelectorAll("script");
+  onpointerout() {
   }
-  get forms() {
-    return this.querySelectorAll("form");
+  onpointerover() {
   }
-  get images() {
-    return this.querySelectorAll("img");
+  onpointerup() {
   }
-  get scrollingElement() {
-    return this.documentElement;
+  onprogress() {
   }
-  get documentElement() {
-    for (let i = this.childNodes.length - 1; i >= 0; i--) {
-      if (this.childNodes[i].nodeName === "HTML") {
-        return this.childNodes[i];
-      }
-    }
-    const documentElement = new MockHTMLElement(this, "html");
-    this.appendChild(documentElement);
-    return documentElement;
+  onratechange() {
   }
-  set documentElement(documentElement) {
-    for (let i = this.childNodes.length - 1; i >= 0; i--) {
-      if (this.childNodes[i].nodeType !== 10 /* DOCUMENT_TYPE_NODE */) {
-        this.childNodes[i].remove();
-      }
-    }
-    if (documentElement != null) {
-      this.appendChild(documentElement);
-      setOwnerDocument(documentElement, this);
-    }
+  onreset() {
   }
-  get head() {
-    const documentElement = this.documentElement;
-    for (let i = 0; i < documentElement.childNodes.length; i++) {
-      if (documentElement.childNodes[i].nodeName === "HEAD") {
-        return documentElement.childNodes[i];
-      }
-    }
-    const head = new MockHTMLElement(this, "head");
-    documentElement.insertBefore(head, documentElement.firstChild);
-    return head;
+  onresize() {
   }
-  set head(head) {
-    const documentElement = this.documentElement;
-    for (let i = documentElement.childNodes.length - 1; i >= 0; i--) {
-      if (documentElement.childNodes[i].nodeName === "HEAD") {
-        documentElement.childNodes[i].remove();
-      }
-    }
-    if (head != null) {
-      documentElement.insertBefore(head, documentElement.firstChild);
-      setOwnerDocument(head, this);
-    }
+  onscroll() {
   }
-  get body() {
-    const documentElement = this.documentElement;
-    for (let i = documentElement.childNodes.length - 1; i >= 0; i--) {
-      if (documentElement.childNodes[i].nodeName === "BODY") {
-        return documentElement.childNodes[i];
-      }
-    }
-    const body = new MockHTMLElement(this, "body");
-    documentElement.appendChild(body);
-    return body;
+  onsearch() {
   }
-  set body(body) {
-    const documentElement = this.documentElement;
-    for (let i = documentElement.childNodes.length - 1; i >= 0; i--) {
-      if (documentElement.childNodes[i].nodeName === "BODY") {
-        documentElement.childNodes[i].remove();
-      }
-    }
-    if (body != null) {
-      documentElement.appendChild(body);
-      setOwnerDocument(body, this);
-    }
+  onseeked() {
   }
-  appendChild(newNode) {
-    newNode.remove();
-    newNode.parentNode = this;
-    this.childNodes.push(newNode);
-    return newNode;
+  onseeking() {
   }
-  createComment(data) {
-    return new MockComment(this, data);
+  onselect() {
   }
-  createAttribute(attrName) {
-    return new MockAttr(attrName.toLowerCase(), "");
+  onselectstart() {
   }
-  createAttributeNS(namespaceURI, attrName) {
-    return new MockAttr(attrName, "", namespaceURI);
+  onstalled() {
   }
-  createElement(tagName) {
-    if (tagName === "#document" /* DOCUMENT_NODE */) {
-      const doc = new _MockDocument(false);
-      doc.nodeName = tagName;
-      doc.parentNode = null;
-      return doc;
-    }
-    return createElement(this, tagName);
+  onsubmit() {
   }
-  createElementNS(namespaceURI, tagName) {
-    const elmNs = createElementNS(this, namespaceURI, tagName);
-    return elmNs;
+  onsuspend() {
   }
-  createTextNode(text) {
-    return new MockTextNode(this, text);
+  ontimeupdate() {
   }
-  createDocumentFragment() {
-    return new MockDocumentFragment(this);
+  ontoggle() {
   }
-  createDocumentTypeNode() {
-    return new MockDocumentTypeNode(this);
+  onvolumechange() {
   }
-  getElementById(id) {
-    return getElementById(this, id);
+  onwaiting() {
   }
-  getElementsByName(elmName) {
-    return getElementsByName(this, elmName.toLowerCase());
+  onwebkitfullscreenchange() {
   }
-  get title() {
-    const title = this.head.childNodes.find((elm) => elm.nodeName === "TITLE");
-    if (title != null && typeof title.textContent === "string") {
-      return title.textContent.trim();
-    }
-    return "";
+  onwebkitfullscreenerror() {
   }
-  set title(value) {
-    const head = this.head;
-    let title = head.childNodes.find((elm) => elm.nodeName === "TITLE");
-    if (title == null) {
-      title = this.createElement("title");
-      head.appendChild(title);
-    }
-    title.textContent = value;
+  onwheel() {
   }
 };
-function resetDocument(doc) {
-  if (doc != null) {
-    resetEventListeners(doc);
-    const documentElement = doc.documentElement;
-    if (documentElement != null) {
-      resetElement(documentElement);
-      for (let i = 0, ii = documentElement.childNodes.length; i < ii; i++) {
-        const childNode = documentElement.childNodes[i];
-        resetElement(childNode);
-        childNode.childNodes.length = 0;
-      }
-    }
-    for (const key in doc) {
-      if (doc.hasOwnProperty(key) && !DOC_KEY_KEEPERS.has(key)) {
-        delete doc[key];
-      }
-    }
-    try {
-      doc.nodeName = "#document" /* DOCUMENT_NODE */;
-    } catch (e) {
-    }
-    try {
-      doc.nodeType = 9 /* DOCUMENT_NODE */;
-    } catch (e) {
-    }
-    try {
-      doc.cookie = "";
-    } catch (e) {
-    }
-    try {
-      doc.referrer = "";
-    } catch (e) {
-    }
+addGlobalsToWindowPrototype(MockWindow.prototype);
+function resetWindowDefaults(win2) {
+  win2.__clearInterval = nativeClearInterval;
+  win2.__clearTimeout = nativeClearTimeout;
+  win2.__setInterval = nativeSetInterval;
+  win2.__setTimeout = nativeSetTimeout;
+  win2.__maxTimeout = 6e4;
+  win2.__allowInterval = true;
+  win2.URL = nativeURL;
+}
+function cloneWindow(srcWin, opts = {}) {
+  if (srcWin == null) {
+    return null;
+  }
+  const clonedWin = new MockWindow(false);
+  if (!opts.customElementProxy) {
+    srcWin.customElements = null;
+  }
+  if (srcWin.document != null) {
+    const clonedDoc = new MockDocument(false, clonedWin);
+    clonedWin.document = clonedDoc;
+    clonedDoc.documentElement = srcWin.document.documentElement.cloneNode(true);
+  } else {
+    clonedWin.document = new MockDocument(null, clonedWin);
   }
+  return clonedWin;
 }
-var DOC_KEY_KEEPERS = /* @__PURE__ */ new Set([
-  "nodeName",
-  "nodeType",
-  "nodeValue",
-  "ownerDocument",
-  "parentNode",
-  "childNodes",
-  "_shadowRoot"
-]);
-function getElementById(elm, id) {
-  const children = elm.children;
-  for (let i = 0, ii = children.length; i < ii; i++) {
-    const childElm = children[i];
-    if (childElm.id === id) {
-      return childElm;
+function constrainTimeouts(win2) {
+  win2.__allowInterval = false;
+  win2.__maxTimeout = 0;
+}
+function resetWindow(win2) {
+  if (win2 != null) {
+    if (win2.__timeouts) {
+      win2.__timeouts.forEach((timeoutId) => {
+        nativeClearInterval(timeoutId);
+        nativeClearTimeout(timeoutId);
+      });
+      win2.__timeouts.clear();
     }
-    const childElmFound = getElementById(childElm, id);
-    if (childElmFound != null) {
-      return childElmFound;
+    if (win2.customElements && win2.customElements.clear) {
+      win2.customElements.clear();
     }
-  }
-  return null;
-}
-function getElementsByName(elm, elmName, foundElms = []) {
-  const children = elm.children;
-  for (let i = 0, ii = children.length; i < ii; i++) {
-    const childElm = children[i];
-    if (childElm.name && childElm.name.toLowerCase() === elmName) {
-      foundElms.push(childElm);
+    resetDocument(win2.document);
+    resetPerformance(win2.performance);
+    for (const key in win2) {
+      if (win2.hasOwnProperty(key) && key !== "document" && key !== "performance" && key !== "customElements") {
+        delete win2[key];
+      }
     }
-    getElementsByName(childElm, elmName, foundElms);
-  }
-  return foundElms;
-}
-function setOwnerDocument(elm, ownerDocument) {
-  for (let i = 0, ii = elm.childNodes.length; i < ii; i++) {
-    elm.childNodes[i].ownerDocument = ownerDocument;
-    if (elm.childNodes[i].nodeType === 1 /* ELEMENT_NODE */) {
-      setOwnerDocument(elm.childNodes[i], ownerDocument);
+    resetWindowDefaults(win2);
+    resetWindowDimensions(win2);
+    resetEventListeners(win2);
+    if (win2.document != null) {
+      try {
+        win2.document.defaultView = win2;
+      } catch (e) {
+      }
     }
+    win2.fetch = null;
+    win2.Headers = null;
+    win2.Request = null;
+    win2.Response = null;
+    win2.FetchError = null;
   }
 }
-
-// src/hydrate/runner/create-window.ts
-var templateWindows = /* @__PURE__ */ new Map();
-function createWindowFromHtml(templateHtml, uniqueId) {
-  let templateWindow = templateWindows.get(uniqueId);
-  if (templateWindow == null) {
-    templateWindow = new MockWindow(templateHtml);
-    templateWindows.set(uniqueId, templateWindow);
-  }
-  const win2 = cloneWindow(templateWindow);
-  return win2;
-}
-
-// src/hydrate/runner/render.ts
-import { Readable } from "stream";
-import { hydrateFactory } from "@stencil/core/hydrate-factory";
-
-// src/client/client-build.ts
-import { BUILD } from "@stencil/core/internal/app-data";
-var Build = {
-  isDev: BUILD.isDev ? true : false,
-  isBrowser: true,
-  isServer: false,
-  isTesting: BUILD.isTesting ? true : false
-};
-
-// src/client/client-host-ref.ts
-import { BUILD as BUILD3 } from "@stencil/core/internal/app-data";
-
-// src/utils/constants.ts
-var PrimitiveType = /* @__PURE__ */ ((PrimitiveType2) => {
-  PrimitiveType2["Undefined"] = "undefined";
-  PrimitiveType2["Null"] = "null";
-  PrimitiveType2["String"] = "string";
-  PrimitiveType2["Number"] = "number";
-  PrimitiveType2["SpecialNumber"] = "number";
-  PrimitiveType2["Boolean"] = "boolean";
-  PrimitiveType2["BigInt"] = "bigint";
-  return PrimitiveType2;
-})(PrimitiveType || {});
-var NonPrimitiveType = /* @__PURE__ */ ((NonPrimitiveType2) => {
-  NonPrimitiveType2["Array"] = "array";
-  NonPrimitiveType2["Date"] = "date";
-  NonPrimitiveType2["Map"] = "map";
-  NonPrimitiveType2["Object"] = "object";
-  NonPrimitiveType2["RegularExpression"] = "regexp";
-  NonPrimitiveType2["Set"] = "set";
-  NonPrimitiveType2["Channel"] = "channel";
-  NonPrimitiveType2["Symbol"] = "symbol";
-  return NonPrimitiveType2;
-})(NonPrimitiveType || {});
-var TYPE_CONSTANT = "type";
-var VALUE_CONSTANT = "value";
-var SERIALIZED_PREFIX = "serialized:";
-
-// src/utils/es2022-rewire-class-members.ts
-import { BUILD as BUILD2 } from "@stencil/core/internal/app-data";
-
-// src/client/client-load-module.ts
-import { BUILD as BUILD5 } from "@stencil/core/internal/app-data";
-
-// src/client/client-log.ts
-import { BUILD as BUILD4 } from "@stencil/core/internal/app-data";
-var STENCIL_DEV_MODE = BUILD4.isTesting ? ["STENCIL:"] : [
-  "%cstencil",
-  "color: white;background:#4c47ff;font-weight: bold; font-size:10px; padding:2px 6px; border-radius: 5px"
-];
-
-// src/client/client-style.ts
-var modeResolutionChain = [];
-
-// src/client/client-task-queue.ts
-import { BUILD as BUILD7 } from "@stencil/core/internal/app-data";
-
-// src/client/client-window.ts
-import { BUILD as BUILD6 } from "@stencil/core/internal/app-data";
-var win = typeof window !== "undefined" ? window : {};
-var H = win.HTMLElement || class {
-};
-var supportsShadow = BUILD6.shadowDom;
-var supportsConstructableStylesheets = BUILD6.constructableCSS ? /* @__PURE__ */ (() => {
+function resetWindowDimensions(win2) {
   try {
-    new CSSStyleSheet();
-    return typeof new CSSStyleSheet().replaceSync === "function";
+    win2.devicePixelRatio = 1;
+    win2.innerHeight = 768;
+    win2.innerWidth = 1366;
+    win2.pageXOffset = 0;
+    win2.pageYOffset = 0;
+    win2.screenLeft = 0;
+    win2.screenTop = 0;
+    win2.screenX = 0;
+    win2.screenY = 0;
+    win2.scrollX = 0;
+    win2.scrollY = 0;
+    win2.screen = {
+      availHeight: win2.innerHeight,
+      availLeft: 0,
+      availTop: 0,
+      availWidth: win2.innerWidth,
+      colorDepth: 24,
+      height: win2.innerHeight,
+      keepAwake: false,
+      orientation: {
+        angle: 0,
+        type: "portrait-primary"
+      },
+      pixelDepth: 24,
+      width: win2.innerWidth
+    };
   } catch (e) {
   }
-  return false;
-})() : false;
-
-// src/client/index.ts
-import { BUILD as BUILD31, Env, NAMESPACE as NAMESPACE2 } from "@stencil/core/internal/app-data";
-
-// src/runtime/bootstrap-custom-element.ts
-import { BUILD as BUILD27 } from "@stencil/core/internal/app-data";
-
-// src/utils/helpers.ts
-var isString = (v) => typeof v === "string";
+}
 
-// src/utils/local-value.ts
-var LocalValue = class _LocalValue {
-  constructor(type, value) {
-    if (type === "undefined" /* Undefined */ || type === "null" /* Null */) {
-      this.type = type;
-    } else {
-      this.type = type;
-      this.value = value;
+// src/mock-doc/document.ts
+var MockDocument = class _MockDocument extends MockHTMLElement {
+  constructor(html = null, win2 = null) {
+    super(null, null);
+    this.nodeName = "#document" /* DOCUMENT_NODE */;
+    this.nodeType = 9 /* DOCUMENT_NODE */;
+    this.defaultView = win2;
+    this.cookie = "";
+    this.referrer = "";
+    this.appendChild(this.createDocumentTypeNode());
+    if (typeof html === "string") {
+      const parsedDoc = parseDocumentUtil(this, html);
+      const documentElement = parsedDoc.children.find((elm) => elm.nodeName === "HTML");
+      if (documentElement != null) {
+        this.appendChild(documentElement);
+        setOwnerDocument(documentElement, this);
+      }
+    } else if (html !== false) {
+      const documentElement = new MockHTMLElement(this, "html");
+      this.appendChild(documentElement);
+      documentElement.appendChild(new MockHTMLElement(this, "head"));
+      documentElement.appendChild(new MockHTMLElement(this, "body"));
     }
   }
-  /**
-   * Creates a new LocalValue object with a string value.
-   *
-   * @param {string} value - The string value to be stored in the LocalValue object.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createStringValue(value) {
-    return new _LocalValue("string" /* String */, value);
+  get dir() {
+    return this.documentElement.dir;
   }
-  /**
-   * Creates a new LocalValue object with a number value.
-   *
-   * @param {number} value - The number value.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createNumberValue(value) {
-    return new _LocalValue("number" /* Number */, value);
+  set dir(value) {
+    this.documentElement.dir = value;
   }
-  /**
-   * Creates a new LocalValue object with a special number value.
-   *
-   * @param {number} value - The value of the special number.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createSpecialNumberValue(value) {
-    if (Number.isNaN(value)) {
-      return new _LocalValue("number" /* SpecialNumber */, "NaN");
-    }
-    if (Object.is(value, -0)) {
-      return new _LocalValue("number" /* SpecialNumber */, "-0");
+  get localName() {
+    throw new Error("Unimplemented");
+  }
+  get location() {
+    if (this.defaultView != null) {
+      return this.defaultView.location;
     }
-    if (value === Infinity) {
-      return new _LocalValue("number" /* SpecialNumber */, "Infinity");
+    return null;
+  }
+  set location(val) {
+    if (this.defaultView != null) {
+      this.defaultView.location.href = val;
     }
-    if (value === -Infinity) {
-      return new _LocalValue("number" /* SpecialNumber */, "-Infinity");
+  }
+  get baseURI() {
+    const baseNode = this.head.childNodes.find((node) => node.nodeName === "BASE");
+    if (baseNode) {
+      return baseNode.href;
     }
-    return new _LocalValue("number" /* SpecialNumber */, value);
+    return this.URL;
   }
-  /**
-   * Creates a new LocalValue object with an undefined value.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createUndefinedValue() {
-    return new _LocalValue("undefined" /* Undefined */);
+  get URL() {
+    return this.location.href;
   }
-  /**
-   * Creates a new LocalValue object with a null value.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createNullValue() {
-    return new _LocalValue("null" /* Null */);
+  get styleSheets() {
+    return this.querySelectorAll("style");
   }
-  /**
-   * Creates a new LocalValue object with a boolean value.
-   *
-   * @param {boolean} value - The boolean value.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createBooleanValue(value) {
-    return new _LocalValue("boolean" /* Boolean */, value);
+  get scripts() {
+    return this.querySelectorAll("script");
   }
-  /**
-   * Creates a new LocalValue object with a BigInt value.
-   *
-   * @param {BigInt} value - The BigInt value.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createBigIntValue(value) {
-    return new _LocalValue("bigint" /* BigInt */, value.toString());
+  get forms() {
+    return this.querySelectorAll("form");
   }
-  /**
-   * Creates a new LocalValue object with an array.
-   *
-   * @param {Array} value - The array.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createArrayValue(value) {
-    return new _LocalValue("array" /* Array */, value);
+  get images() {
+    return this.querySelectorAll("img");
   }
-  /**
-   * Creates a new LocalValue object with date value.
-   *
-   * @param {string} value - The date.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createDateValue(value) {
-    return new _LocalValue("date" /* Date */, value);
+  get scrollingElement() {
+    return this.documentElement;
   }
-  /**
-   * Creates a new LocalValue object of map value.
-   * @param {Map} map - The map.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createMapValue(map2) {
-    const value = [];
-    Array.from(map2.entries()).forEach(([key, val]) => {
-      value.push([_LocalValue.getArgument(key), _LocalValue.getArgument(val)]);
-    });
-    return new _LocalValue("map" /* Map */, value);
+  get documentElement() {
+    for (let i = this.childNodes.length - 1; i >= 0; i--) {
+      if (this.childNodes[i].nodeName === "HTML") {
+        return this.childNodes[i];
+      }
+    }
+    const documentElement = new MockHTMLElement(this, "html");
+    this.appendChild(documentElement);
+    return documentElement;
   }
-  /**
-   * Creates a new LocalValue object from the passed object.
-   *
-   * @param object the object to create a LocalValue from
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createObjectValue(object) {
-    const value = [];
-    Object.entries(object).forEach(([key, val]) => {
-      value.push([key, _LocalValue.getArgument(val)]);
-    });
-    return new _LocalValue("object" /* Object */, value);
+  set documentElement(documentElement) {
+    for (let i = this.childNodes.length - 1; i >= 0; i--) {
+      if (this.childNodes[i].nodeType !== 10 /* DOCUMENT_TYPE_NODE */) {
+        this.childNodes[i].remove();
+      }
+    }
+    if (documentElement != null) {
+      this.appendChild(documentElement);
+      setOwnerDocument(documentElement, this);
+    }
   }
-  /**
-   * Creates a new LocalValue object of regular expression value.
-   *
-   * @param {string} value - The value of the regular expression.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createRegularExpressionValue(value) {
-    return new _LocalValue("regexp" /* RegularExpression */, value);
+  get head() {
+    const documentElement = this.documentElement;
+    for (let i = 0; i < documentElement.childNodes.length; i++) {
+      if (documentElement.childNodes[i].nodeName === "HEAD") {
+        return documentElement.childNodes[i];
+      }
+    }
+    const head = new MockHTMLElement(this, "head");
+    documentElement.insertBefore(head, documentElement.firstChild);
+    return head;
+  }
+  set head(head) {
+    const documentElement = this.documentElement;
+    for (let i = documentElement.childNodes.length - 1; i >= 0; i--) {
+      if (documentElement.childNodes[i].nodeName === "HEAD") {
+        documentElement.childNodes[i].remove();
+      }
+    }
+    if (head != null) {
+      documentElement.insertBefore(head, documentElement.firstChild);
+      setOwnerDocument(head, this);
+    }
+  }
+  get body() {
+    const documentElement = this.documentElement;
+    for (let i = documentElement.childNodes.length - 1; i >= 0; i--) {
+      if (documentElement.childNodes[i].nodeName === "BODY") {
+        return documentElement.childNodes[i];
+      }
+    }
+    const body = new MockHTMLElement(this, "body");
+    documentElement.appendChild(body);
+    return body;
+  }
+  set body(body) {
+    const documentElement = this.documentElement;
+    for (let i = documentElement.childNodes.length - 1; i >= 0; i--) {
+      if (documentElement.childNodes[i].nodeName === "BODY") {
+        documentElement.childNodes[i].remove();
+      }
+    }
+    if (body != null) {
+      documentElement.appendChild(body);
+      setOwnerDocument(body, this);
+    }
+  }
+  appendChild(newNode) {
+    newNode.remove();
+    newNode.parentNode = this;
+    this.childNodes.push(newNode);
+    return newNode;
   }
-  /**
-   * Creates a new LocalValue object with the specified value.
-   * @param {Set} value - The value to be set.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createSetValue(value) {
-    return new _LocalValue("set" /* Set */, value);
+  createComment(data) {
+    return new MockComment(this, data);
   }
-  /**
-   * Creates a new LocalValue object with the given channel value
-   *
-   * @param {ChannelValue} value - The channel value.
-   * @returns {LocalValue} - The created LocalValue object.
-   */
-  static createChannelValue(value) {
-    return new _LocalValue("channel" /* Channel */, value);
+  createAttribute(attrName) {
+    return new MockAttr(attrName.toLowerCase(), "");
   }
-  /**
-   * Creates a new LocalValue object with a Symbol value.
-   *
-   * @param {Symbol} symbol - The Symbol value
-   * @returns {LocalValue} - The created LocalValue object
-   */
-  static createSymbolValue(symbol) {
-    const description = symbol.description || "Symbol()";
-    return new _LocalValue("symbol" /* Symbol */, description);
+  createAttributeNS(namespaceURI, attrName) {
+    return new MockAttr(attrName, "", namespaceURI);
   }
-  static getArgument(argument) {
-    const type = typeof argument;
-    switch (type) {
-      case "string" /* String */:
-        return _LocalValue.createStringValue(argument);
-      case "number" /* Number */:
-        if (Number.isNaN(argument) || Object.is(argument, -0) || !Number.isFinite(argument)) {
-          return _LocalValue.createSpecialNumberValue(argument);
-        }
-        return _LocalValue.createNumberValue(argument);
-      case "boolean" /* Boolean */:
-        return _LocalValue.createBooleanValue(argument);
-      case "bigint" /* BigInt */:
-        return _LocalValue.createBigIntValue(argument);
-      case "undefined" /* Undefined */:
-        return _LocalValue.createUndefinedValue();
-      case "symbol" /* Symbol */:
-        return _LocalValue.createSymbolValue(argument);
-      case "object" /* Object */:
-        if (argument === null) {
-          return _LocalValue.createNullValue();
-        }
-        if (argument instanceof Date) {
-          return _LocalValue.createDateValue(argument);
-        }
-        if (argument instanceof Map) {
-          const map2 = [];
-          argument.forEach((value, key) => {
-            const objectKey = typeof key === "string" ? key : _LocalValue.getArgument(key);
-            const objectValue = _LocalValue.getArgument(value);
-            map2.push([objectKey, objectValue]);
-          });
-          return _LocalValue.createMapValue(argument);
-        }
-        if (argument instanceof Set) {
-          const set = [];
-          argument.forEach((value) => {
-            set.push(_LocalValue.getArgument(value));
-          });
-          return _LocalValue.createSetValue(set);
-        }
-        if (argument instanceof Array) {
-          const arr = [];
-          argument.forEach((value) => {
-            arr.push(_LocalValue.getArgument(value));
-          });
-          return _LocalValue.createArrayValue(arr);
-        }
-        if (argument instanceof RegExp) {
-          return _LocalValue.createRegularExpressionValue({
-            pattern: argument.source,
-            flags: argument.flags
-          });
-        }
-        return _LocalValue.createObjectValue(argument);
+  createElement(tagName) {
+    if (tagName === "#document" /* DOCUMENT_NODE */) {
+      const doc = new _MockDocument(false);
+      doc.nodeName = tagName;
+      doc.parentNode = null;
+      return doc;
     }
-    throw new Error(`Unsupported type: ${type}`);
+    return createElement(this, tagName);
   }
-  asMap() {
-    return {
-      [TYPE_CONSTANT]: this.type,
-      ...!(this.type === "null" /* Null */ || this.type === "undefined" /* Undefined */) ? { [VALUE_CONSTANT]: this.value } : {}
-    };
+  createElementNS(namespaceURI, tagName) {
+    const elmNs = createElementNS(this, namespaceURI, tagName);
+    return elmNs;
   }
-};
-
-// src/utils/message-utils.ts
-var catchError = (diagnostics, err2, msg) => {
-  const diagnostic = {
-    level: "error",
-    type: "build",
-    header: "Build Error",
-    messageText: "build error",
-    lines: []
-  };
-  if (isString(msg)) {
-    diagnostic.messageText = msg.length ? msg : "UNKNOWN ERROR";
-  } else if (err2 != null) {
-    if (err2.stack != null) {
-      diagnostic.messageText = err2.stack.toString();
-    } else {
-      if (err2.message != null) {
-        diagnostic.messageText = err2.message.length ? err2.message : "UNKNOWN ERROR";
-      } else {
-        diagnostic.messageText = err2.toString();
-      }
-    }
+  createTextNode(text) {
+    return new MockTextNode(this, text);
   }
-  if (diagnostics != null && !shouldIgnoreError(diagnostic.messageText)) {
-    diagnostics.push(diagnostic);
+  createDocumentFragment() {
+    return new MockDocumentFragment(this);
   }
-  return diagnostic;
-};
-var hasError = (diagnostics) => {
-  if (diagnostics == null || diagnostics.length === 0) {
-    return false;
+  createDocumentTypeNode() {
+    return new MockDocumentTypeNode(this);
   }
-  return diagnostics.some((d) => d.level === "error" && d.type !== "runtime");
-};
-var shouldIgnoreError = (msg) => {
-  return msg === TASK_CANCELED_MSG;
-};
-var TASK_CANCELED_MSG = `task canceled`;
-
-// src/utils/regular-expression.ts
-var escapeRegExpSpecialCharacters = (text) => {
-  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-};
-
-// src/utils/remote-value.ts
-var RemoteValue = class _RemoteValue {
-  /**
-   * Deserializes a LocalValue serialized object back to its original JavaScript representation
-   *
-   * @param serialized The serialized LocalValue object
-   * @returns The original JavaScript value/object
-   */
-  static fromLocalValue(serialized) {
-    const type = serialized[TYPE_CONSTANT];
-    const value = VALUE_CONSTANT in serialized ? serialized[VALUE_CONSTANT] : void 0;
-    switch (type) {
-      case "string" /* String */:
-        return value;
-      case "boolean" /* Boolean */:
-        return value;
-      case "bigint" /* BigInt */:
-        return BigInt(value);
-      case "undefined" /* Undefined */:
-        return void 0;
-      case "null" /* Null */:
-        return null;
-      case "number" /* Number */:
-        if (value === "NaN") return NaN;
-        if (value === "-0") return -0;
-        if (value === "Infinity") return Infinity;
-        if (value === "-Infinity") return -Infinity;
-        return value;
-      case "array" /* Array */:
-        return value.map((item) => _RemoteValue.fromLocalValue(item));
-      case "date" /* Date */:
-        return new Date(value);
-      case "map" /* Map */:
-        const map2 = /* @__PURE__ */ new Map();
-        for (const [key, val] of value) {
-          const deserializedKey = typeof key === "object" && key !== null ? _RemoteValue.fromLocalValue(key) : key;
-          const deserializedValue = _RemoteValue.fromLocalValue(val);
-          map2.set(deserializedKey, deserializedValue);
-        }
-        return map2;
-      case "object" /* Object */:
-        const obj = {};
-        for (const [key, val] of value) {
-          obj[key] = _RemoteValue.fromLocalValue(val);
-        }
-        return obj;
-      case "regexp" /* RegularExpression */:
-        const { pattern, flags } = value;
-        return new RegExp(pattern, flags);
-      case "set" /* Set */:
-        const set = /* @__PURE__ */ new Set();
-        for (const item of value) {
-          set.add(_RemoteValue.fromLocalValue(item));
-        }
-        return set;
-      case "symbol" /* Symbol */:
-        return Symbol(value);
-      default:
-        throw new Error(`Unsupported type: ${type}`);
+  getElementById(id) {
+    return getElementById(this, id);
+  }
+  getElementsByName(elmName) {
+    return getElementsByName(this, elmName.toLowerCase());
+  }
+  get title() {
+    const title = this.head.childNodes.find((elm) => elm.nodeName === "TITLE");
+    if (title != null && typeof title.textContent === "string") {
+      return title.textContent.trim();
     }
+    return "";
   }
-  /**
-   * Utility method to deserialize multiple LocalValues at once
-   *
-   * @param serializedValues Array of serialized LocalValue objects
-   * @returns Array of deserialized JavaScript values
-   */
-  static fromLocalValueArray(serializedValues) {
-    return serializedValues.map((value) => _RemoteValue.fromLocalValue(value));
+  set title(value) {
+    const head = this.head;
+    let title = head.childNodes.find((elm) => elm.nodeName === "TITLE");
+    if (title == null) {
+      title = this.createElement("title");
+      head.appendChild(title);
+    }
+    title.textContent = value;
   }
-  /**
-   * Verifies if the given object matches the structure of a serialized LocalValue
-   *
-   * @param obj Object to verify
-   * @returns boolean indicating if the object has LocalValue structure
-   */
-  static isLocalValueObject(obj) {
-    if (typeof obj !== "object" || obj === null) {
-      return false;
+};
+function resetDocument(doc) {
+  if (doc != null) {
+    resetEventListeners(doc);
+    const documentElement = doc.documentElement;
+    if (documentElement != null) {
+      resetElement(documentElement);
+      for (let i = 0, ii = documentElement.childNodes.length; i < ii; i++) {
+        const childNode = documentElement.childNodes[i];
+        resetElement(childNode);
+        childNode.childNodes.length = 0;
+      }
     }
-    if (!obj.hasOwnProperty(TYPE_CONSTANT)) {
-      return false;
+    for (const key in doc) {
+      if (doc.hasOwnProperty(key) && !DOC_KEY_KEEPERS.has(key)) {
+        delete doc[key];
+      }
     }
-    const type = obj[TYPE_CONSTANT];
-    const hasTypeProperty = Object.values({ ...PrimitiveType, ...NonPrimitiveType }).includes(type);
-    if (!hasTypeProperty) {
-      return false;
+    try {
+      doc.nodeName = "#document" /* DOCUMENT_NODE */;
+    } catch (e) {
     }
-    if (type !== "null" /* Null */ && type !== "undefined" /* Undefined */) {
-      return obj.hasOwnProperty(VALUE_CONSTANT);
+    try {
+      doc.nodeType = 9 /* DOCUMENT_NODE */;
+    } catch (e) {
     }
-    return true;
-  }
-};
-
-// src/utils/result.ts
-var result_exports = {};
-__export(result_exports, {
-  err: () => err,
-  map: () => map,
-  ok: () => ok,
-  unwrap: () => unwrap,
-  unwrapErr: () => unwrapErr
-});
-var ok = (value) => ({
-  isOk: true,
-  isErr: false,
-  value
-});
-var err = (value) => ({
-  isOk: false,
-  isErr: true,
-  value
-});
-function map(result, fn) {
-  if (result.isOk) {
-    const val = fn(result.value);
-    if (val instanceof Promise) {
-      return val.then((newVal) => ok(newVal));
-    } else {
-      return ok(val);
+    try {
+      doc.cookie = "";
+    } catch (e) {
+    }
+    try {
+      doc.referrer = "";
+    } catch (e) {
     }
   }
-  if (result.isErr) {
-    const value = result.value;
-    return err(value);
-  }
-  throw "should never get here";
 }
-var unwrap = (result) => {
-  if (result.isOk) {
-    return result.value;
-  } else {
-    throw result.value;
-  }
-};
-var unwrapErr = (result) => {
-  if (result.isErr) {
-    return result.value;
-  } else {
-    throw result.value;
+var DOC_KEY_KEEPERS = /* @__PURE__ */ new Set([
+  "nodeName",
+  "nodeType",
+  "nodeValue",
+  "ownerDocument",
+  "parentNode",
+  "childNodes",
+  "_shadowRoot"
+]);
+function getElementById(elm, id) {
+  const children = elm.children;
+  for (let i = 0, ii = children.length; i < ii; i++) {
+    const childElm = children[i];
+    if (childElm.id === id) {
+      return childElm;
+    }
+    const childElmFound = getElementById(childElm, id);
+    if (childElmFound != null) {
+      return childElmFound;
+    }
   }
-};
-
-// src/utils/serialize.ts
-function serializeProperty(value) {
-  if (["string", "boolean", "undefined"].includes(typeof value) || typeof value === "number" && value !== Infinity && value !== -Infinity && !isNaN(value)) {
-    return value;
+  return null;
+}
+function getElementsByName(elm, elmName, foundElms = []) {
+  const children = elm.children;
+  for (let i = 0, ii = children.length; i < ii; i++) {
+    const childElm = children[i];
+    if (childElm.name && childElm.name.toLowerCase() === elmName) {
+      foundElms.push(childElm);
+    }
+    getElementsByName(childElm, elmName, foundElms);
   }
-  const arg = LocalValue.getArgument(value);
-  return SERIALIZED_PREFIX + btoa(JSON.stringify(arg));
+  return foundElms;
 }
-function deserializeProperty(value) {
-  if (typeof value !== "string" || !value.startsWith(SERIALIZED_PREFIX)) {
-    return value;
+function setOwnerDocument(elm, ownerDocument) {
+  for (let i = 0, ii = elm.childNodes.length; i < ii; i++) {
+    elm.childNodes[i].ownerDocument = ownerDocument;
+    if (elm.childNodes[i].nodeType === 1 /* ELEMENT_NODE */) {
+      setOwnerDocument(elm.childNodes[i], ownerDocument);
+    }
   }
-  return RemoteValue.fromLocalValue(JSON.parse(atob(value.slice(SERIALIZED_PREFIX.length))));
 }
 
-// src/utils/shadow-root.ts
-import { BUILD as BUILD8 } from "@stencil/core/internal/app-data";
-
-// src/utils/util.ts
-var lowerPathParam = (fn) => (p) => fn(p.toLowerCase());
-var isDtsFile = lowerPathParam((p) => p.endsWith(".d.ts") || p.endsWith(".d.mts") || p.endsWith(".d.cts"));
-var isTsFile = lowerPathParam(
-  (p) => !isDtsFile(p) && (p.endsWith(".ts") || p.endsWith(".mts") || p.endsWith(".cts"))
-);
-var isTsxFile = lowerPathParam(
-  (p) => p.endsWith(".tsx") || p.endsWith(".mtsx") || p.endsWith(".ctsx")
-);
-var isJsxFile = lowerPathParam(
-  (p) => p.endsWith(".jsx") || p.endsWith(".mjsx") || p.endsWith(".cjsx")
-);
-var isJsFile = lowerPathParam((p) => p.endsWith(".js") || p.endsWith(".mjs") || p.endsWith(".cjs"));
-
-// src/runtime/connected-callback.ts
-import { BUILD as BUILD25 } from "@stencil/core/internal/app-data";
-
-// src/runtime/client-hydrate.ts
-import { BUILD as BUILD14 } from "@stencil/core/internal/app-data";
-
-// src/runtime/dom-extras.ts
-import { BUILD as BUILD10 } from "@stencil/core/internal/app-data";
-
-// src/runtime/slot-polyfill-utils.ts
-import { BUILD as BUILD9 } from "@stencil/core/internal/app-data";
-
-// src/runtime/profile.ts
-import { BUILD as BUILD11 } from "@stencil/core/internal/app-data";
-
-// src/runtime/styles.ts
-import { BUILD as BUILD12 } from "@stencil/core/internal/app-data";
-
-// src/runtime/vdom/h.ts
-import { BUILD as BUILD13 } from "@stencil/core/internal/app-data";
-
-// src/runtime/initialize-component.ts
-import { BUILD as BUILD24 } from "@stencil/core/internal/app-data";
-
-// src/utils/shadow-css.ts
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- *
- * This file is a port of shadowCSS from `webcomponents.js` to TypeScript.
- * https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js
- * https://github.com/angular/angular/blob/master/packages/compiler/src/shadow_css.ts
- */
-var _polyfillHost = "-shadowcsshost";
-var _polyfillSlotted = "-shadowcssslotted";
-var _polyfillHostContext = "-shadowcsscontext";
-var _parenSuffix = ")(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))?([^,{]*)";
-var _cssColonHostRe = new RegExp("(" + _polyfillHost + _parenSuffix, "gim");
-var _cssColonHostContextRe = new RegExp("(" + _polyfillHostContext + _parenSuffix, "gim");
-var _cssColonSlottedRe = new RegExp("(" + _polyfillSlotted + _parenSuffix, "gim");
-var _polyfillHostNoCombinator = _polyfillHost + "-no-combinator";
-var createSupportsRuleRe = (selector) => {
-  const safeSelector = escapeRegExpSpecialCharacters(selector);
-  return new RegExp(
-    // First capture group: match any context before the selector that's not inside @supports selector()
-    // Using negative lookahead to avoid matching inside @supports selector(...) condition
-    `(^|[^@]|@(?!supports\\s+selector\\s*\\([^{]*?${safeSelector}))(${safeSelector}\\b)`,
-    "g"
-  );
-};
-var _colonSlottedRe = createSupportsRuleRe("::slotted");
-var _colonHostRe = createSupportsRuleRe(":host");
-var _colonHostContextRe = createSupportsRuleRe(":host-context");
-
-// src/runtime/mode.ts
-var setMode = (handler) => modeResolutionChain.push(handler);
-
-// src/runtime/proxy-component.ts
-import { BUILD as BUILD23 } from "@stencil/core/internal/app-data";
-
-// src/runtime/set-value.ts
-import { BUILD as BUILD22 } from "@stencil/core/internal/app-data";
-
-// src/runtime/parse-property-value.ts
-import { BUILD as BUILD15 } from "@stencil/core/internal/app-data";
-
-// src/runtime/update-component.ts
-import { BUILD as BUILD21, NAMESPACE } from "@stencil/core/internal/app-data";
-
-// src/runtime/event-emitter.ts
-import { BUILD as BUILD17 } from "@stencil/core/internal/app-data";
-
-// src/runtime/element.ts
-import { BUILD as BUILD16 } from "@stencil/core/internal/app-data";
-
-// src/runtime/vdom/vdom-render.ts
-import { BUILD as BUILD20 } from "@stencil/core/internal/app-data";
-
-// src/runtime/vdom/update-element.ts
-import { BUILD as BUILD19 } from "@stencil/core/internal/app-data";
-
-// src/runtime/vdom/set-accessor.ts
-import { BUILD as BUILD18 } from "@stencil/core/internal/app-data";
-var CAPTURE_EVENT_SUFFIX = "Capture";
-var CAPTURE_EVENT_REGEX = new RegExp(CAPTURE_EVENT_SUFFIX + "$");
-
-// src/runtime/disconnected-callback.ts
-import { BUILD as BUILD26 } from "@stencil/core/internal/app-data";
-
-// src/runtime/bootstrap-lazy.ts
-import { BUILD as BUILD28 } from "@stencil/core/internal/app-data";
-
-// src/runtime/host-listener.ts
-import { BUILD as BUILD29 } from "@stencil/core/internal/app-data";
+// src/hydrate/runner/create-window.ts
+var templateWindows = /* @__PURE__ */ new Map();
+function createWindowFromHtml(templateHtml, uniqueId) {
+  let templateWindow = templateWindows.get(uniqueId);
+  if (templateWindow == null) {
+    templateWindow = new MockWindow(templateHtml);
+    templateWindows.set(uniqueId, templateWindow);
+  }
+  const win2 = cloneWindow(templateWindow);
+  return win2;
+}
 
-// src/runtime/mixin.ts
-import { BUILD as BUILD30 } from "@stencil/core/internal/app-data";
-var baseClass = BUILD30.lazyLoad ? class {
-} : globalThis.HTMLElement || class {
-};
+// src/hydrate/runner/render.ts
+import { Readable } from "stream";
+import { hydrateFactory } from "@stencil/core/hydrate-factory";
 
 // src/compiler/html/canonical-link.ts
 var updateCanonicalLink = (doc, href) => {
@@ -16162,6 +16178,15 @@ function removeScripts(elm) {
     }
   }
 }
+
+// src/hydrate/runner/index.ts
+var everywhere;
+try {
+  everywhere = global || globalThis;
+} catch (e) {
+  everywhere = window || globalThis;
+}
+everywhere.tagTransform = transformTag;
 export {
   createWindowFromHtml,
   deserializeProperty,
@@ -16169,5 +16194,7 @@ export {
   renderToString,
   serializeDocumentToString,
   serializeProperty,
-  streamToString
+  setTagTransformer,
+  streamToString,
+  transformTag
 };