@digipair/skill-web 0.47.2 → 0.47.3

package/index.esm.js

@@ -13,27 +13,165 @@ function _extends() {
 
 /**
  * @license
- * Copyright 2021 Google LLC
+ * Copyright 2023 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
- */ var replacements = {
-    "&": "&",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    // Note &apos; was not defined in the HTML4 spec, and is not supported by very
-    // old browsers like IE8, so a codepoint entity is used instead.
-    "'": "&#39;"
-};
-/**
- * Replaces characters which have special meaning in HTML (&<>"') with escaped
- * HTML entities ("&amp;", "&lt;", etc.).
- */ var escapeHtml = function(str) {
-    return str.replace(/[&<>"']/g, function(char) {
-        return replacements[char];
-    });
+ */ /**
+ * Map of ARIAMixin properties to attributes
+ */ function _class_call_check$A(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$z(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$z(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$z(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$z(Constructor, staticProps);
+    return Constructor;
+}
+var ariaMixinAttributes = {
+    ariaAtomic: "aria-atomic",
+    ariaAutoComplete: "aria-autocomplete",
+    ariaBrailleLabel: "aria-braillelabel",
+    ariaBrailleRoleDescription: "aria-brailleroledescription",
+    ariaBusy: "aria-busy",
+    ariaChecked: "aria-checked",
+    ariaColCount: "aria-colcount",
+    ariaColIndex: "aria-colindex",
+    ariaColSpan: "aria-colspan",
+    ariaCurrent: "aria-current",
+    ariaDescription: "aria-description",
+    ariaDisabled: "aria-disabled",
+    ariaExpanded: "aria-expanded",
+    ariaHasPopup: "aria-haspopup",
+    ariaHidden: "aria-hidden",
+    ariaInvalid: "aria-invalid",
+    ariaKeyShortcuts: "aria-keyshortcuts",
+    ariaLabel: "aria-label",
+    ariaLevel: "aria-level",
+    ariaLive: "aria-live",
+    ariaModal: "aria-modal",
+    ariaMultiLine: "aria-multiline",
+    ariaMultiSelectable: "aria-multiselectable",
+    ariaOrientation: "aria-orientation",
+    ariaPlaceholder: "aria-placeholder",
+    ariaPosInSet: "aria-posinset",
+    ariaPressed: "aria-pressed",
+    ariaReadOnly: "aria-readonly",
+    ariaRequired: "aria-required",
+    ariaRoleDescription: "aria-roledescription",
+    ariaRowCount: "aria-rowcount",
+    ariaRowIndex: "aria-rowindex",
+    ariaRowSpan: "aria-rowspan",
+    ariaSelected: "aria-selected",
+    ariaSetSize: "aria-setsize",
+    ariaSort: "aria-sort",
+    ariaValueMax: "aria-valuemax",
+    ariaValueMin: "aria-valuemin",
+    ariaValueNow: "aria-valuenow",
+    ariaValueText: "aria-valuetext",
+    role: "role"
 };
+// Shim the global element internals object
+// Methods should be fine as noops and properties can generally
+// be while on the server.
+var ElementInternalsShim = /*#__PURE__*/ function() {
+    function ElementInternals(_host) {
+        _class_call_check$A(this, ElementInternals);
+        this.ariaAtomic = "";
+        this.ariaAutoComplete = "";
+        this.ariaBrailleLabel = "";
+        this.ariaBrailleRoleDescription = "";
+        this.ariaBusy = "";
+        this.ariaChecked = "";
+        this.ariaColCount = "";
+        this.ariaColIndex = "";
+        this.ariaColSpan = "";
+        this.ariaCurrent = "";
+        this.ariaDescription = "";
+        this.ariaDisabled = "";
+        this.ariaExpanded = "";
+        this.ariaHasPopup = "";
+        this.ariaHidden = "";
+        this.ariaInvalid = "";
+        this.ariaKeyShortcuts = "";
+        this.ariaLabel = "";
+        this.ariaLevel = "";
+        this.ariaLive = "";
+        this.ariaModal = "";
+        this.ariaMultiLine = "";
+        this.ariaMultiSelectable = "";
+        this.ariaOrientation = "";
+        this.ariaPlaceholder = "";
+        this.ariaPosInSet = "";
+        this.ariaPressed = "";
+        this.ariaReadOnly = "";
+        this.ariaRequired = "";
+        this.ariaRoleDescription = "";
+        this.ariaRowCount = "";
+        this.ariaRowIndex = "";
+        this.ariaRowSpan = "";
+        this.ariaSelected = "";
+        this.ariaSetSize = "";
+        this.ariaSort = "";
+        this.ariaValueMax = "";
+        this.ariaValueMin = "";
+        this.ariaValueNow = "";
+        this.ariaValueText = "";
+        this.role = "";
+        this.form = null;
+        this.labels = [];
+        this.states = new Set();
+        this.validationMessage = "";
+        this.validity = {};
+        this.willValidate = true;
+        this.__host = _host;
+    }
+    _create_class$z(ElementInternals, [
+        {
+            key: "shadowRoot",
+            get: function get() {
+                // Grab the shadow root instance from the Element shim
+                // to ensure that the shadow root is always available
+                // to the internals instance even if the mode is 'closed'
+                return this.__host.__shadowRoot;
+            }
+        },
+        {
+            key: "checkValidity",
+            value: function checkValidity() {
+                // TODO(augustjk) Consider actually implementing logic.
+                // See https://github.com/lit/lit/issues/3740
+                console.warn("`ElementInternals.checkValidity()` was called on the server." + "This method always returns true.");
+                return true;
+            }
+        },
+        {
+            key: "reportValidity",
+            value: function reportValidity() {
+                return true;
+            }
+        },
+        {
+            key: "setFormValue",
+            value: function setFormValue() {}
+        },
+        {
+            key: "setValidity",
+            value: function setValidity() {}
+        }
+    ]);
+    return ElementInternals;
+}();
+var HYDRATE_INTERNALS_ATTR_PREFIX = "hydrate-internals-";
 
-/// <reference lib="dom" />
 /**
  * @license
  * Copyright 2019 Google LLC
@@ -52,12 +190,12 @@ function _assert_this_initialized$f(self) {
     }
     return self;
 }
-function _class_call_check$A(instance, Constructor) {
+function _class_call_check$z(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
-function _defineProperties$z(target, props) {
+function _defineProperties$y(target, props) {
     for(var i = 0; i < props.length; i++){
         var descriptor = props[i];
         descriptor.enumerable = descriptor.enumerable || false;
@@ -66,9 +204,9 @@ function _defineProperties$z(target, props) {
         Object.defineProperty(target, descriptor.key, descriptor);
     }
 }
-function _create_class$z(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$z(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties$z(Constructor, staticProps);
+function _create_class$y(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$y(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$y(Constructor, staticProps);
     return Constructor;
 }
 function _get_prototype_of$f(o) {
@@ -169,252 +307,607 @@ function _create_super$f(Derived) {
         return _possible_constructor_return$f(this, result);
     };
 }
-function _ts_generator$5(thisArg, body) {
-    var f, y, t, g, _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    };
-    return g = {
-        next: verb(0),
-        "throw": verb(1),
-        "return": verb(2)
-    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
-        return this;
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
+var attributes = new WeakMap();
+var attributesForElement = function(element) {
+    var attrs = attributes.get(element);
+    if (attrs === undefined) {
+        attributes.set(element, attrs = new Map());
     }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(_)try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [
-                op[0] & 2,
-                t.value
-            ];
-            switch(op[0]){
-                case 0:
-                case 1:
-                    t = op;
-                    break;
-                case 4:
-                    _.label++;
+    return attrs;
+};
+// The typings around the exports below are a little funky:
+//
+// 1. We want the `name` of the shim classes to match the real ones at runtime,
+//    hence e.g. `class Element`.
+// 2. We can't shadow the global types with a simple class declaration, because
+//    then we can't reference the global types for casting, hence e.g.
+//    `const ElementShim = class Element`.
+// 3. We want to export the classes typed as the real ones, hence e.g.
+//    `const ElementShimWithRealType = ElementShim as object as typeof Element;`.
+// 4. We want the exported names to match the real ones, hence e.g.
+//    `export {ElementShimWithRealType as Element}`.
+var ElementShim = /*#__PURE__*/ function() {
+    function Element() {
+        _class_call_check$z(this, Element);
+        this.__shadowRootMode = null;
+        this.__shadowRoot = null;
+        this.__internals = null;
+    }
+    _create_class$y(Element, [
+        {
+            key: "attributes",
+            get: function get() {
+                return Array.from(attributesForElement(this)).map(function(param) {
+                    var _param = _sliced_to_array$j(param, 2), name = _param[0], value = _param[1];
                     return {
-                        value: op[1],
-                        done: false
+                        name: name,
+                        value: value
                     };
-                case 5:
-                    _.label++;
-                    y = op[1];
-                    op = [
-                        0
-                    ];
-                    continue;
-                case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                        _ = 0;
-                        continue;
-                    }
-                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                        _.label = op[1];
-                        break;
-                    }
-                    if (op[0] === 6 && _.label < t[1]) {
-                        _.label = t[1];
-                        t = op;
-                        break;
-                    }
-                    if (t && _.label < t[2]) {
-                        _.label = t[2];
-                        _.ops.push(op);
-                        break;
-                    }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
+                });
             }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
-        }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
-    }
-}
-var getElementRenderer = function(param, tagName) {
-    var elementRenderers = param.elementRenderers, ceClass = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : customElements.get(tagName), attributes = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : new Map();
-    if (ceClass === undefined) {
-        console.warn("Custom element ".concat(tagName, " was not registered."));
-        return new FallbackRenderer(tagName);
-    }
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        // TODO(kschaaf): Should we implement a caching scheme, e.g. keyed off of
-        // ceClass's base class to prevent O(n) lookups for every element (probably
-        // not a concern for the small number of element renderers we'd expect)? Doing
-        // so would preclude having cross-cutting renderers to e.g. no-op render all
-        // custom elements with a `client-only` attribute, so punting for now.
-        for(var _iterator = elementRenderers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var renderer = _step.value;
-            if (renderer.matchesClass(ceClass, tagName, attributes)) {
-                return new renderer(tagName);
+        },
+        {
+            key: "shadowRoot",
+            get: function get() {
+                if (this.__shadowRootMode === "closed") {
+                    return null;
+                }
+                return this.__shadowRoot;
             }
-        }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
+        },
+        {
+            key: "localName",
+            get: function get() {
+                return this.constructor.__localName;
             }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
+        },
+        {
+            key: "tagName",
+            get: function get() {
+                var _this_localName;
+                return (_this_localName = this.localName) === null || _this_localName === void 0 ? void 0 : _this_localName.toUpperCase();
             }
-        }
-    }
-    return new FallbackRenderer(tagName);
-};
-/**
- * An object that renders elements of a certain type.
- */ var ElementRenderer = /*#__PURE__*/ function() {
-    function ElementRenderer(tagName) {
-        _class_call_check$A(this, ElementRenderer);
-        this.tagName = tagName;
-    }
-    _create_class$z(ElementRenderer, [
+        },
         {
-            /**
-     * Called when a custom element is "attached" to the server DOM.
-     *
-     * Because we don't presume a full DOM emulation, this isn't the same as
-     * being connected in a real browser. There may not be an owner document,
-     * parentNode, etc., depending on the DOM emulation.
-     *
-     * If this renderer is creating actual element instances, it may forward
-     * the call to the element's `connectedCallback()`.
-     *
-     * The default impementation is a no-op.
-     */ key: "connectedCallback",
-            value: function connectedCallback() {
-            // do nothing
+            key: "setAttribute",
+            value: function setAttribute(name, value) {
+                // Emulate browser behavior that silently casts all values to string. E.g.
+                // `42` becomes `"42"` and `{}` becomes `"[object Object]""`.
+                attributesForElement(this).set(name, String(value));
             }
         },
         {
-            /**
-     * Called from `setAttribute()` to emulate the browser's
-     * `attributeChangedCallback` lifecycle hook.
-     *
-     * If this renderer is creating actual element instances, it may forward
-     * the call to the element's `attributeChangedCallback()`.
-     */ key: "attributeChangedCallback",
-            value: function attributeChangedCallback(_name, _old, _value) {
-            // do nothing
+            key: "removeAttribute",
+            value: function removeAttribute(name) {
+                attributesForElement(this).delete(name);
             }
         },
         {
-            /**
-     * Handles setting a property on the element.
-     *
-     * The default implementation sets the property on the renderer's element
-     * instance.
-     *
-     * @param name Name of the property
-     * @param value Value of the property
-     */ key: "setProperty",
-            value: function setProperty(name, value) {
-                if (this.element !== undefined) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    this.element[name] = value;
+            key: "toggleAttribute",
+            value: function toggleAttribute(name, force) {
+                // Steps reference https://dom.spec.whatwg.org/#dom-element-toggleattribute
+                if (this.hasAttribute(name)) {
+                    // Step 5
+                    if (force === undefined || !force) {
+                        this.removeAttribute(name);
+                        return false;
+                    }
+                } else {
+                    // Step 4
+                    if (force === undefined || force) {
+                        // Step 4.1
+                        this.setAttribute(name, "");
+                        return true;
+                    } else {
+                        // Step 4.2
+                        return false;
+                    }
                 }
+                // Step 6
+                return true;
             }
         },
         {
-            /**
-     * Handles setting an attribute on an element.
-     *
-     * Default implementation calls `setAttribute` on the renderer's element
-     * instance, and calls the abstract `attributeChangedCallback` on the
-     * renderer.
-     *
-     * @param name Name of the attribute
-     * @param value Value of the attribute
-     */ key: "setAttribute",
-            value: function setAttribute(name, value) {
-                // Browser turns all HTML attributes to lowercase.
-                name = name.toLowerCase();
-                if (this.element !== undefined) {
-                    var old = this.element.getAttribute(name);
-                    this.element.setAttribute(name, value);
-                    this.attributeChangedCallback(name, old, value);
-                }
+            key: "hasAttribute",
+            value: function hasAttribute(name) {
+                return attributesForElement(this).has(name);
             }
         },
         {
-            key: "shadowRootOptions",
-            get: /**
-     * The shadow root options to write to the declarative shadow DOM <template>,
-     * if one is created with `renderShadow()`.
-     */ function get() {
-                return {
-                    mode: "open"
+            key: "attachShadow",
+            value: function attachShadow(init) {
+                var shadowRoot = {
+                    host: this
                 };
+                this.__shadowRootMode = init.mode;
+                if (init && init.mode === "open") {
+                    this.__shadowRoot = shadowRoot;
+                }
+                return shadowRoot;
             }
         },
         {
-            /**
-     * Render the element's shadow root children.
-     *
-     * If `renderShadow()` returns undefined, no declarative shadow root is
-     * emitted.
-     */ key: "renderShadow",
-            value: function renderShadow(_renderInfo) {
-                return undefined;
+            key: "attachInternals",
+            value: function attachInternals() {
+                if (this.__internals !== null) {
+                    throw new Error("Failed to execute 'attachInternals' on 'HTMLElement': " + "ElementInternals for the specified element was already attached.");
+                }
+                var internals = new ElementInternalsShim(this);
+                this.__internals = internals;
+                return internals;
             }
         },
         {
-            /**
-     * Render the element's light DOM children.
-     */ key: "renderLight",
-            value: function renderLight(_renderInfo) {
-                return undefined;
+            key: "getAttribute",
+            value: function getAttribute(name) {
+                var value = attributesForElement(this).get(name);
+                return value !== null && value !== void 0 ? value : null;
             }
-        },
+        }
+    ]);
+    return Element;
+}();
+var HTMLElementShim = /*#__PURE__*/ function(ElementShim) {
+    _inherits$f(HTMLElement, ElementShim);
+    var _super = _create_super$f(HTMLElement);
+    function HTMLElement() {
+        _class_call_check$z(this, HTMLElement);
+        return _super.apply(this, arguments);
+    }
+    return HTMLElement;
+}(ElementShim);
+var HTMLElementShimWithRealType = HTMLElementShim;
+var CustomElementRegistryShim = /*#__PURE__*/ function() {
+    function CustomElementRegistry() {
+        _class_call_check$z(this, CustomElementRegistry);
+        this.__definitions = new Map();
+    }
+    _create_class$y(CustomElementRegistry, [
         {
-            key: "renderAttributes",
-            value: /**
-     * Render the element's attributes.
-     *
-     * The default implementation serializes all attributes on the element
-     * instance.
-     */ function renderAttributes() {
-                var attributes, ref, i, name, value;
-                return _ts_generator$5(this, function(_state) {
-                    switch(_state.label){
+            key: "define",
+            value: function define(name, ctor) {
+                if (this.__definitions.has(name)) {
+                    if (process.env.NODE_ENV === "development") {
+                        console.warn("'CustomElementRegistry' already has \"".concat(name, '" defined. ') + "This may have been caused by live reload or hot module " + "replacement in which case it can be safely ignored.\n" + "Make sure to test your application with a production build as " + "repeat registrations will throw in production.");
+                    } else {
+                        throw new Error("Failed to execute 'define' on 'CustomElementRegistry': " + 'the name "'.concat(name, '" has already been used with this registry'));
+                    }
+                }
+                // Provide tagName and localName for the component.
+                ctor.__localName = name;
+                var _ctor_observedAttributes;
+                this.__definitions.set(name, {
+                    ctor: ctor,
+                    // Note it's important we read `observedAttributes` in case it is a getter
+                    // with side-effects, as is the case in Lit, where it triggers class
+                    // finalization.
+                    //
+                    // TODO(aomarks) To be spec compliant, we should also capture the
+                    // registration-time lifecycle methods like `connectedCallback`. For them
+                    // to be actually accessible to e.g. the Lit SSR element renderer, though,
+                    // we'd need to introduce a new API for accessing them (since `get` only
+                    // returns the constructor).
+                    observedAttributes: (_ctor_observedAttributes = ctor.observedAttributes) !== null && _ctor_observedAttributes !== void 0 ? _ctor_observedAttributes : []
+                });
+            }
+        },
+        {
+            key: "get",
+            value: function get(name) {
+                var definition = this.__definitions.get(name);
+                return definition === null || definition === void 0 ? void 0 : definition.ctor;
+            }
+        }
+    ]);
+    return CustomElementRegistry;
+}();
+var CustomElementRegistryShimWithRealType = CustomElementRegistryShim;
+new CustomElementRegistryShimWithRealType();
+
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */ var replacements = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    // Note &apos; was not defined in the HTML4 spec, and is not supported by very
+    // old browsers like IE8, so a codepoint entity is used instead.
+    "'": "&#39;"
+};
+/**
+ * Replaces characters which have special meaning in HTML (&<>"') with escaped
+ * HTML entities ("&amp;", "&lt;", etc.).
+ */ var escapeHtml = function(str) {
+    return str.replace(/[&<>"']/g, function(char) {
+        return replacements[char];
+    });
+};
+
+/// <reference lib="dom" />
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */ function _array_like_to_array$o(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes$i(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _assert_this_initialized$e(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _class_call_check$y(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$x(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$x(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$x(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$x(Constructor, staticProps);
+    return Constructor;
+}
+function _get_prototype_of$e(o) {
+    _get_prototype_of$e = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$e(o);
+}
+function _inherits$e(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of$e(subClass, superClass);
+}
+function _iterable_to_array_limit$i(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest$i() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possible_constructor_return$e(self, call) {
+    if (call && (_type_of$i(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized$e(self);
+}
+function _set_prototype_of$e(o, p) {
+    _set_prototype_of$e = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$e(o, p);
+}
+function _sliced_to_array$i(arr, i) {
+    return _array_with_holes$i(arr) || _iterable_to_array_limit$i(arr, i) || _unsupported_iterable_to_array$o(arr, i) || _non_iterable_rest$i();
+}
+function _type_of$i(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array$o(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$o(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$o(o, minLen);
+}
+function _is_native_reflect_construct$e() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super$e(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct$e();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of$e(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of$e(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return$e(this, result);
+    };
+}
+function _ts_generator$5(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var getElementRenderer = function(param, tagName) {
+    var elementRenderers = param.elementRenderers, ceClass = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : customElements.get(tagName), attributes = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : new Map();
+    if (ceClass === undefined) {
+        console.warn("Custom element ".concat(tagName, " was not registered."));
+        return new FallbackRenderer(tagName);
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        // TODO(kschaaf): Should we implement a caching scheme, e.g. keyed off of
+        // ceClass's base class to prevent O(n) lookups for every element (probably
+        // not a concern for the small number of element renderers we'd expect)? Doing
+        // so would preclude having cross-cutting renderers to e.g. no-op render all
+        // custom elements with a `client-only` attribute, so punting for now.
+        for(var _iterator = elementRenderers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var renderer = _step.value;
+            if (renderer.matchesClass(ceClass, tagName, attributes)) {
+                return new renderer(tagName);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return new FallbackRenderer(tagName);
+};
+/**
+ * An object that renders elements of a certain type.
+ */ var ElementRenderer = /*#__PURE__*/ function() {
+    function ElementRenderer(tagName) {
+        _class_call_check$y(this, ElementRenderer);
+        this.tagName = tagName;
+    }
+    _create_class$x(ElementRenderer, [
+        {
+            /**
+     * Called when a custom element is "attached" to the server DOM.
+     *
+     * Because we don't presume a full DOM emulation, this isn't the same as
+     * being connected in a real browser. There may not be an owner document,
+     * parentNode, etc., depending on the DOM emulation.
+     *
+     * If this renderer is creating actual element instances, it may forward
+     * the call to the element's `connectedCallback()`.
+     *
+     * The default impementation is a no-op.
+     */ key: "connectedCallback",
+            value: function connectedCallback() {
+            // do nothing
+            }
+        },
+        {
+            /**
+     * Called from `setAttribute()` to emulate the browser's
+     * `attributeChangedCallback` lifecycle hook.
+     *
+     * If this renderer is creating actual element instances, it may forward
+     * the call to the element's `attributeChangedCallback()`.
+     */ key: "attributeChangedCallback",
+            value: function attributeChangedCallback(_name, _old, _value) {
+            // do nothing
+            }
+        },
+        {
+            /**
+     * Handles setting a property on the element.
+     *
+     * The default implementation sets the property on the renderer's element
+     * instance.
+     *
+     * @param name Name of the property
+     * @param value Value of the property
+     */ key: "setProperty",
+            value: function setProperty(name, value) {
+                if (this.element !== undefined) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    this.element[name] = value;
+                }
+            }
+        },
+        {
+            /**
+     * Handles setting an attribute on an element.
+     *
+     * Default implementation calls `setAttribute` on the renderer's element
+     * instance, and calls the abstract `attributeChangedCallback` on the
+     * renderer.
+     *
+     * @param name Name of the attribute
+     * @param value Value of the attribute
+     */ key: "setAttribute",
+            value: function setAttribute(name, value) {
+                // Browser turns all HTML attributes to lowercase.
+                name = name.toLowerCase();
+                if (this.element !== undefined) {
+                    var old = this.element.getAttribute(name);
+                    this.element.setAttribute(name, value);
+                    this.attributeChangedCallback(name, old, value);
+                }
+            }
+        },
+        {
+            key: "shadowRootOptions",
+            get: /**
+     * The shadow root options to write to the declarative shadow DOM <template>,
+     * if one is created with `renderShadow()`.
+     */ function get() {
+                return {
+                    mode: "open"
+                };
+            }
+        },
+        {
+            /**
+     * Render the element's shadow root children.
+     *
+     * If `renderShadow()` returns undefined, no declarative shadow root is
+     * emitted.
+     */ key: "renderShadow",
+            value: function renderShadow(_renderInfo) {
+                return undefined;
+            }
+        },
+        {
+            /**
+     * Render the element's light DOM children.
+     */ key: "renderLight",
+            value: function renderLight(_renderInfo) {
+                return undefined;
+            }
+        },
+        {
+            key: "renderAttributes",
+            value: /**
+     * Render the element's attributes.
+     *
+     * The default implementation serializes all attributes on the element
+     * instance.
+     */ function renderAttributes() {
+                var attributes, ref, i, name, value;
+                return _ts_generator$5(this, function(_state) {
+                    switch(_state.label){
                         case 0:
                             if (!(this.element !== undefined)) return [
                                 3,
@@ -486,10 +979,10 @@ var getElementRenderer = function(param, tagName) {
  * An ElementRenderer used as a fallback in the case where a custom element is
  * either unregistered or has no other matching renderer.
  */ var FallbackRenderer = /*#__PURE__*/ function(ElementRenderer) {
-    _inherits$f(FallbackRenderer, ElementRenderer);
-    var _super = _create_super$f(FallbackRenderer);
+    _inherits$e(FallbackRenderer, ElementRenderer);
+    var _super = _create_super$e(FallbackRenderer);
     function FallbackRenderer() {
-        _class_call_check$A(this, FallbackRenderer);
+        _class_call_check$y(this, FallbackRenderer);
         var _this;
         _this = _super.call.apply(_super, [
             this
@@ -497,7 +990,7 @@ var getElementRenderer = function(param, tagName) {
         _this._attributes = {};
         return _this;
     }
-    _create_class$z(FallbackRenderer, [
+    _create_class$x(FallbackRenderer, [
         {
             key: "setAttribute",
             value: function setAttribute(name, value) {
@@ -528,7 +1021,7 @@ var getElementRenderer = function(param, tagName) {
                                 3,
                                 7
                             ];
-                            _step_value = _sliced_to_array$j(_step.value, 2), name = _step_value[0], value = _step_value[1];
+                            _step_value = _sliced_to_array$i(_step.value, 2), name = _step_value[0], value = _step_value[1];
                             if (!(value === "" || value === undefined || value === null)) return [
                                 3,
                                 4
@@ -600,12 +1093,12 @@ var getElementRenderer = function(param, tagName) {
  * @license
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
- */ function _class_call_check$z(instance, Constructor) {
+ */ function _class_call_check$x(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
-function _defineProperties$y(target, props) {
+function _defineProperties$w(target, props) {
     for(var i = 0; i < props.length; i++){
         var descriptor = props[i];
         descriptor.enumerable = descriptor.enumerable || false;
@@ -614,9 +1107,9 @@ function _defineProperties$y(target, props) {
         Object.defineProperty(target, descriptor.key, descriptor);
     }
 }
-function _create_class$y(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$y(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties$y(Constructor, staticProps);
+function _create_class$w(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$w(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$w(Constructor, staticProps);
     return Constructor;
 }
 function _instanceof$a(left, right) {
@@ -629,11 +1122,11 @@ function _instanceof$a(left, right) {
 var t$3 = globalThis, e$4 = t$3.ShadowRoot && (void 0 === t$3.ShadyCSS || t$3.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype, s$3 = Symbol(), o$3 = new WeakMap;
 var n$4 = /*#__PURE__*/ function() {
     function n(t, e, o) {
-        _class_call_check$z(this, n);
+        _class_call_check$x(this, n);
         if (this._$cssResult$ = !0, o !== s$3) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
         this.cssText = t, this.t = e;
     }
-    _create_class$y(n, [
+    _create_class$w(n, [
         {
             key: "styleSheet",
             get: function get() {
@@ -711,18 +1204,18 @@ var r$4 = function(t) {
     }(t) : t;
 };
 
-function _array_like_to_array$o(arr, len) {
+function _array_like_to_array$n(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_with_holes$i(arr) {
+function _array_with_holes$h(arr) {
     if (Array.isArray(arr)) return arr;
 }
 function _array_without_holes$e(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array$o(arr);
+    if (Array.isArray(arr)) return _array_like_to_array$n(arr);
 }
-function _assert_this_initialized$e(self) {
+function _assert_this_initialized$d(self) {
     if (self === void 0) {
         throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
     }
@@ -757,13 +1250,13 @@ function _async_to_generator$1(fn) {
         });
     };
 }
-function _class_call_check$y(instance, Constructor) {
+function _class_call_check$w(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
 function _construct$2(Parent, args, Class) {
-    if (_is_native_reflect_construct$e()) {
+    if (_is_native_reflect_construct$d()) {
         _construct$2 = Reflect.construct;
     } else {
         _construct$2 = function construct(Parent, args, Class) {
@@ -773,13 +1266,13 @@ function _construct$2(Parent, args, Class) {
             a.push.apply(a, args);
             var Constructor = Function.bind.apply(Parent, a);
             var instance = new Constructor();
-            if (Class) _set_prototype_of$e(instance, Class.prototype);
+            if (Class) _set_prototype_of$d(instance, Class.prototype);
             return instance;
         };
     }
     return _construct$2.apply(null, arguments);
 }
-function _defineProperties$x(target, props) {
+function _defineProperties$v(target, props) {
     for(var i = 0; i < props.length; i++){
         var descriptor = props[i];
         descriptor.enumerable = descriptor.enumerable || false;
@@ -788,18 +1281,18 @@ function _defineProperties$x(target, props) {
         Object.defineProperty(target, descriptor.key, descriptor);
     }
 }
-function _create_class$x(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$x(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties$x(Constructor, staticProps);
+function _create_class$v(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$v(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$v(Constructor, staticProps);
     return Constructor;
 }
-function _get_prototype_of$e(o) {
-    _get_prototype_of$e = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+function _get_prototype_of$d(o) {
+    _get_prototype_of$d = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
         return o.__proto__ || Object.getPrototypeOf(o);
     };
-    return _get_prototype_of$e(o);
+    return _get_prototype_of$d(o);
 }
-function _inherits$e(subClass, superClass) {
+function _inherits$d(subClass, superClass) {
     if (typeof superClass !== "function" && superClass !== null) {
         throw new TypeError("Super expression must either be null or a function");
     }
@@ -810,7 +1303,7 @@ function _inherits$e(subClass, superClass) {
             configurable: true
         }
     });
-    if (superClass) _set_prototype_of$e(subClass, superClass);
+    if (superClass) _set_prototype_of$d(subClass, superClass);
 }
 function _is_native_function$2(fn) {
     return Function.toString.call(fn).indexOf("[native code]") !== -1;
@@ -818,7 +1311,7 @@ function _is_native_function$2(fn) {
 function _iterable_to_array$e(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-function _iterable_to_array_limit$i(arr, i) {
+function _iterable_to_array_limit$h(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
     var _arr = [];
@@ -842,42 +1335,42 @@ function _iterable_to_array_limit$i(arr, i) {
     }
     return _arr;
 }
-function _non_iterable_rest$i() {
+function _non_iterable_rest$h() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 function _non_iterable_spread$e() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _possible_constructor_return$e(self, call) {
-    if (call && (_type_of$i(call) === "object" || typeof call === "function")) {
+function _possible_constructor_return$d(self, call) {
+    if (call && (_type_of$h(call) === "object" || typeof call === "function")) {
         return call;
     }
-    return _assert_this_initialized$e(self);
+    return _assert_this_initialized$d(self);
 }
-function _set_prototype_of$e(o, p) {
-    _set_prototype_of$e = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+function _set_prototype_of$d(o, p) {
+    _set_prototype_of$d = Object.setPrototypeOf || function setPrototypeOf(o, p) {
         o.__proto__ = p;
         return o;
     };
-    return _set_prototype_of$e(o, p);
+    return _set_prototype_of$d(o, p);
 }
-function _sliced_to_array$i(arr, i) {
-    return _array_with_holes$i(arr) || _iterable_to_array_limit$i(arr, i) || _unsupported_iterable_to_array$o(arr, i) || _non_iterable_rest$i();
+function _sliced_to_array$h(arr, i) {
+    return _array_with_holes$h(arr) || _iterable_to_array_limit$h(arr, i) || _unsupported_iterable_to_array$n(arr, i) || _non_iterable_rest$h();
 }
 function _to_consumable_array$e(arr) {
-    return _array_without_holes$e(arr) || _iterable_to_array$e(arr) || _unsupported_iterable_to_array$o(arr) || _non_iterable_spread$e();
+    return _array_without_holes$e(arr) || _iterable_to_array$e(arr) || _unsupported_iterable_to_array$n(arr) || _non_iterable_spread$e();
 }
-function _type_of$i(obj) {
+function _type_of$h(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
-function _unsupported_iterable_to_array$o(o, minLen) {
+function _unsupported_iterable_to_array$n(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$o(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$n(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$o(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$n(o, minLen);
 }
 function _wrap_native_super$2(Class) {
     var _cache = typeof Map === "function" ? new Map() : undefined;
@@ -891,7 +1384,7 @@ function _wrap_native_super$2(Class) {
             _cache.set(Class, Wrapper);
         }
         function Wrapper() {
-            return _construct$2(Class, arguments, _get_prototype_of$e(this).constructor);
+            return _construct$2(Class, arguments, _get_prototype_of$d(this).constructor);
         }
         Wrapper.prototype = Object.create(Class.prototype, {
             constructor: {
@@ -901,11 +1394,11 @@ function _wrap_native_super$2(Class) {
                 configurable: true
             }
         });
-        return _set_prototype_of$e(Wrapper, Class);
+        return _set_prototype_of$d(Wrapper, Class);
     };
     return _wrap_native_super$2(Class);
 }
-function _is_native_reflect_construct$e() {
+function _is_native_reflect_construct$d() {
     if (typeof Reflect === "undefined" || !Reflect.construct) return false;
     if (Reflect.construct.sham) return false;
     if (typeof Proxy === "function") return true;
@@ -916,17 +1409,17 @@ function _is_native_reflect_construct$e() {
         return false;
     }
 }
-function _create_super$e(Derived) {
-    var hasNativeReflectConstruct = _is_native_reflect_construct$e();
+function _create_super$d(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct$d();
     return function _createSuperInternal() {
-        var Super = _get_prototype_of$e(Derived), result;
+        var Super = _get_prototype_of$d(Derived), result;
         if (hasNativeReflectConstruct) {
-            var NewTarget = _get_prototype_of$e(this).constructor;
+            var NewTarget = _get_prototype_of$d(this).constructor;
             result = Reflect.construct(Super, arguments, NewTarget);
         } else {
             result = Super.apply(this, arguments);
         }
-        return _possible_constructor_return$e(this, result);
+        return _possible_constructor_return$d(this, result);
     };
 }
 function _ts_generator$4(thisArg, body) {
@@ -1074,15 +1567,15 @@ var _Symbol, _a$1, _a1;
 var _metadata, _litPropertyMetadata;
 (_metadata = (_Symbol = Symbol).metadata) !== null && _metadata !== void 0 ? _metadata : _Symbol.metadata = Symbol("metadata"), (_litPropertyMetadata = (_a$1 = a$1).litPropertyMetadata) !== null && _litPropertyMetadata !== void 0 ? _litPropertyMetadata : _a$1.litPropertyMetadata = new WeakMap;
 var b = /*#__PURE__*/ function(HTMLElement1) {
-    _inherits$e(b, HTMLElement1);
-    var _super = _create_super$e(b);
+    _inherits$d(b, HTMLElement1);
+    var _super = _create_super$d(b);
     function b() {
-        _class_call_check$y(this, b);
+        _class_call_check$w(this, b);
         var _this;
         _this = _super.call(this), _this._$Ep = void 0, _this.isUpdatePending = !1, _this.hasUpdated = !1, _this._$Em = null, _this._$Ev();
-        return _possible_constructor_return$e(_this);
+        return _possible_constructor_return$d(_this);
     }
-    _create_class$x(b, [
+    _create_class$v(b, [
         {
             key: "_$Ev",
             value: function _$Ev() {
@@ -1293,7 +1786,7 @@ var b = /*#__PURE__*/ function(HTMLElement1) {
                         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                         try {
                             for(var _iterator = this._$Ep[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                                var _step_value = _sliced_to_array$i(_step.value, 2), t = _step_value[0], _$s = _step_value[1];
+                                var _step_value = _sliced_to_array$h(_step.value, 2), t = _step_value[0], _$s = _step_value[1];
                                 this[t] = _$s;
                             }
                         } catch (err) {
@@ -1316,7 +1809,7 @@ var b = /*#__PURE__*/ function(HTMLElement1) {
                     var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
                     if (t1.size > 0) try {
                         for(var _iterator1 = t1[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-                            var _step_value1 = _sliced_to_array$i(_step1.value, 2), _$s1 = _step_value1[0], i = _step_value1[1];
+                            var _step_value1 = _sliced_to_array$h(_step1.value, 2), _$s1 = _step_value1[0], i = _step_value1[1];
                             !0 !== i.wrapped || this._$AL.has(_$s1) || void 0 === this[_$s1] || this.P(_$s1, this[_$s1], i);
                         }
                     } catch (err) {
@@ -1500,7 +1993,7 @@ var b = /*#__PURE__*/ function(HTMLElement1) {
                     var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
                     if (void 0 !== s1) try {
                         for(var _iterator1 = s1[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-                            var _step_value = _sliced_to_array$i(_step1.value, 2), t2 = _step_value[0], i1 = _step_value[1];
+                            var _step_value = _sliced_to_array$h(_step1.value, 2), t2 = _step_value[0], i1 = _step_value[1];
                             this.elementProperties.set(t2, i1);
                         }
                     } catch (err) {
@@ -1522,7 +2015,7 @@ var b = /*#__PURE__*/ function(HTMLElement1) {
                 var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
                 try {
                     for(var _iterator2 = this.elementProperties[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
-                        var _step_value1 = _sliced_to_array$i(_step2.value, 2), t3 = _step_value1[0], s2 = _step_value1[1];
+                        var _step_value1 = _sliced_to_array$h(_step2.value, 2), t3 = _step_value1[0], s2 = _step_value1[1];
                         var i2 = this._$Eu(t3, s2);
                         void 0 !== i2 && this._$Eh.set(i2, t3);
                     }
@@ -1594,29 +2087,29 @@ b.elementStyles = [], b.shadowRootOptions = {
  * @license
  * Copyright 2017 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
- */ function _array_like_to_array$n(arr, len) {
+ */ function _array_like_to_array$m(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_with_holes$h(arr) {
+function _array_with_holes$g(arr) {
     if (Array.isArray(arr)) return arr;
 }
 function _array_without_holes$d(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array$n(arr);
+    if (Array.isArray(arr)) return _array_like_to_array$m(arr);
 }
-function _assert_this_initialized$d(self) {
+function _assert_this_initialized$c(self) {
     if (self === void 0) {
         throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
     }
     return self;
 }
-function _class_call_check$x(instance, Constructor) {
+function _class_call_check$v(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
-function _defineProperties$w(target, props) {
+function _defineProperties$u(target, props) {
     for(var i = 0; i < props.length; i++){
         var descriptor = props[i];
         descriptor.enumerable = descriptor.enumerable || false;
@@ -1625,18 +2118,18 @@ function _defineProperties$w(target, props) {
         Object.defineProperty(target, descriptor.key, descriptor);
     }
 }
-function _create_class$w(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$w(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties$w(Constructor, staticProps);
+function _create_class$u(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$u(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$u(Constructor, staticProps);
     return Constructor;
 }
-function _get_prototype_of$d(o) {
-    _get_prototype_of$d = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+function _get_prototype_of$c(o) {
+    _get_prototype_of$c = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
         return o.__proto__ || Object.getPrototypeOf(o);
     };
-    return _get_prototype_of$d(o);
+    return _get_prototype_of$c(o);
 }
-function _inherits$d(subClass, superClass) {
+function _inherits$c(subClass, superClass) {
     if (typeof superClass !== "function" && superClass !== null) {
         throw new TypeError("Super expression must either be null or a function");
     }
@@ -1647,12 +2140,12 @@ function _inherits$d(subClass, superClass) {
             configurable: true
         }
     });
-    if (superClass) _set_prototype_of$d(subClass, superClass);
+    if (superClass) _set_prototype_of$c(subClass, superClass);
 }
 function _iterable_to_array$d(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-function _iterable_to_array_limit$h(arr, i) {
+function _iterable_to_array_limit$g(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
     var _arr = [];
@@ -1676,44 +2169,44 @@ function _iterable_to_array_limit$h(arr, i) {
     }
     return _arr;
 }
-function _non_iterable_rest$h() {
+function _non_iterable_rest$g() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 function _non_iterable_spread$d() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _possible_constructor_return$d(self, call) {
-    if (call && (_type_of$h(call) === "object" || typeof call === "function")) {
+function _possible_constructor_return$c(self, call) {
+    if (call && (_type_of$g(call) === "object" || typeof call === "function")) {
         return call;
     }
-    return _assert_this_initialized$d(self);
+    return _assert_this_initialized$c(self);
 }
-function _set_prototype_of$d(o, p) {
-    _set_prototype_of$d = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+function _set_prototype_of$c(o, p) {
+    _set_prototype_of$c = Object.setPrototypeOf || function setPrototypeOf(o, p) {
         o.__proto__ = p;
         return o;
     };
-    return _set_prototype_of$d(o, p);
+    return _set_prototype_of$c(o, p);
 }
-function _sliced_to_array$h(arr, i) {
-    return _array_with_holes$h(arr) || _iterable_to_array_limit$h(arr, i) || _unsupported_iterable_to_array$n(arr, i) || _non_iterable_rest$h();
+function _sliced_to_array$g(arr, i) {
+    return _array_with_holes$g(arr) || _iterable_to_array_limit$g(arr, i) || _unsupported_iterable_to_array$m(arr, i) || _non_iterable_rest$g();
 }
 function _to_consumable_array$d(arr) {
-    return _array_without_holes$d(arr) || _iterable_to_array$d(arr) || _unsupported_iterable_to_array$n(arr) || _non_iterable_spread$d();
+    return _array_without_holes$d(arr) || _iterable_to_array$d(arr) || _unsupported_iterable_to_array$m(arr) || _non_iterable_spread$d();
 }
-function _type_of$h(obj) {
+function _type_of$g(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
-function _unsupported_iterable_to_array$n(o, minLen) {
+function _unsupported_iterable_to_array$m(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$n(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$m(o, minLen);
     var n = Object.prototype.toString.call(o).slice(8, -1);
     if (n === "Object" && o.constructor) n = o.constructor.name;
     if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$n(o, minLen);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$m(o, minLen);
 }
-function _is_native_reflect_construct$d() {
+function _is_native_reflect_construct$c() {
     if (typeof Reflect === "undefined" || !Reflect.construct) return false;
     if (Reflect.construct.sham) return false;
     if (typeof Proxy === "function") return true;
@@ -1724,17 +2217,17 @@ function _is_native_reflect_construct$d() {
         return false;
     }
 }
-function _create_super$d(Derived) {
-    var hasNativeReflectConstruct = _is_native_reflect_construct$d();
+function _create_super$c(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct$c();
     return function _createSuperInternal() {
-        var Super = _get_prototype_of$d(Derived), result;
+        var Super = _get_prototype_of$c(Derived), result;
         if (hasNativeReflectConstruct) {
-            var NewTarget = _get_prototype_of$d(this).constructor;
+            var NewTarget = _get_prototype_of$c(this).constructor;
             result = Reflect.construct(Super, arguments, NewTarget);
         } else {
             result = Super.apply(this, arguments);
         }
-        return _possible_constructor_return$d(this, result);
+        return _possible_constructor_return$c(this, result);
     };
 }
 var _t;
@@ -1771,11 +2264,11 @@ var V = function(t, i) {
 var N = /*#__PURE__*/ function() {
     function N(param, n) {
         var t = param.strings, s = param._$litType$;
-        _class_call_check$x(this, N);
+        _class_call_check$v(this, N);
         var r;
         this.parts = [];
         var c = 0, a = 0;
-        var u = t.length - 1, d = this.parts, _V = _sliced_to_array$h(V(t, s), 2), f = _V[0], v = _V[1];
+        var u = t.length - 1, d = this.parts, _V = _sliced_to_array$g(V(t, s), 2), f = _V[0], v = _V[1];
         if (this.el = N.createElement(f, n), C.currentNode = this.el.content, 2 === s || 3 === s) {
             var _t;
             var t1 = this.el.content.firstChild;
@@ -1840,7 +2333,7 @@ var N = /*#__PURE__*/ function() {
             c++;
         }
     }
-    _create_class$w(N, null, [
+    _create_class$u(N, null, [
         {
             key: "createElement",
             value: function createElement(t, i) {
@@ -1863,10 +2356,10 @@ function S(t, i) {
 }
 var M = /*#__PURE__*/ function() {
     function M(t, i) {
-        _class_call_check$x(this, M);
+        _class_call_check$v(this, M);
         this._$AV = [], this._$AN = void 0, this._$AD = t, this._$AM = i;
     }
-    _create_class$w(M, [
+    _create_class$u(M, [
         {
             key: "parentNode",
             get: function get() {
@@ -1927,11 +2420,11 @@ var M = /*#__PURE__*/ function() {
 }();
 var R = /*#__PURE__*/ function() {
     function R(t, i, s, e) {
-        _class_call_check$x(this, R);
+        _class_call_check$v(this, R);
         var _e_isConnected;
         this.type = 2, this._$AH = E, this._$AN = void 0, this._$AA = t, this._$AB = i, this._$AM = s, this.options = e, this._$Cv = (_e_isConnected = e === null || e === void 0 ? void 0 : e.isConnected) !== null && _e_isConnected !== void 0 ? _e_isConnected : !0;
     }
-    _create_class$w(R, [
+    _create_class$u(R, [
         {
             key: "_$AU",
             get: function get() {
@@ -2056,10 +2549,10 @@ var R = /*#__PURE__*/ function() {
 }();
 var k = /*#__PURE__*/ function() {
     function k(t, i, s, e, h) {
-        _class_call_check$x(this, k);
+        _class_call_check$v(this, k);
         this.type = 1, this._$AH = E, this._$AN = void 0, this.element = t, this.name = i, this._$AM = e, this.options = h, s.length > 2 || "" !== s[0] || "" !== s[1] ? (this._$AH = Array(s.length - 1).fill(new String), this.strings = s) : this._$AH = E;
     }
-    _create_class$w(k, [
+    _create_class$u(k, [
         {
             key: "tagName",
             get: function get() {
@@ -2097,17 +2590,17 @@ var k = /*#__PURE__*/ function() {
     return k;
 }();
 var H = /*#__PURE__*/ function(k) {
-    _inherits$d(H, k);
-    var _super = _create_super$d(H);
+    _inherits$c(H, k);
+    var _super = _create_super$c(H);
     function H() {
-        _class_call_check$x(this, H);
+        _class_call_check$v(this, H);
         var _this;
         _this = _super.call.apply(_super, [
             this
         ].concat(Array.prototype.slice.call(arguments))), _this.type = 3;
-        return _possible_constructor_return$d(_this);
+        return _possible_constructor_return$c(_this);
     }
-    _create_class$w(H, [
+    _create_class$u(H, [
         {
             key: "j",
             value: function j(t) {
@@ -2118,17 +2611,17 @@ var H = /*#__PURE__*/ function(k) {
     return H;
 }(k);
 var I = /*#__PURE__*/ function(k) {
-    _inherits$d(I, k);
-    var _super = _create_super$d(I);
+    _inherits$c(I, k);
+    var _super = _create_super$c(I);
     function I() {
-        _class_call_check$x(this, I);
+        _class_call_check$v(this, I);
         var _this;
         _this = _super.call.apply(_super, [
             this
         ].concat(Array.prototype.slice.call(arguments))), _this.type = 4;
-        return _possible_constructor_return$d(_this);
+        return _possible_constructor_return$c(_this);
     }
-    _create_class$w(I, [
+    _create_class$u(I, [
         {
             key: "j",
             value: function j(t) {
@@ -2139,15 +2632,15 @@ var I = /*#__PURE__*/ function(k) {
     return I;
 }(k);
 var L = /*#__PURE__*/ function(k) {
-    _inherits$d(L, k);
-    var _super = _create_super$d(L);
+    _inherits$c(L, k);
+    var _super = _create_super$c(L);
     function L(t, i, s, e, h) {
-        _class_call_check$x(this, L);
+        _class_call_check$v(this, L);
         var _this;
         _this = _super.call(this, t, i, s, e, h), _this.type = 5;
-        return _possible_constructor_return$d(_this);
+        return _possible_constructor_return$c(_this);
     }
-    _create_class$w(L, [
+    _create_class$u(L, [
         {
             key: "_$AI",
             value: function _$AI(t) {
@@ -2171,10 +2664,10 @@ var L = /*#__PURE__*/ function(k) {
 }(k);
 var z = /*#__PURE__*/ function() {
     function z(t, i, s) {
-        _class_call_check$x(this, z);
+        _class_call_check$v(this, z);
         this.element = t, this.type = 6, this._$AN = void 0, this._$AM = i, this.options = s;
     }
-    _create_class$w(z, [
+    _create_class$u(z, [
         {
             key: "_$AU",
             get: function get() {
@@ -2220,18 +2713,18 @@ var B = function(t, i, s) {
     return h._$AI(t), h;
 };
 
-function _assert_this_initialized$c(self) {
+function _assert_this_initialized$b(self) {
     if (self === void 0) {
         throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
     }
     return self;
 }
-function _class_call_check$w(instance, Constructor) {
+function _class_call_check$u(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
-function _defineProperties$v(target, props) {
+function _defineProperties$t(target, props) {
     for(var i = 0; i < props.length; i++){
         var descriptor = props[i];
         descriptor.enumerable = descriptor.enumerable || false;
@@ -2240,9 +2733,9 @@ function _defineProperties$v(target, props) {
         Object.defineProperty(target, descriptor.key, descriptor);
     }
 }
-function _create_class$v(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$v(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties$v(Constructor, staticProps);
+function _create_class$t(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$t(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties$t(Constructor, staticProps);
     return Constructor;
 }
 function _get$1(target, property, receiver) {
@@ -2261,13 +2754,13 @@ function _get$1(target, property, receiver) {
     }
     return _get$1(target, property, receiver || target);
 }
-function _get_prototype_of$c(o) {
-    _get_prototype_of$c = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+function _get_prototype_of$b(o) {
+    _get_prototype_of$b = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
         return o.__proto__ || Object.getPrototypeOf(o);
     };
-    return _get_prototype_of$c(o);
+    return _get_prototype_of$b(o);
 }
-function _inherits$c(subClass, superClass) {
+function _inherits$b(subClass, superClass) {
     if (typeof superClass !== "function" && superClass !== null) {
         throw new TypeError("Super expression must either be null or a function");
     }
@@ -2278,33 +2771,33 @@ function _inherits$c(subClass, superClass) {
             configurable: true
         }
     });
-    if (superClass) _set_prototype_of$c(subClass, superClass);
+    if (superClass) _set_prototype_of$b(subClass, superClass);
 }
-function _possible_constructor_return$c(self, call) {
-    if (call && (_type_of$g(call) === "object" || typeof call === "function")) {
+function _possible_constructor_return$b(self, call) {
+    if (call && (_type_of$f(call) === "object" || typeof call === "function")) {
         return call;
     }
-    return _assert_this_initialized$c(self);
+    return _assert_this_initialized$b(self);
 }
-function _set_prototype_of$c(o, p) {
-    _set_prototype_of$c = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+function _set_prototype_of$b(o, p) {
+    _set_prototype_of$b = Object.setPrototypeOf || function setPrototypeOf(o, p) {
         o.__proto__ = p;
         return o;
     };
-    return _set_prototype_of$c(o, p);
+    return _set_prototype_of$b(o, p);
 }
 function _super_prop_base$1(object, property) {
     while(!Object.prototype.hasOwnProperty.call(object, property)){
-        object = _get_prototype_of$c(object);
+        object = _get_prototype_of$b(object);
         if (object === null) break;
     }
     return object;
 }
-function _type_of$g(obj) {
+function _type_of$f(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
-function _is_native_reflect_construct$c() {
+function _is_native_reflect_construct$b() {
     if (typeof Reflect === "undefined" || !Reflect.construct) return false;
     if (Reflect.construct.sham) return false;
     if (typeof Proxy === "function") return true;
@@ -2315,44 +2808,44 @@ function _is_native_reflect_construct$c() {
         return false;
     }
 }
-function _create_super$c(Derived) {
-    var hasNativeReflectConstruct = _is_native_reflect_construct$c();
+function _create_super$b(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct$b();
     return function _createSuperInternal() {
-        var Super = _get_prototype_of$c(Derived), result;
+        var Super = _get_prototype_of$b(Derived), result;
         if (hasNativeReflectConstruct) {
-            var NewTarget = _get_prototype_of$c(this).constructor;
+            var NewTarget = _get_prototype_of$b(this).constructor;
             result = Reflect.construct(Super, arguments, NewTarget);
         } else {
             result = Super.apply(this, arguments);
         }
-        return _possible_constructor_return$c(this, result);
+        return _possible_constructor_return$b(this, result);
     };
 }
-var _globalThis_litElementHydrateSupport, _globalThis;
+var _globalThis_litElementHydrateSupport, _globalThis$1;
 var _globalThis1;
 /**
  * @license
  * Copyright 2017 Google LLC
  * SPDX-License-Identifier: BSD-3-Clause
  */ var r$1 = /*#__PURE__*/ function(t) {
-    _inherits$c(r, t);
-    var _super = _create_super$c(r);
+    _inherits$b(r, t);
+    var _super = _create_super$b(r);
     function r() {
-        _class_call_check$w(this, r);
+        _class_call_check$u(this, r);
         var _this;
         _this = _super.call.apply(_super, [
             this
         ].concat(Array.prototype.slice.call(arguments))), _this.renderOptions = {
-            host: _assert_this_initialized$c(_this)
+            host: _assert_this_initialized$b(_this)
         }, _this._$Do = void 0;
-        return _possible_constructor_return$c(_this);
+        return _possible_constructor_return$b(_this);
     }
-    _create_class$v(r, [
+    _create_class$t(r, [
         {
             key: "createRenderRoot",
             value: function createRenderRoot() {
                 var _this_renderOptions;
-                var _$t = _get$1(_get_prototype_of$c(r.prototype), "createRenderRoot", this).call(this);
+                var _$t = _get$1(_get_prototype_of$b(r.prototype), "createRenderRoot", this).call(this);
                 var _renderBefore;
                 return (_renderBefore = (_this_renderOptions = this.renderOptions).renderBefore) !== null && _renderBefore !== void 0 ? _renderBefore : _this_renderOptions.renderBefore = _$t.firstChild, _$t;
             }
@@ -2361,21 +2854,21 @@ var _globalThis1;
             key: "update",
             value: function update(t) {
                 var s = this.render();
-                this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), _get$1(_get_prototype_of$c(r.prototype), "update", this).call(this, t), this._$Do = B(s, this.renderRoot, this.renderOptions);
+                this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), _get$1(_get_prototype_of$b(r.prototype), "update", this).call(this, t), this._$Do = B(s, this.renderRoot, this.renderOptions);
             }
         },
         {
             key: "connectedCallback",
             value: function connectedCallback() {
                 var _this__$Do;
-                _get$1(_get_prototype_of$c(r.prototype), "connectedCallback", this).call(this), (_this__$Do = this._$Do) === null || _this__$Do === void 0 ? void 0 : _this__$Do.setConnected(!0);
+                _get$1(_get_prototype_of$b(r.prototype), "connectedCallback", this).call(this), (_this__$Do = this._$Do) === null || _this__$Do === void 0 ? void 0 : _this__$Do.setConnected(!0);
             }
         },
         {
             key: "disconnectedCallback",
             value: function disconnectedCallback() {
                 var _this__$Do;
-                _get$1(_get_prototype_of$c(r.prototype), "disconnectedCallback", this).call(this), (_this__$Do = this._$Do) === null || _this__$Do === void 0 ? void 0 : _this__$Do.setConnected(!1);
+                _get$1(_get_prototype_of$b(r.prototype), "disconnectedCallback", this).call(this), (_this__$Do = this._$Do) === null || _this__$Do === void 0 ? void 0 : _this__$Do.setConnected(!1);
             }
         },
         {
@@ -2387,7 +2880,7 @@ var _globalThis1;
     ]);
     return r;
 }(b);
-r$1._$litElement$ = !0, r$1["finalized"] = !0, (_globalThis_litElementHydrateSupport = (_globalThis = globalThis).litElementHydrateSupport) === null || _globalThis_litElementHydrateSupport === void 0 ? void 0 : _globalThis_litElementHydrateSupport.call(_globalThis, {
+r$1._$litElement$ = !0, r$1["finalized"] = !0, (_globalThis_litElementHydrateSupport = (_globalThis$1 = globalThis).litElementHydrateSupport) === null || _globalThis_litElementHydrateSupport === void 0 ? void 0 : _globalThis_litElementHydrateSupport.call(_globalThis$1, {
     LitElement: r$1
 });
 var i$4 = globalThis.litElementPolyfillSupport;
@@ -2414,499 +2907,6 @@ var _litElementVersions;
     changedProperties: o._$AL
 };
 
-/**
- * @license
- * Copyright 2023 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */ /**
- * Map of ARIAMixin properties to attributes
- */ function _class_call_check$v(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties$u(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class$u(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$u(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties$u(Constructor, staticProps);
-    return Constructor;
-}
-var ariaMixinAttributes = {
-    ariaAtomic: "aria-atomic",
-    ariaAutoComplete: "aria-autocomplete",
-    ariaBrailleLabel: "aria-braillelabel",
-    ariaBrailleRoleDescription: "aria-brailleroledescription",
-    ariaBusy: "aria-busy",
-    ariaChecked: "aria-checked",
-    ariaColCount: "aria-colcount",
-    ariaColIndex: "aria-colindex",
-    ariaColSpan: "aria-colspan",
-    ariaCurrent: "aria-current",
-    ariaDescription: "aria-description",
-    ariaDisabled: "aria-disabled",
-    ariaExpanded: "aria-expanded",
-    ariaHasPopup: "aria-haspopup",
-    ariaHidden: "aria-hidden",
-    ariaInvalid: "aria-invalid",
-    ariaKeyShortcuts: "aria-keyshortcuts",
-    ariaLabel: "aria-label",
-    ariaLevel: "aria-level",
-    ariaLive: "aria-live",
-    ariaModal: "aria-modal",
-    ariaMultiLine: "aria-multiline",
-    ariaMultiSelectable: "aria-multiselectable",
-    ariaOrientation: "aria-orientation",
-    ariaPlaceholder: "aria-placeholder",
-    ariaPosInSet: "aria-posinset",
-    ariaPressed: "aria-pressed",
-    ariaReadOnly: "aria-readonly",
-    ariaRequired: "aria-required",
-    ariaRoleDescription: "aria-roledescription",
-    ariaRowCount: "aria-rowcount",
-    ariaRowIndex: "aria-rowindex",
-    ariaRowSpan: "aria-rowspan",
-    ariaSelected: "aria-selected",
-    ariaSetSize: "aria-setsize",
-    ariaSort: "aria-sort",
-    ariaValueMax: "aria-valuemax",
-    ariaValueMin: "aria-valuemin",
-    ariaValueNow: "aria-valuenow",
-    ariaValueText: "aria-valuetext",
-    role: "role"
-};
-// Shim the global element internals object
-// Methods should be fine as noops and properties can generally
-// be while on the server.
-var ElementInternalsShim = /*#__PURE__*/ function() {
-    function ElementInternals(_host) {
-        _class_call_check$v(this, ElementInternals);
-        this.ariaAtomic = "";
-        this.ariaAutoComplete = "";
-        this.ariaBrailleLabel = "";
-        this.ariaBrailleRoleDescription = "";
-        this.ariaBusy = "";
-        this.ariaChecked = "";
-        this.ariaColCount = "";
-        this.ariaColIndex = "";
-        this.ariaColSpan = "";
-        this.ariaCurrent = "";
-        this.ariaDescription = "";
-        this.ariaDisabled = "";
-        this.ariaExpanded = "";
-        this.ariaHasPopup = "";
-        this.ariaHidden = "";
-        this.ariaInvalid = "";
-        this.ariaKeyShortcuts = "";
-        this.ariaLabel = "";
-        this.ariaLevel = "";
-        this.ariaLive = "";
-        this.ariaModal = "";
-        this.ariaMultiLine = "";
-        this.ariaMultiSelectable = "";
-        this.ariaOrientation = "";
-        this.ariaPlaceholder = "";
-        this.ariaPosInSet = "";
-        this.ariaPressed = "";
-        this.ariaReadOnly = "";
-        this.ariaRequired = "";
-        this.ariaRoleDescription = "";
-        this.ariaRowCount = "";
-        this.ariaRowIndex = "";
-        this.ariaRowSpan = "";
-        this.ariaSelected = "";
-        this.ariaSetSize = "";
-        this.ariaSort = "";
-        this.ariaValueMax = "";
-        this.ariaValueMin = "";
-        this.ariaValueNow = "";
-        this.ariaValueText = "";
-        this.role = "";
-        this.form = null;
-        this.labels = [];
-        this.states = new Set();
-        this.validationMessage = "";
-        this.validity = {};
-        this.willValidate = true;
-        this.__host = _host;
-    }
-    _create_class$u(ElementInternals, [
-        {
-            key: "shadowRoot",
-            get: function get() {
-                // Grab the shadow root instance from the Element shim
-                // to ensure that the shadow root is always available
-                // to the internals instance even if the mode is 'closed'
-                return this.__host.__shadowRoot;
-            }
-        },
-        {
-            key: "checkValidity",
-            value: function checkValidity() {
-                // TODO(augustjk) Consider actually implementing logic.
-                // See https://github.com/lit/lit/issues/3740
-                console.warn("`ElementInternals.checkValidity()` was called on the server." + "This method always returns true.");
-                return true;
-            }
-        },
-        {
-            key: "reportValidity",
-            value: function reportValidity() {
-                return true;
-            }
-        },
-        {
-            key: "setFormValue",
-            value: function setFormValue() {}
-        },
-        {
-            key: "setValidity",
-            value: function setValidity() {}
-        }
-    ]);
-    return ElementInternals;
-}();
-var HYDRATE_INTERNALS_ATTR_PREFIX = "hydrate-internals-";
-
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */ function _array_like_to_array$m(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _array_with_holes$g(arr) {
-    if (Array.isArray(arr)) return arr;
-}
-function _assert_this_initialized$b(self) {
-    if (self === void 0) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-    return self;
-}
-function _class_call_check$u(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties$t(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class$t(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$t(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties$t(Constructor, staticProps);
-    return Constructor;
-}
-function _get_prototype_of$b(o) {
-    _get_prototype_of$b = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _get_prototype_of$b(o);
-}
-function _inherits$b(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-        throw new TypeError("Super expression must either be null or a function");
-    }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            writable: true,
-            configurable: true
-        }
-    });
-    if (superClass) _set_prototype_of$b(subClass, superClass);
-}
-function _iterable_to_array_limit$g(arr, i) {
-    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-    if (_i == null) return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
-    var _s, _e;
-    try {
-        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
-            _arr.push(_s.value);
-            if (i && _arr.length === i) break;
-        }
-    } catch (err) {
-        _d = true;
-        _e = err;
-    } finally{
-        try {
-            if (!_n && _i["return"] != null) _i["return"]();
-        } finally{
-            if (_d) throw _e;
-        }
-    }
-    return _arr;
-}
-function _non_iterable_rest$g() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _possible_constructor_return$b(self, call) {
-    if (call && (_type_of$f(call) === "object" || typeof call === "function")) {
-        return call;
-    }
-    return _assert_this_initialized$b(self);
-}
-function _set_prototype_of$b(o, p) {
-    _set_prototype_of$b = Object.setPrototypeOf || function setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-    };
-    return _set_prototype_of$b(o, p);
-}
-function _sliced_to_array$g(arr, i) {
-    return _array_with_holes$g(arr) || _iterable_to_array_limit$g(arr, i) || _unsupported_iterable_to_array$m(arr, i) || _non_iterable_rest$g();
-}
-function _type_of$f(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-function _unsupported_iterable_to_array$m(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$m(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$m(o, minLen);
-}
-function _is_native_reflect_construct$b() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-    try {
-        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-        return true;
-    } catch (e) {
-        return false;
-    }
-}
-function _create_super$b(Derived) {
-    var hasNativeReflectConstruct = _is_native_reflect_construct$b();
-    return function _createSuperInternal() {
-        var Super = _get_prototype_of$b(Derived), result;
-        if (hasNativeReflectConstruct) {
-            var NewTarget = _get_prototype_of$b(this).constructor;
-            result = Reflect.construct(Super, arguments, NewTarget);
-        } else {
-            result = Super.apply(this, arguments);
-        }
-        return _possible_constructor_return$b(this, result);
-    };
-}
-var attributes = new WeakMap();
-var attributesForElement = function(element) {
-    var attrs = attributes.get(element);
-    if (attrs === undefined) {
-        attributes.set(element, attrs = new Map());
-    }
-    return attrs;
-};
-// The typings around the exports below are a little funky:
-//
-// 1. We want the `name` of the shim classes to match the real ones at runtime,
-//    hence e.g. `class Element`.
-// 2. We can't shadow the global types with a simple class declaration, because
-//    then we can't reference the global types for casting, hence e.g.
-//    `const ElementShim = class Element`.
-// 3. We want to export the classes typed as the real ones, hence e.g.
-//    `const ElementShimWithRealType = ElementShim as object as typeof Element;`.
-// 4. We want the exported names to match the real ones, hence e.g.
-//    `export {ElementShimWithRealType as Element}`.
-var ElementShim = /*#__PURE__*/ function() {
-    function Element() {
-        _class_call_check$u(this, Element);
-        this.__shadowRootMode = null;
-        this.__shadowRoot = null;
-        this.__internals = null;
-    }
-    _create_class$t(Element, [
-        {
-            key: "attributes",
-            get: function get() {
-                return Array.from(attributesForElement(this)).map(function(param) {
-                    var _param = _sliced_to_array$g(param, 2), name = _param[0], value = _param[1];
-                    return {
-                        name: name,
-                        value: value
-                    };
-                });
-            }
-        },
-        {
-            key: "shadowRoot",
-            get: function get() {
-                if (this.__shadowRootMode === "closed") {
-                    return null;
-                }
-                return this.__shadowRoot;
-            }
-        },
-        {
-            key: "localName",
-            get: function get() {
-                return this.constructor.__localName;
-            }
-        },
-        {
-            key: "tagName",
-            get: function get() {
-                var _this_localName;
-                return (_this_localName = this.localName) === null || _this_localName === void 0 ? void 0 : _this_localName.toUpperCase();
-            }
-        },
-        {
-            key: "setAttribute",
-            value: function setAttribute(name, value) {
-                // Emulate browser behavior that silently casts all values to string. E.g.
-                // `42` becomes `"42"` and `{}` becomes `"[object Object]""`.
-                attributesForElement(this).set(name, String(value));
-            }
-        },
-        {
-            key: "removeAttribute",
-            value: function removeAttribute(name) {
-                attributesForElement(this).delete(name);
-            }
-        },
-        {
-            key: "toggleAttribute",
-            value: function toggleAttribute(name, force) {
-                // Steps reference https://dom.spec.whatwg.org/#dom-element-toggleattribute
-                if (this.hasAttribute(name)) {
-                    // Step 5
-                    if (force === undefined || !force) {
-                        this.removeAttribute(name);
-                        return false;
-                    }
-                } else {
-                    // Step 4
-                    if (force === undefined || force) {
-                        // Step 4.1
-                        this.setAttribute(name, "");
-                        return true;
-                    } else {
-                        // Step 4.2
-                        return false;
-                    }
-                }
-                // Step 6
-                return true;
-            }
-        },
-        {
-            key: "hasAttribute",
-            value: function hasAttribute(name) {
-                return attributesForElement(this).has(name);
-            }
-        },
-        {
-            key: "attachShadow",
-            value: function attachShadow(init) {
-                var shadowRoot = {
-                    host: this
-                };
-                this.__shadowRootMode = init.mode;
-                if (init && init.mode === "open") {
-                    this.__shadowRoot = shadowRoot;
-                }
-                return shadowRoot;
-            }
-        },
-        {
-            key: "attachInternals",
-            value: function attachInternals() {
-                if (this.__internals !== null) {
-                    throw new Error("Failed to execute 'attachInternals' on 'HTMLElement': " + "ElementInternals for the specified element was already attached.");
-                }
-                var internals = new ElementInternalsShim(this);
-                this.__internals = internals;
-                return internals;
-            }
-        },
-        {
-            key: "getAttribute",
-            value: function getAttribute(name) {
-                var value = attributesForElement(this).get(name);
-                return value !== null && value !== void 0 ? value : null;
-            }
-        }
-    ]);
-    return Element;
-}();
-var HTMLElementShim = /*#__PURE__*/ function(ElementShim) {
-    _inherits$b(HTMLElement, ElementShim);
-    var _super = _create_super$b(HTMLElement);
-    function HTMLElement() {
-        _class_call_check$u(this, HTMLElement);
-        return _super.apply(this, arguments);
-    }
-    return HTMLElement;
-}(ElementShim);
-var HTMLElementShimWithRealType = HTMLElementShim;
-var CustomElementRegistryShim = /*#__PURE__*/ function() {
-    function CustomElementRegistry() {
-        _class_call_check$u(this, CustomElementRegistry);
-        this.__definitions = new Map();
-    }
-    _create_class$t(CustomElementRegistry, [
-        {
-            key: "define",
-            value: function define(name, ctor) {
-                if (this.__definitions.has(name)) {
-                    if (process.env.NODE_ENV === "development") {
-                        console.warn("'CustomElementRegistry' already has \"".concat(name, '" defined. ') + "This may have been caused by live reload or hot module " + "replacement in which case it can be safely ignored.\n" + "Make sure to test your application with a production build as " + "repeat registrations will throw in production.");
-                    } else {
-                        throw new Error("Failed to execute 'define' on 'CustomElementRegistry': " + 'the name "'.concat(name, '" has already been used with this registry'));
-                    }
-                }
-                // Provide tagName and localName for the component.
-                ctor.__localName = name;
-                var _ctor_observedAttributes;
-                this.__definitions.set(name, {
-                    ctor: ctor,
-                    // Note it's important we read `observedAttributes` in case it is a getter
-                    // with side-effects, as is the case in Lit, where it triggers class
-                    // finalization.
-                    //
-                    // TODO(aomarks) To be spec compliant, we should also capture the
-                    // registration-time lifecycle methods like `connectedCallback`. For them
-                    // to be actually accessible to e.g. the Lit SSR element renderer, though,
-                    // we'd need to introduce a new API for accessing them (since `get` only
-                    // returns the constructor).
-                    observedAttributes: (_ctor_observedAttributes = ctor.observedAttributes) !== null && _ctor_observedAttributes !== void 0 ? _ctor_observedAttributes : []
-                });
-            }
-        },
-        {
-            key: "get",
-            value: function get(name) {
-                var definition = this.__definitions.get(name);
-                return definition === null || definition === void 0 ? void 0 : definition.ctor;
-            }
-        }
-    ]);
-    return CustomElementRegistry;
-}();
-var CustomElementRegistryShimWithRealType = CustomElementRegistryShim;
-new CustomElementRegistryShimWithRealType();
-
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -40968,14 +40968,14 @@ function indent(str, spaces) {
         var match = parseIdentifier(input, i1, namePart) || namePart && parseAdditionalSymbol(input, i1) || maybeSpace && parseSpaces(input, i1);
         // match is required
         if (!match) {
-            return nextMatch = nextMatch1, tokens = tokens1, i = i1, {
+            return i = i1, nextMatch = nextMatch1, tokens = tokens1, {
                 v: nextMatch1
             };
         }
         var token = match.token, offset = match.offset;
         i1 += offset;
         if (token === " ") {
-            return nextMatch = nextMatch1, tokens = tokens1, i = i1, "continue";
+            return i = i1, nextMatch = nextMatch1, tokens = tokens1, "continue";
         }
         tokens1 = _to_consumable_array$1(tokens1).concat([
             token
@@ -40994,7 +40994,7 @@ function indent(str, spaces) {
         if (contextKeys.some(function(el) {
             return el.startsWith(name);
         })) {
-            return nextMatch = nextMatch1, tokens = tokens1, i = i1, "continue";
+            return i = i1, nextMatch = nextMatch1, tokens = tokens1, "continue";
         }
         if (dateTimeIdentifiers.some(function(el) {
             return el === name;
@@ -41013,9 +41013,9 @@ function indent(str, spaces) {
         if (dateTimeIdentifiers.some(function(el) {
             return el.startsWith(name);
         })) {
-            return nextMatch = nextMatch1, tokens = tokens1, i = i1, "continue";
+            return i = i1, nextMatch = nextMatch1, tokens = tokens1, "continue";
         }
-        return nextMatch = nextMatch1, tokens = tokens1, i = i1, {
+        return i = i1, nextMatch = nextMatch1, tokens = tokens1, {
             v: nextMatch1
         };
     };
@@ -45022,9 +45022,9 @@ const preparePinsSettings = async (settings, context)=>{
     });
 };
 
-var _global;
+var _globalThis;
 var _HTMLElement;
-(_HTMLElement = (_global = global).HTMLElement) != null ? _HTMLElement : _global.HTMLElement = HTMLElementShimWithRealType;
+(_HTMLElement = (_globalThis = globalThis).HTMLElement) != null ? _HTMLElement : _globalThis.HTMLElement = HTMLElementShimWithRealType;
 let WebService = class WebService {
     filteredWebPinsSettings(item, path) {
         if (Array.isArray(item)) {