@record-evolution/widget-overlay 1.0.7 → 1.0.9

package/dist/widget-overlay.js

@@ -1,29 +1,749 @@
-import { css as ve, LitElement as Te, html as y, nothing as P } from "lit";
-import { property as te, customElement as Re, state as M, query as ke } from "lit/decorators.js";
-const $ = globalThis, u = (o) => {
+const q = globalThis, ue = q.ShadowRoot && (q.ShadyCSS === void 0 || q.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype, fe = /* @__PURE__ */ Symbol(), Te = /* @__PURE__ */ new WeakMap();
+class We {
+  constructor(e, t, i) {
+    if (this._$cssResult$ = !0, i !== fe)
+      throw new Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
+    this.cssText = e, this._strings = t;
+  }
+  // This is a getter so that it's lazy. In practice, this means stylesheets
+  // are not created until the first element instance is made.
+  get styleSheet() {
+    let e = this._styleSheet;
+    const t = this._strings;
+    if (ue && e === void 0) {
+      const i = t !== void 0 && t.length === 1;
+      i && (e = Te.get(t)), e === void 0 && ((this._styleSheet = e = new CSSStyleSheet()).replaceSync(this.cssText), i && Te.set(t, e));
+    }
+    return e;
+  }
+  toString() {
+    return this.cssText;
+  }
+}
+const et = (n) => {
+  if (n._$cssResult$ === !0)
+    return n.cssText;
+  if (typeof n == "number")
+    return n;
+  throw new Error(`Value passed to 'css' function must be a 'css' function result: ${n}. Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security.`);
+}, tt = (n) => new We(typeof n == "string" ? n : String(n), void 0, fe), He = (n, ...e) => {
+  const t = n.length === 1 ? n[0] : e.reduce((i, s, r) => i + et(s) + n[r + 1], n[0]);
+  return new We(t, n, fe);
+}, it = (n, e) => {
+  if (ue)
+    n.adoptedStyleSheets = e.map((t) => t instanceof CSSStyleSheet ? t : t.styleSheet);
+  else
+    for (const t of e) {
+      const i = document.createElement("style"), s = q.litNonce;
+      s !== void 0 && i.setAttribute("nonce", s), i.textContent = t.cssText, n.appendChild(i);
+    }
+}, st = (n) => {
+  let e = "";
+  for (const t of n.cssRules)
+    e += t.cssText;
+  return tt(e);
+}, Ce = ue ? (n) => n : (n) => n instanceof CSSStyleSheet ? st(n) : n;
+const { is: nt, defineProperty: rt, getOwnPropertyDescriptor: Ee, getOwnPropertyNames: ot, getOwnPropertySymbols: at, getPrototypeOf: Ne } = Object, $ = globalThis;
+let v;
+const Me = $.trustedTypes, lt = Me ? Me.emptyScript : "", je = $.reactiveElementPolyfillSupportDevMode;
+$.litIssuedWarnings ??= /* @__PURE__ */ new Set(), v = (n, e) => {
+  e += ` See https://lit.dev/msg/${n} for more information.`, !$.litIssuedWarnings.has(e) && !$.litIssuedWarnings.has(n) && (console.warn(e), $.litIssuedWarnings.add(e));
+}, queueMicrotask(() => {
+  v("dev-mode", "Lit is in dev mode. Not recommended for production!"), $.ShadyDOM?.inUse && je === void 0 && v("polyfill-support-missing", "Shadow DOM is being polyfilled via `ShadyDOM` but the `polyfill-support` module has not been loaded.");
+});
+const dt = (n) => {
   $.emitLitDebugLogEvents && $.dispatchEvent(new CustomEvent("lit-debug", {
-    detail: o
+    detail: n
   }));
+}, V = (n, e) => n, G = {
+  toAttribute(n, e) {
+    switch (e) {
+      case Boolean:
+        n = n ? lt : null;
+        break;
+      case Object:
+      case Array:
+        n = n == null ? n : JSON.stringify(n);
+        break;
+    }
+    return n;
+  },
+  fromAttribute(n, e) {
+    let t = n;
+    switch (e) {
+      case Boolean:
+        t = n !== null;
+        break;
+      case Number:
+        t = n === null ? null : Number(n);
+        break;
+      case Object:
+      case Array:
+        try {
+          t = JSON.parse(n);
+        } catch {
+          t = null;
+        }
+        break;
+    }
+    return t;
+  }
+}, me = (n, e) => !nt(n, e), Ue = {
+  attribute: !0,
+  type: String,
+  converter: G,
+  reflect: !1,
+  useDefault: !1,
+  hasChanged: me
 };
-let I;
-$.litIssuedWarnings ??= /* @__PURE__ */ new Set(), I = (o, e) => {
-  e += o ? ` See https://lit.dev/msg/${o} for more information.` : "", !$.litIssuedWarnings.has(e) && !$.litIssuedWarnings.has(o) && (console.warn(e), $.litIssuedWarnings.add(e));
+Symbol.metadata ??= /* @__PURE__ */ Symbol("metadata");
+$.litPropertyMetadata ??= /* @__PURE__ */ new WeakMap();
+class C extends HTMLElement {
+  /**
+   * Adds an initializer function to the class that is called during instance
+   * construction.
+   *
+   * This is useful for code that runs against a `ReactiveElement`
+   * subclass, such as a decorator, that needs to do work for each
+   * instance, such as setting up a `ReactiveController`.
+   *
+   * ```ts
+   * const myDecorator = (target: typeof ReactiveElement, key: string) => {
+   *   target.addInitializer((instance: ReactiveElement) => {
+   *     // This is run during construction of the element
+   *     new MyController(instance);
+   *   });
+   * }
+   * ```
+   *
+   * Decorating a field will then cause each instance to run an initializer
+   * that adds a controller:
+   *
+   * ```ts
+   * class MyElement extends LitElement {
+   *   @myDecorator foo;
+   * }
+   * ```
+   *
+   * Initializers are stored per-constructor. Adding an initializer to a
+   * subclass does not add it to a superclass. Since initializers are run in
+   * constructors, initializers will run in order of the class hierarchy,
+   * starting with superclasses and progressing to the instance's class.
+   *
+   * @nocollapse
+   */
+  static addInitializer(e) {
+    this.__prepare(), (this._initializers ??= []).push(e);
+  }
+  /**
+   * Returns a list of attributes corresponding to the registered properties.
+   * @nocollapse
+   * @category attributes
+   */
+  static get observedAttributes() {
+    return this.finalize(), this.__attributeToPropertyMap && [...this.__attributeToPropertyMap.keys()];
+  }
+  /**
+   * Creates a property accessor on the element prototype if one does not exist
+   * and stores a {@linkcode PropertyDeclaration} for the property with the
+   * given options. The property setter calls the property's `hasChanged`
+   * property option or uses a strict identity check to determine whether or not
+   * to request an update.
+   *
+   * This method may be overridden to customize properties; however,
+   * when doing so, it's important to call `super.createProperty` to ensure
+   * the property is setup correctly. This method calls
+   * `getPropertyDescriptor` internally to get a descriptor to install.
+   * To customize what properties do when they are get or set, override
+   * `getPropertyDescriptor`. To customize the options for a property,
+   * implement `createProperty` like this:
+   *
+   * ```ts
+   * static createProperty(name, options) {
+   *   options = Object.assign(options, {myOption: true});
+   *   super.createProperty(name, options);
+   * }
+   * ```
+   *
+   * @nocollapse
+   * @category properties
+   */
+  static createProperty(e, t = Ue) {
+    if (t.state && (t.attribute = !1), this.__prepare(), this.prototype.hasOwnProperty(e) && (t = Object.create(t), t.wrapped = !0), this.elementProperties.set(e, t), !t.noAccessor) {
+      const i = (
+        // Use Symbol.for in dev mode to make it easier to maintain state
+        // when doing HMR.
+        /* @__PURE__ */ Symbol.for(`${String(e)} (@property() cache)`)
+      ), s = this.getPropertyDescriptor(e, i, t);
+      s !== void 0 && rt(this.prototype, e, s);
+    }
+  }
+  /**
+   * Returns a property descriptor to be defined on the given named property.
+   * If no descriptor is returned, the property will not become an accessor.
+   * For example,
+   *
+   * ```ts
+   * class MyElement extends LitElement {
+   *   static getPropertyDescriptor(name, key, options) {
+   *     const defaultDescriptor =
+   *         super.getPropertyDescriptor(name, key, options);
+   *     const setter = defaultDescriptor.set;
+   *     return {
+   *       get: defaultDescriptor.get,
+   *       set(value) {
+   *         setter.call(this, value);
+   *         // custom action.
+   *       },
+   *       configurable: true,
+   *       enumerable: true
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * @nocollapse
+   * @category properties
+   */
+  static getPropertyDescriptor(e, t, i) {
+    const { get: s, set: r } = Ee(this.prototype, e) ?? {
+      get() {
+        return this[t];
+      },
+      set(o) {
+        this[t] = o;
+      }
+    };
+    if (s == null) {
+      if ("value" in (Ee(this.prototype, e) ?? {}))
+        throw new Error(`Field ${JSON.stringify(String(e))} on ${this.name} was declared as a reactive property but it's actually declared as a value on the prototype. Usually this is due to using @property or @state on a method.`);
+      v("reactive-property-without-getter", `Field ${JSON.stringify(String(e))} on ${this.name} was declared as a reactive property but it does not have a getter. This will be an error in a future version of Lit.`);
+    }
+    return {
+      get: s,
+      set(o) {
+        const l = s?.call(this);
+        r?.call(this, o), this.requestUpdate(e, l, i);
+      },
+      configurable: !0,
+      enumerable: !0
+    };
+  }
+  /**
+   * Returns the property options associated with the given property.
+   * These options are defined with a `PropertyDeclaration` via the `properties`
+   * object or the `@property` decorator and are registered in
+   * `createProperty(...)`.
+   *
+   * Note, this method should be considered "final" and not overridden. To
+   * customize the options for a given property, override
+   * {@linkcode createProperty}.
+   *
+   * @nocollapse
+   * @final
+   * @category properties
+   */
+  static getPropertyOptions(e) {
+    return this.elementProperties.get(e) ?? Ue;
+  }
+  /**
+   * Initializes static own properties of the class used in bookkeeping
+   * for element properties, initializers, etc.
+   *
+   * Can be called multiple times by code that needs to ensure these
+   * properties exist before using them.
+   *
+   * This method ensures the superclass is finalized so that inherited
+   * property metadata can be copied down.
+   * @nocollapse
+   */
+  static __prepare() {
+    if (this.hasOwnProperty(V("elementProperties")))
+      return;
+    const e = Ne(this);
+    e.finalize(), e._initializers !== void 0 && (this._initializers = [...e._initializers]), this.elementProperties = new Map(e.elementProperties);
+  }
+  /**
+   * Finishes setting up the class so that it's ready to be registered
+   * as a custom element and instantiated.
+   *
+   * This method is called by the ReactiveElement.observedAttributes getter.
+   * If you override the observedAttributes getter, you must either call
+   * super.observedAttributes to trigger finalization, or call finalize()
+   * yourself.
+   *
+   * @nocollapse
+   */
+  static finalize() {
+    if (this.hasOwnProperty(V("finalized")))
+      return;
+    if (this.finalized = !0, this.__prepare(), this.hasOwnProperty(V("properties"))) {
+      const t = this.properties, i = [
+        ...ot(t),
+        ...at(t)
+      ];
+      for (const s of i)
+        this.createProperty(s, t[s]);
+    }
+    const e = this[Symbol.metadata];
+    if (e !== null) {
+      const t = litPropertyMetadata.get(e);
+      if (t !== void 0)
+        for (const [i, s] of t)
+          this.elementProperties.set(i, s);
+    }
+    this.__attributeToPropertyMap = /* @__PURE__ */ new Map();
+    for (const [t, i] of this.elementProperties) {
+      const s = this.__attributeNameForProperty(t, i);
+      s !== void 0 && this.__attributeToPropertyMap.set(s, t);
+    }
+    this.elementStyles = this.finalizeStyles(this.styles), this.hasOwnProperty("createProperty") && v("no-override-create-property", "Overriding ReactiveElement.createProperty() is deprecated. The override will not be called with standard decorators"), this.hasOwnProperty("getPropertyDescriptor") && v("no-override-get-property-descriptor", "Overriding ReactiveElement.getPropertyDescriptor() is deprecated. The override will not be called with standard decorators");
+  }
+  /**
+   * Takes the styles the user supplied via the `static styles` property and
+   * returns the array of styles to apply to the element.
+   * Override this method to integrate into a style management system.
+   *
+   * Styles are deduplicated preserving the _last_ instance in the list. This
+   * is a performance optimization to avoid duplicated styles that can occur
+   * especially when composing via subclassing. The last item is kept to try
+   * to preserve the cascade order with the assumption that it's most important
+   * that last added styles override previous styles.
+   *
+   * @nocollapse
+   * @category styles
+   */
+  static finalizeStyles(e) {
+    const t = [];
+    if (Array.isArray(e)) {
+      const i = new Set(e.flat(1 / 0).reverse());
+      for (const s of i)
+        t.unshift(Ce(s));
+    } else e !== void 0 && t.push(Ce(e));
+    return t;
+  }
+  /**
+   * Returns the property name for the given attribute `name`.
+   * @nocollapse
+   */
+  static __attributeNameForProperty(e, t) {
+    const i = t.attribute;
+    return i === !1 ? void 0 : typeof i == "string" ? i : typeof e == "string" ? e.toLowerCase() : void 0;
+  }
+  constructor() {
+    super(), this.__instanceProperties = void 0, this.isUpdatePending = !1, this.hasUpdated = !1, this.__reflectingProperty = null, this.__initialize();
+  }
+  /**
+   * Internal only override point for customizing work done when elements
+   * are constructed.
+   */
+  __initialize() {
+    this.__updatePromise = new Promise((e) => this.enableUpdating = e), this._$changedProperties = /* @__PURE__ */ new Map(), this.__saveInstanceProperties(), this.requestUpdate(), this.constructor._initializers?.forEach((e) => e(this));
+  }
+  /**
+   * Registers a `ReactiveController` to participate in the element's reactive
+   * update cycle. The element automatically calls into any registered
+   * controllers during its lifecycle callbacks.
+   *
+   * If the element is connected when `addController()` is called, the
+   * controller's `hostConnected()` callback will be immediately called.
+   * @category controllers
+   */
+  addController(e) {
+    (this.__controllers ??= /* @__PURE__ */ new Set()).add(e), this.renderRoot !== void 0 && this.isConnected && e.hostConnected?.();
+  }
+  /**
+   * Removes a `ReactiveController` from the element.
+   * @category controllers
+   */
+  removeController(e) {
+    this.__controllers?.delete(e);
+  }
+  /**
+   * Fixes any properties set on the instance before upgrade time.
+   * Otherwise these would shadow the accessor and break these properties.
+   * The properties are stored in a Map which is played back after the
+   * constructor runs.
+   */
+  __saveInstanceProperties() {
+    const e = /* @__PURE__ */ new Map(), t = this.constructor.elementProperties;
+    for (const i of t.keys())
+      this.hasOwnProperty(i) && (e.set(i, this[i]), delete this[i]);
+    e.size > 0 && (this.__instanceProperties = e);
+  }
+  /**
+   * Returns the node into which the element should render and by default
+   * creates and returns an open shadowRoot. Implement to customize where the
+   * element's DOM is rendered. For example, to render into the element's
+   * childNodes, return `this`.
+   *
+   * @return Returns a node into which to render.
+   * @category rendering
+   */
+  createRenderRoot() {
+    const e = this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions);
+    return it(e, this.constructor.elementStyles), e;
+  }
+  /**
+   * On first connection, creates the element's renderRoot, sets up
+   * element styling, and enables updating.
+   * @category lifecycle
+   */
+  connectedCallback() {
+    this.renderRoot ??= this.createRenderRoot(), this.enableUpdating(!0), this.__controllers?.forEach((e) => e.hostConnected?.());
+  }
+  /**
+   * Note, this method should be considered final and not overridden. It is
+   * overridden on the element instance with a function that triggers the first
+   * update.
+   * @category updates
+   */
+  enableUpdating(e) {
+  }
+  /**
+   * Allows for `super.disconnectedCallback()` in extensions while
+   * reserving the possibility of making non-breaking feature additions
+   * when disconnecting at some point in the future.
+   * @category lifecycle
+   */
+  disconnectedCallback() {
+    this.__controllers?.forEach((e) => e.hostDisconnected?.());
+  }
+  /**
+   * Synchronizes property values when attributes change.
+   *
+   * Specifically, when an attribute is set, the corresponding property is set.
+   * You should rarely need to implement this callback. If this method is
+   * overridden, `super.attributeChangedCallback(name, _old, value)` must be
+   * called.
+   *
+   * See [responding to attribute changes](https://developer.mozilla.org/en-US/docs/Web/API/Web_components/Using_custom_elements#responding_to_attribute_changes)
+   * on MDN for more information about the `attributeChangedCallback`.
+   * @category attributes
+   */
+  attributeChangedCallback(e, t, i) {
+    this._$attributeToProperty(e, i);
+  }
+  __propertyToAttribute(e, t) {
+    const s = this.constructor.elementProperties.get(e), r = this.constructor.__attributeNameForProperty(e, s);
+    if (r !== void 0 && s.reflect === !0) {
+      const l = (s.converter?.toAttribute !== void 0 ? s.converter : G).toAttribute(t, s.type);
+      this.constructor.enabledWarnings.includes("migration") && l === void 0 && v("undefined-attribute-value", `The attribute value for the ${e} property is undefined on element ${this.localName}. The attribute will be removed, but in the previous version of \`ReactiveElement\`, the attribute would not have changed.`), this.__reflectingProperty = e, l == null ? this.removeAttribute(r) : this.setAttribute(r, l), this.__reflectingProperty = null;
+    }
+  }
+  /** @internal */
+  _$attributeToProperty(e, t) {
+    const i = this.constructor, s = i.__attributeToPropertyMap.get(e);
+    if (s !== void 0 && this.__reflectingProperty !== s) {
+      const r = i.getPropertyOptions(s), o = typeof r.converter == "function" ? { fromAttribute: r.converter } : r.converter?.fromAttribute !== void 0 ? r.converter : G;
+      this.__reflectingProperty = s, this[s] = o.fromAttribute(t, r.type) ?? this.__defaultValues?.get(s) ?? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      null, this.__reflectingProperty = null;
+    }
+  }
+  /**
+   * Requests an update which is processed asynchronously. This should be called
+   * when an element should update based on some state not triggered by setting
+   * a reactive property. In this case, pass no arguments. It should also be
+   * called when manually implementing a property setter. In this case, pass the
+   * property `name` and `oldValue` to ensure that any configured property
+   * options are honored.
+   *
+   * @param name name of requesting property
+   * @param oldValue old value of requesting property
+   * @param options property options to use instead of the previously
+   *     configured options
+   * @category updates
+   */
+  requestUpdate(e, t, i) {
+    if (e !== void 0) {
+      e instanceof Event && v("", "The requestUpdate() method was called with an Event as the property name. This is probably a mistake caused by binding this.requestUpdate as an event listener. Instead bind a function that will call it with no arguments: () => this.requestUpdate()");
+      const s = this.constructor, r = this[e];
+      if (i ??= s.getPropertyOptions(e), (i.hasChanged ?? me)(r, t) || // When there is no change, check a corner case that can occur when
+      // 1. there's a initial value which was not reflected
+      // 2. the property is subsequently set to this value.
+      // For example, `prop: {useDefault: true, reflect: true}`
+      // and el.prop = 'foo'. This should be considered a change if the
+      // attribute is not set because we will now reflect the property to the attribute.
+      i.useDefault && i.reflect && r === this.__defaultValues?.get(e) && !this.hasAttribute(s.__attributeNameForProperty(e, i)))
+        this._$changeProperty(e, t, i);
+      else
+        return;
+    }
+    this.isUpdatePending === !1 && (this.__updatePromise = this.__enqueueUpdate());
+  }
+  /**
+   * @internal
+   */
+  _$changeProperty(e, t, { useDefault: i, reflect: s, wrapped: r }, o) {
+    i && !(this.__defaultValues ??= /* @__PURE__ */ new Map()).has(e) && (this.__defaultValues.set(e, o ?? t ?? this[e]), r !== !0 || o !== void 0) || (this._$changedProperties.has(e) || (!this.hasUpdated && !i && (t = void 0), this._$changedProperties.set(e, t)), s === !0 && this.__reflectingProperty !== e && (this.__reflectingProperties ??= /* @__PURE__ */ new Set()).add(e));
+  }
+  /**
+   * Sets up the element to asynchronously update.
+   */
+  async __enqueueUpdate() {
+    this.isUpdatePending = !0;
+    try {
+      await this.__updatePromise;
+    } catch (t) {
+      Promise.reject(t);
+    }
+    const e = this.scheduleUpdate();
+    return e != null && await e, !this.isUpdatePending;
+  }
+  /**
+   * Schedules an element update. You can override this method to change the
+   * timing of updates by returning a Promise. The update will await the
+   * returned Promise, and you should resolve the Promise to allow the update
+   * to proceed. If this method is overridden, `super.scheduleUpdate()`
+   * must be called.
+   *
+   * For instance, to schedule updates to occur just before the next frame:
+   *
+   * ```ts
+   * override protected async scheduleUpdate(): Promise<unknown> {
+   *   await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+   *   super.scheduleUpdate();
+   * }
+   * ```
+   * @category updates
+   */
+  scheduleUpdate() {
+    const e = this.performUpdate();
+    return this.constructor.enabledWarnings.includes("async-perform-update") && typeof e?.then == "function" && v("async-perform-update", `Element ${this.localName} returned a Promise from performUpdate(). This behavior is deprecated and will be removed in a future version of ReactiveElement.`), e;
+  }
+  /**
+   * Performs an element update. Note, if an exception is thrown during the
+   * update, `firstUpdated` and `updated` will not be called.
+   *
+   * Call `performUpdate()` to immediately process a pending update. This should
+   * generally not be needed, but it can be done in rare cases when you need to
+   * update synchronously.
+   *
+   * @category updates
+   */
+  performUpdate() {
+    if (!this.isUpdatePending)
+      return;
+    if (dt?.({ kind: "update" }), !this.hasUpdated) {
+      this.renderRoot ??= this.createRenderRoot();
+      {
+        const r = [...this.constructor.elementProperties.keys()].filter((o) => this.hasOwnProperty(o) && o in Ne(this));
+        if (r.length)
+          throw new Error(`The following properties on element ${this.localName} will not trigger updates as expected because they are set using class fields: ${r.join(", ")}. Native class fields and some compiled output will overwrite accessors used for detecting changes. See https://lit.dev/msg/class-field-shadowing for more information.`);
+      }
+      if (this.__instanceProperties) {
+        for (const [s, r] of this.__instanceProperties)
+          this[s] = r;
+        this.__instanceProperties = void 0;
+      }
+      const i = this.constructor.elementProperties;
+      if (i.size > 0)
+        for (const [s, r] of i) {
+          const { wrapped: o } = r, l = this[s];
+          o === !0 && !this._$changedProperties.has(s) && l !== void 0 && this._$changeProperty(s, void 0, r, l);
+        }
+    }
+    let e = !1;
+    const t = this._$changedProperties;
+    try {
+      e = this.shouldUpdate(t), e ? (this.willUpdate(t), this.__controllers?.forEach((i) => i.hostUpdate?.()), this.update(t)) : this.__markUpdated();
+    } catch (i) {
+      throw e = !1, this.__markUpdated(), i;
+    }
+    e && this._$didUpdate(t);
+  }
+  /**
+   * Invoked before `update()` to compute values needed during the update.
+   *
+   * Implement `willUpdate` to compute property values that depend on other
+   * properties and are used in the rest of the update process.
+   *
+   * ```ts
+   * willUpdate(changedProperties) {
+   *   // only need to check changed properties for an expensive computation.
+   *   if (changedProperties.has('firstName') || changedProperties.has('lastName')) {
+   *     this.sha = computeSHA(`${this.firstName} ${this.lastName}`);
+   *   }
+   * }
+   *
+   * render() {
+   *   return html`SHA: ${this.sha}`;
+   * }
+   * ```
+   *
+   * @category updates
+   */
+  willUpdate(e) {
+  }
+  // Note, this is an override point for polyfill-support.
+  // @internal
+  _$didUpdate(e) {
+    this.__controllers?.forEach((t) => t.hostUpdated?.()), this.hasUpdated || (this.hasUpdated = !0, this.firstUpdated(e)), this.updated(e), this.isUpdatePending && this.constructor.enabledWarnings.includes("change-in-update") && v("change-in-update", `Element ${this.localName} scheduled an update (generally because a property was set) after an update completed, causing a new update to be scheduled. This is inefficient and should be avoided unless the next update can only be scheduled as a side effect of the previous update.`);
+  }
+  __markUpdated() {
+    this._$changedProperties = /* @__PURE__ */ new Map(), this.isUpdatePending = !1;
+  }
+  /**
+   * Returns a Promise that resolves when the element has completed updating.
+   * The Promise value is a boolean that is `true` if the element completed the
+   * update without triggering another update. The Promise result is `false` if
+   * a property was set inside `updated()`. If the Promise is rejected, an
+   * exception was thrown during the update.
+   *
+   * To await additional asynchronous work, override the `getUpdateComplete`
+   * method. For example, it is sometimes useful to await a rendered element
+   * before fulfilling this Promise. To do this, first await
+   * `super.getUpdateComplete()`, then any subsequent state.
+   *
+   * @return A promise of a boolean that resolves to true if the update completed
+   *     without triggering another update.
+   * @category updates
+   */
+  get updateComplete() {
+    return this.getUpdateComplete();
+  }
+  /**
+   * Override point for the `updateComplete` promise.
+   *
+   * It is not safe to override the `updateComplete` getter directly due to a
+   * limitation in TypeScript which means it is not possible to call a
+   * superclass getter (e.g. `super.updateComplete.then(...)`) when the target
+   * language is ES5 (https://github.com/microsoft/TypeScript/issues/338).
+   * This method should be overridden instead. For example:
+   *
+   * ```ts
+   * class MyElement extends LitElement {
+   *   override async getUpdateComplete() {
+   *     const result = await super.getUpdateComplete();
+   *     await this._myChild.updateComplete;
+   *     return result;
+   *   }
+   * }
+   * ```
+   *
+   * @return A promise of a boolean that resolves to true if the update completed
+   *     without triggering another update.
+   * @category updates
+   */
+  getUpdateComplete() {
+    return this.__updatePromise;
+  }
+  /**
+   * Controls whether or not `update()` should be called when the element requests
+   * an update. By default, this method always returns `true`, but this can be
+   * customized to control when to update.
+   *
+   * @param _changedProperties Map of changed properties with old values
+   * @category updates
+   */
+  shouldUpdate(e) {
+    return !0;
+  }
+  /**
+   * Updates the element. This method reflects property values to attributes.
+   * It can be overridden to render and keep updated element DOM.
+   * Setting properties inside this method will *not* trigger
+   * another update.
+   *
+   * @param _changedProperties Map of changed properties with old values
+   * @category updates
+   */
+  update(e) {
+    this.__reflectingProperties &&= this.__reflectingProperties.forEach((t) => this.__propertyToAttribute(t, this[t])), this.__markUpdated();
+  }
+  /**
+   * Invoked whenever the element is updated. Implement to perform
+   * post-updating tasks via DOM APIs, for example, focusing an element.
+   *
+   * Setting properties inside this method will trigger the element to update
+   * again after this update cycle completes.
+   *
+   * @param _changedProperties Map of changed properties with old values
+   * @category updates
+   */
+  updated(e) {
+  }
+  /**
+   * Invoked when the element is first updated. Implement to perform one time
+   * work on the element after update.
+   *
+   * ```ts
+   * firstUpdated() {
+   *   this.renderRoot.getElementById('my-text-area').focus();
+   * }
+   * ```
+   *
+   * Setting properties inside this method will trigger the element to update
+   * again after this update cycle completes.
+   *
+   * @param _changedProperties Map of changed properties with old values
+   * @category updates
+   */
+  firstUpdated(e) {
+  }
+}
+C.elementStyles = [];
+C.shadowRootOptions = { mode: "open" };
+C[V("elementProperties")] = /* @__PURE__ */ new Map();
+C[V("finalized")] = /* @__PURE__ */ new Map();
+je?.({ ReactiveElement: C });
+{
+  C.enabledWarnings = [
+    "change-in-update",
+    "async-perform-update"
+  ];
+  const n = function(e) {
+    e.hasOwnProperty(V("enabledWarnings")) || (e.enabledWarnings = e.enabledWarnings.slice());
+  };
+  C.enableWarning = function(e) {
+    n(this), this.enabledWarnings.includes(e) || this.enabledWarnings.push(e);
+  }, C.disableWarning = function(e) {
+    n(this);
+    const t = this.enabledWarnings.indexOf(e);
+    t >= 0 && this.enabledWarnings.splice(t, 1);
+  };
+}
+($.reactiveElementVersions ??= []).push("2.1.0");
+$.reactiveElementVersions.length > 1 && queueMicrotask(() => {
+  v("multiple-versions", "Multiple versions of Lit loaded. Loading multiple versions is not recommended.");
+});
+const b = globalThis, u = (n) => {
+  b.emitLitDebugLogEvents && b.dispatchEvent(new CustomEvent("lit-debug", {
+    detail: n
+  }));
+};
+let ct = 0, H;
+b.litIssuedWarnings ??= /* @__PURE__ */ new Set(), H = (n, e) => {
+  e += n ? ` See https://lit.dev/msg/${n} for more information.` : "", !b.litIssuedWarnings.has(e) && !b.litIssuedWarnings.has(n) && (console.warn(e), b.litIssuedWarnings.add(e));
 }, queueMicrotask(() => {
-  I("dev-mode", "Lit is in dev mode. Not recommended for production!");
+  H("dev-mode", "Lit is in dev mode. Not recommended for production!");
 });
-const x = $.ShadyDOM?.inUse && $.ShadyDOM?.noPatch === !0 ? $.ShadyDOM.wrap : (o) => o, z = $.trustedTypes, pe = z ? z.createPolicy("lit-html", {
-  createHTML: (o) => o
-}) : void 0, De = (o) => o, Ce = (o, e, t) => De, ue = (o, e, t) => j(), Ne = "$lit$", v = `lit$${Math.random().toFixed(9).slice(2)}$`, Se = "?" + v, Ue = `<${Se}>`, V = document, O = () => V.createComment(""), D = (o) => o === null || typeof o != "object" && typeof o != "function", ie = Array.isArray, Ie = (o) => ie(o) || // eslint-disable-next-line @typescript-eslint/no-explicit-any
-typeof o?.[Symbol.iterator] == "function", K = `[ 	
-\f\r]`, ze = `[^ 	
-\f\r"'\`<>=]`, Oe = `[^\\s"'>=/]`, R = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g, fe = 1, G = 2, He = 3, ge = /-->/g, _e = />/g, S = new RegExp(`>|${K}(?:(${Oe}+)(${K}*=${K}*(?:${ze}|("|')|))|$)`, "g"), Be = 0, ye = 1, je = 2, $e = 3, Y = /'/g, Z = /"/g, Ee = /^(?:script|style|textarea|title)$/i, J = 2, ee = 3, se = 1, H = 2, We = 3, Fe = 4, Ke = 5, ne = 6, Ge = 7, N = /* @__PURE__ */ Symbol.for("lit-noChange"), _ = /* @__PURE__ */ Symbol.for("lit-nothing"), be = /* @__PURE__ */ new WeakMap(), A = V.createTreeWalker(
-  V,
+const S = b.ShadyDOM?.inUse && b.ShadyDOM?.noPatch === !0 ? b.ShadyDOM.wrap : (n) => n, Y = b.trustedTypes, Ae = Y ? Y.createPolicy("lit-html", {
+  createHTML: (n) => n
+}) : void 0, ht = (n) => n, Z = (n, e, t) => ht, pt = (n) => {
+  if (O !== Z)
+    throw new Error("Attempted to overwrite existing lit-html security policy. setSanitizeDOMValueFactory should be called at most once.");
+  O = n;
+}, ut = () => {
+  O = Z;
+}, ce = (n, e, t) => O(n, e, t), Be = "$lit$", x = `lit$${Math.random().toFixed(9).slice(2)}$`, Fe = "?" + x, ft = `<${Fe}>`, k = document, j = () => k.createComment(""), B = (n) => n === null || typeof n != "object" && typeof n != "function", ge = Array.isArray, mt = (n) => ge(n) || // eslint-disable-next-line @typescript-eslint/no-explicit-any
+typeof n?.[Symbol.iterator] == "function", se = `[ 	
+\f\r]`, gt = `[^ 	
+\f\r"'\`<>=]`, _t = `[^\\s"'>=/]`, I = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g, Re = 1, ne = 2, yt = 3, ke = /-->/g, Oe = />/g, U = new RegExp(`>|${se}(?:(${_t}+)(${se}*=${se}*(?:${gt}|("|')|))|$)`, "g"), bt = 0, Ve = 1, $t = 2, Le = 3, re = /'/g, oe = /"/g, qe = /^(?:script|style|textarea|title)$/i, wt = 1, he = 2, pe = 3, _e = 1, J = 2, St = 3, vt = 4, Pt = 5, ye = 6, xt = 7, Tt = (n) => (e, ...t) => (e.some((i) => i === void 0) && console.warn(`Some template strings are undefined.
+This is probably caused by illegal octal escape sequences.`), t.some((i) => i?._$litStatic$) && H("", `Static values 'literal' or 'unsafeStatic' cannot be used as values to non-static templates.
+Please use the static 'html' tag function. See https://lit.dev/docs/templates/expressions/#static-expressions`), {
+  // This property needs to remain unminified.
+  _$litType$: n,
+  strings: e,
+  values: t
+}), y = Tt(wt), E = /* @__PURE__ */ Symbol.for("lit-noChange"), m = /* @__PURE__ */ Symbol.for("lit-nothing"), De = /* @__PURE__ */ new WeakMap(), R = k.createTreeWalker(
+  k,
   129
   /* NodeFilter.SHOW_{ELEMENT|COMMENT} */
 );
-let j = Ce;
-function Ae(o, e) {
-  if (!ie(o) || !o.hasOwnProperty("raw")) {
+let O = Z;
+function Ke(n, e) {
+  if (!ge(n) || !n.hasOwnProperty("raw")) {
     let t = "invalid template strings array";
     throw t = `
           Internal Error: expected template strings to be an array
@@ -38,87 +758,87 @@ function Ae(o, e) {
         `.trim().replace(/\n */g, `
 `), new Error(t);
   }
-  return pe !== void 0 ? pe.createHTML(e) : e;
+  return Ae !== void 0 ? Ae.createHTML(e) : e;
 }
-const Ye = (o, e) => {
-  const t = o.length - 1, i = [];
-  let s = e === J ? "<svg>" : e === ee ? "<math>" : "", n, r = R;
+const Ct = (n, e) => {
+  const t = n.length - 1, i = [];
+  let s = e === he ? "<svg>" : e === pe ? "<math>" : "", r, o = I;
   for (let a = 0; a < t; a++) {
-    const c = o[a];
-    let f = -1, m, d = 0, l;
-    for (; d < c.length && (r.lastIndex = d, l = r.exec(c), l !== null); )
-      if (d = r.lastIndex, r === R) {
-        if (l[fe] === "!--")
-          r = ge;
-        else if (l[fe] !== void 0)
-          r = _e;
-        else if (l[G] !== void 0)
-          Ee.test(l[G]) && (n = new RegExp(`</${l[G]}`, "g")), r = S;
-        else if (l[He] !== void 0)
+    const h = n[a];
+    let g = -1, p, c = 0, d;
+    for (; c < h.length && (o.lastIndex = c, d = o.exec(h), d !== null); )
+      if (c = o.lastIndex, o === I) {
+        if (d[Re] === "!--")
+          o = ke;
+        else if (d[Re] !== void 0)
+          o = Oe;
+        else if (d[ne] !== void 0)
+          qe.test(d[ne]) && (r = new RegExp(`</${d[ne]}`, "g")), o = U;
+        else if (d[yt] !== void 0)
           throw new Error("Bindings in tag names are not supported. Please use static templates instead. See https://lit.dev/docs/templates/expressions/#static-expressions");
-      } else r === S ? l[Be] === ">" ? (r = n ?? R, f = -1) : l[ye] === void 0 ? f = -2 : (f = r.lastIndex - l[je].length, m = l[ye], r = l[$e] === void 0 ? S : l[$e] === '"' ? Z : Y) : r === Z || r === Y ? r = S : r === ge || r === _e ? r = R : (r = S, n = void 0);
-    console.assert(f === -1 || r === S || r === Y || r === Z, "unexpected parse state B");
-    const p = r === S && o[a + 1].startsWith("/>") ? " " : "";
-    s += r === R ? c + Ue : f >= 0 ? (i.push(m), c.slice(0, f) + Ne + c.slice(f) + v + p) : c + v + (f === -2 ? a : p);
+      } else o === U ? d[bt] === ">" ? (o = r ?? I, g = -1) : d[Ve] === void 0 ? g = -2 : (g = o.lastIndex - d[$t].length, p = d[Ve], o = d[Le] === void 0 ? U : d[Le] === '"' ? oe : re) : o === oe || o === re ? o = U : o === ke || o === Oe ? o = I : (o = U, r = void 0);
+    console.assert(g === -1 || o === U || o === re || o === oe, "unexpected parse state B");
+    const f = o === U && n[a + 1].startsWith("/>") ? " " : "";
+    s += o === I ? h + ft : g >= 0 ? (i.push(p), h.slice(0, g) + Be + h.slice(g) + x + f) : h + x + (g === -2 ? a : f);
   }
-  const h = s + (o[t] || "<?>") + (e === J ? "</svg>" : e === ee ? "</math>" : "");
-  return [Ae(o, h), i];
+  const l = s + (n[t] || "<?>") + (e === he ? "</svg>" : e === pe ? "</math>" : "");
+  return [Ke(n, l), i];
 };
-class U {
+class F {
   constructor({ strings: e, ["_$litType$"]: t }, i) {
     this.parts = [];
-    let s, n = 0, r = 0;
-    const h = e.length - 1, a = this.parts, [c, f] = Ye(e, t);
-    if (this.el = U.createElement(c, i), A.currentNode = this.el.content, t === J || t === ee) {
-      const m = this.el.content.firstChild;
-      m.replaceWith(...m.childNodes);
+    let s, r = 0, o = 0;
+    const l = e.length - 1, a = this.parts, [h, g] = Ct(e, t);
+    if (this.el = F.createElement(h, i), R.currentNode = this.el.content, t === he || t === pe) {
+      const p = this.el.content.firstChild;
+      p.replaceWith(...p.childNodes);
     }
-    for (; (s = A.nextNode()) !== null && a.length < h; ) {
+    for (; (s = R.nextNode()) !== null && a.length < l; ) {
       if (s.nodeType === 1) {
         {
-          const m = s.localName;
-          if (/^(?:textarea|template)$/i.test(m) && s.innerHTML.includes(v)) {
-            const d = `Expressions are not supported inside \`${m}\` elements. See https://lit.dev/msg/expression-in-${m} for more information.`;
-            if (m === "template")
-              throw new Error(d);
-            I("", d);
+          const p = s.localName;
+          if (/^(?:textarea|template)$/i.test(p) && s.innerHTML.includes(x)) {
+            const c = `Expressions are not supported inside \`${p}\` elements. See https://lit.dev/msg/expression-in-${p} for more information.`;
+            if (p === "template")
+              throw new Error(c);
+            H("", c);
           }
         }
         if (s.hasAttributes())
-          for (const m of s.getAttributeNames())
-            if (m.endsWith(Ne)) {
-              const d = f[r++], p = s.getAttribute(m).split(v), g = /([.?@])?(.*)/.exec(d);
+          for (const p of s.getAttributeNames())
+            if (p.endsWith(Be)) {
+              const c = g[o++], f = s.getAttribute(p).split(x), _ = /([.?@])?(.*)/.exec(c);
               a.push({
-                type: se,
-                index: n,
-                name: g[2],
-                strings: p,
-                ctor: g[1] === "." ? qe : g[1] === "?" ? Qe : g[1] === "@" ? Xe : W
-              }), s.removeAttribute(m);
-            } else m.startsWith(v) && (a.push({
-              type: ne,
-              index: n
-            }), s.removeAttribute(m));
-        if (Ee.test(s.tagName)) {
-          const m = s.textContent.split(v), d = m.length - 1;
-          if (d > 0) {
-            s.textContent = z ? z.emptyScript : "";
-            for (let l = 0; l < d; l++)
-              s.append(m[l], O()), A.nextNode(), a.push({ type: H, index: ++n });
-            s.append(m[d], O());
+                type: _e,
+                index: r,
+                name: _[2],
+                strings: f,
+                ctor: _[1] === "." ? Nt : _[1] === "?" ? Mt : _[1] === "@" ? Ut : ee
+              }), s.removeAttribute(p);
+            } else p.startsWith(x) && (a.push({
+              type: ye,
+              index: r
+            }), s.removeAttribute(p));
+        if (qe.test(s.tagName)) {
+          const p = s.textContent.split(x), c = p.length - 1;
+          if (c > 0) {
+            s.textContent = Y ? Y.emptyScript : "";
+            for (let d = 0; d < c; d++)
+              s.append(p[d], j()), R.nextNode(), a.push({ type: J, index: ++r });
+            s.append(p[c], j());
           }
         }
       } else if (s.nodeType === 8)
-        if (s.data === Se)
-          a.push({ type: H, index: n });
+        if (s.data === Fe)
+          a.push({ type: J, index: r });
         else {
-          let d = -1;
-          for (; (d = s.data.indexOf(v, d + 1)) !== -1; )
-            a.push({ type: Ge, index: n }), d += v.length - 1;
+          let c = -1;
+          for (; (c = s.data.indexOf(x, c + 1)) !== -1; )
+            a.push({ type: xt, index: r }), c += x.length - 1;
         }
-      n++;
+      r++;
     }
-    if (f.length !== r)
+    if (g.length !== o)
       throw new Error('Detected duplicate attribute bindings. This occurs if your template has duplicate attributes on an element tag. For example "<input ?disabled=${true} ?disabled=${false}>" contains a duplicate "disabled" attribute. The error was detected in the following template: \n`' + e.join("${...}") + "`");
     u && u({
       kind: "template prep",
@@ -131,21 +851,21 @@ class U {
   // Overridden via `litHtmlPolyfillSupport` to provide platform support.
   /** @nocollapse */
   static createElement(e, t) {
-    const i = V.createElement("template");
+    const i = k.createElement("template");
     return i.innerHTML = e, i;
   }
 }
-function L(o, e, t = o, i) {
-  if (e === N)
+function L(n, e, t = n, i) {
+  if (e === E)
     return e;
   let s = i !== void 0 ? t.__directives?.[i] : t.__directive;
-  const n = D(e) ? void 0 : (
+  const r = B(e) ? void 0 : (
     // This property needs to remain unminified.
     e._$litDirective$
   );
-  return s?.constructor !== n && (s?._$notifyDirectiveConnectionChanged?.(!1), n === void 0 ? s = void 0 : (s = new n(o), s._$initialize(o, t, i)), i !== void 0 ? (t.__directives ??= [])[i] = s : t.__directive = s), s !== void 0 && (e = L(o, s._$resolve(o, e.values), s, i)), e;
+  return s?.constructor !== r && (s?._$notifyDirectiveConnectionChanged?.(!1), r === void 0 ? s = void 0 : (s = new r(n), s._$initialize(n, t, i)), i !== void 0 ? (t.__directives ??= [])[i] = s : t.__directive = s), s !== void 0 && (e = L(n, s._$resolve(n, e.values), s, i)), e;
 }
-class Ze {
+class Et {
   constructor(e, t) {
     this._$parts = [], this._$disconnectableChildren = void 0, this._$template = e, this._$parent = t;
   }
@@ -160,17 +880,17 @@ class Ze {
   // This method is separate from the constructor because we need to return a
   // DocumentFragment and we don't want to hold onto it with an instance field.
   _clone(e) {
-    const { el: { content: t }, parts: i } = this._$template, s = (e?.creationScope ?? V).importNode(t, !0);
-    A.currentNode = s;
-    let n = A.nextNode(), r = 0, h = 0, a = i[0];
+    const { el: { content: t }, parts: i } = this._$template, s = (e?.creationScope ?? k).importNode(t, !0);
+    R.currentNode = s;
+    let r = R.nextNode(), o = 0, l = 0, a = i[0];
     for (; a !== void 0; ) {
-      if (r === a.index) {
-        let c;
-        a.type === H ? c = new oe(n, n.nextSibling, this, e) : a.type === se ? c = new a.ctor(n, a.name, a.strings, this, e) : a.type === ne && (c = new Je(n, this, e)), this._$parts.push(c), a = i[++h];
+      if (o === a.index) {
+        let h;
+        a.type === J ? h = new X(r, r.nextSibling, this, e) : a.type === _e ? h = new a.ctor(r, a.name, a.strings, this, e) : a.type === ye && (h = new At(r, this, e)), this._$parts.push(h), a = i[++l];
       }
-      r !== a?.index && (n = A.nextNode(), r++);
+      o !== a?.index && (r = R.nextNode(), o++);
     }
-    return A.currentNode = V, s;
+    return R.currentNode = k, s;
   }
   _update(e) {
     let t = 0;
@@ -185,13 +905,13 @@ class Ze {
       }), i.strings !== void 0 ? (i._$setValue(e, i, t), t += i.strings.length - 2) : i._$setValue(e[t])), t++;
   }
 }
-let oe = class Ve {
+let X = class Ge {
   // See comment in Disconnectable interface for why this is a getter
   get _$isConnected() {
     return this._$parent?._$isConnected ?? this.__isConnected;
   }
   constructor(e, t, i, s) {
-    this.type = H, this._$committedValue = _, this._$disconnectableChildren = void 0, this._$startNode = e, this._$endNode = t, this._$parent = i, this.options = s, this.__isConnected = s?.isConnected ?? !0, this._textSanitizer = void 0;
+    this.type = J, this._$committedValue = m, this._$disconnectableChildren = void 0, this._$startNode = e, this._$endNode = t, this._$parent = i, this.options = s, this.__isConnected = s?.isConnected ?? !0, this._textSanitizer = void 0;
   }
   /**
    * The parent node into which the part renders its content.
@@ -212,7 +932,7 @@ let oe = class Ve {
    * consists of all child nodes of `.parentNode`.
    */
   get parentNode() {
-    let e = x(this._$startNode).parentNode;
+    let e = S(this._$startNode).parentNode;
     const t = this._$parent;
     return t !== void 0 && e?.nodeType === 11 && (e = t.parentNode), e;
   }
@@ -233,14 +953,14 @@ let oe = class Ve {
   _$setValue(e, t = this) {
     if (this.parentNode === null)
       throw new Error("This `ChildPart` has no `parentNode` and therefore cannot accept a value. This likely means the element containing the part was manipulated in an unsupported way outside of Lit's control such that the part's marker nodes were ejected from DOM. For example, setting the element's `innerHTML` or `textContent` can do this.");
-    if (e = L(this, e, t), D(e))
-      e === _ || e == null || e === "" ? (this._$committedValue !== _ && (u && u({
+    if (e = L(this, e, t), B(e))
+      e === m || e == null || e === "" ? (this._$committedValue !== m && (u && u({
         kind: "commit nothing to child",
         start: this._$startNode,
         end: this._$endNode,
         parent: this._$parent,
         options: this.options
-      }), this._$clear()), this._$committedValue = _) : e !== this._$committedValue && e !== N && this._commitText(e);
+      }), this._$clear()), this._$committedValue = m) : e !== this._$committedValue && e !== E && this._commitText(e);
     else if (e._$litType$ !== void 0)
       this._commitTemplateResult(e);
     else if (e.nodeType !== void 0) {
@@ -249,14 +969,14 @@ let oe = class Ve {
         return;
       }
       this._commitNode(e);
-    } else Ie(e) ? this._commitIterable(e) : this._commitText(e);
+    } else mt(e) ? this._commitIterable(e) : this._commitText(e);
   }
   _insert(e) {
-    return x(x(this._$startNode).parentNode).insertBefore(e, this._$endNode);
+    return S(S(this._$startNode).parentNode).insertBefore(e, this._$endNode);
   }
   _commitNode(e) {
     if (this._$committedValue !== e) {
-      if (this._$clear(), j !== Ce) {
+      if (this._$clear(), O !== Z) {
         const t = this._$startNode.parentNode?.nodeName;
         if (t === "STYLE" || t === "SCRIPT") {
           let i = "Forbidden";
@@ -273,17 +993,17 @@ let oe = class Ve {
     }
   }
   _commitText(e) {
-    if (this._$committedValue !== _ && D(this._$committedValue)) {
-      const t = x(this._$startNode).nextSibling;
-      this._textSanitizer === void 0 && (this._textSanitizer = ue()), e = this._textSanitizer(e), u && u({
+    if (this._$committedValue !== m && B(this._$committedValue)) {
+      const t = S(this._$startNode).nextSibling;
+      this._textSanitizer === void 0 && (this._textSanitizer = ce(t, "data", "property")), e = this._textSanitizer(e), u && u({
         kind: "commit text",
         node: t,
         value: e,
         options: this.options
       }), t.data = e;
     } else {
-      const t = V.createTextNode("");
-      this._commitNode(t), this._textSanitizer === void 0 && (this._textSanitizer = ue()), e = this._textSanitizer(e), u && u({
+      const t = k.createTextNode("");
+      this._commitNode(t), this._textSanitizer === void 0 && (this._textSanitizer = ce(t, "data", "property")), e = this._textSanitizer(e), u && u({
         kind: "commit text",
         node: t,
         value: e,
@@ -293,7 +1013,7 @@ let oe = class Ve {
     this._$committedValue = e;
   }
   _commitTemplateResult(e) {
-    const { values: t, ["_$litType$"]: i } = e, s = typeof i == "number" ? this._$getTemplate(e) : (i.el === void 0 && (i.el = U.createElement(Ae(i.h, i.h[0]), this.options)), i);
+    const { values: t, ["_$litType$"]: i } = e, s = typeof i == "number" ? this._$getTemplate(e) : (i.el === void 0 && (i.el = F.createElement(Ke(i.h, i.h[0]), this.options)), i);
     if (this._$committedValue?._$template === s)
       u && u({
         kind: "template updating",
@@ -304,39 +1024,39 @@ let oe = class Ve {
         values: t
       }), this._$committedValue._update(t);
     else {
-      const n = new Ze(s, this), r = n._clone(this.options);
+      const r = new Et(s, this), o = r._clone(this.options);
       u && u({
         kind: "template instantiated",
         template: s,
-        instance: n,
-        parts: n._$parts,
+        instance: r,
+        parts: r._$parts,
         options: this.options,
-        fragment: r,
+        fragment: o,
         values: t
-      }), n._update(t), u && u({
+      }), r._update(t), u && u({
         kind: "template instantiated and updated",
         template: s,
-        instance: n,
-        parts: n._$parts,
+        instance: r,
+        parts: r._$parts,
         options: this.options,
-        fragment: r,
+        fragment: o,
         values: t
-      }), this._commitNode(r), this._$committedValue = n;
+      }), this._commitNode(o), this._$committedValue = r;
     }
   }
   // Overridden via `litHtmlPolyfillSupport` to provide platform support.
   /** @internal */
   _$getTemplate(e) {
-    let t = be.get(e.strings);
-    return t === void 0 && be.set(e.strings, t = new U(e)), t;
+    let t = De.get(e.strings);
+    return t === void 0 && De.set(e.strings, t = new F(e)), t;
   }
   _commitIterable(e) {
-    ie(this._$committedValue) || (this._$committedValue = [], this._$clear());
+    ge(this._$committedValue) || (this._$committedValue = [], this._$clear());
     const t = this._$committedValue;
     let i = 0, s;
-    for (const n of e)
-      i === t.length ? t.push(s = new Ve(this._insert(O()), this._insert(O()), this, this.options)) : s = t[i], s._$setValue(n), i++;
-    i < t.length && (this._$clear(s && x(s._$endNode).nextSibling, i), t.length = i);
+    for (const r of e)
+      i === t.length ? t.push(s = new Ge(this._insert(j()), this._insert(j()), this, this.options)) : s = t[i], s._$setValue(r), i++;
+    i < t.length && (this._$clear(s && S(s._$endNode).nextSibling, i), t.length = i);
   }
   /**
    * Removes the nodes contained within this Part from the DOM.
@@ -349,10 +1069,10 @@ let oe = class Ve {
    *
    * @internal
    */
-  _$clear(e = x(this._$startNode).nextSibling, t) {
+  _$clear(e = S(this._$startNode).nextSibling, t) {
     for (this._$notifyConnectionChanged?.(!1, !0, t); e && e !== this._$endNode; ) {
-      const i = x(e).nextSibling;
-      x(e).remove(), e = i;
+      const i = S(e).nextSibling;
+      S(e).remove(), e = i;
     }
   }
   /**
@@ -369,7 +1089,7 @@ let oe = class Ve {
       throw new Error("part.setConnected() may only be called on a RootPart returned from render().");
   }
 };
-class W {
+class ee {
   get tagName() {
     return this.element.tagName;
   }
@@ -377,8 +1097,8 @@ class W {
   get _$isConnected() {
     return this._$parent._$isConnected;
   }
-  constructor(e, t, i, s, n) {
-    this.type = se, this._$committedValue = _, this._$disconnectableChildren = void 0, this.element = e, this.name = t, this._$parent = s, this.options = n, i.length > 2 || i[0] !== "" || i[1] !== "" ? (this._$committedValue = new Array(i.length - 1).fill(new String()), this.strings = i) : this._$committedValue = _, this._sanitizer = void 0;
+  constructor(e, t, i, s, r) {
+    this.type = _e, this._$committedValue = m, this._$disconnectableChildren = void 0, this.element = e, this.name = t, this._$parent = s, this.options = r, i.length > 2 || i[0] !== "" || i[1] !== "" ? (this._$committedValue = new Array(i.length - 1).fill(new String()), this.strings = i) : this._$committedValue = m, this._sanitizer = void 0;
   }
   /**
    * Sets the value of this part by resolving the value from possibly multiple
@@ -403,48 +1123,48 @@ class W {
    * @internal
    */
   _$setValue(e, t = this, i, s) {
-    const n = this.strings;
-    let r = !1;
-    if (n === void 0)
-      e = L(this, e, t, 0), r = !D(e) || e !== this._$committedValue && e !== N, r && (this._$committedValue = e);
+    const r = this.strings;
+    let o = !1;
+    if (r === void 0)
+      e = L(this, e, t, 0), o = !B(e) || e !== this._$committedValue && e !== E, o && (this._$committedValue = e);
     else {
-      const h = e;
-      e = n[0];
-      let a, c;
-      for (a = 0; a < n.length - 1; a++)
-        c = L(this, h[i + a], t, a), c === N && (c = this._$committedValue[a]), r ||= !D(c) || c !== this._$committedValue[a], c === _ ? e = _ : e !== _ && (e += (c ?? "") + n[a + 1]), this._$committedValue[a] = c;
+      const l = e;
+      e = r[0];
+      let a, h;
+      for (a = 0; a < r.length - 1; a++)
+        h = L(this, l[i + a], t, a), h === E && (h = this._$committedValue[a]), o ||= !B(h) || h !== this._$committedValue[a], h === m ? e = m : e !== m && (e += (h ?? "") + r[a + 1]), this._$committedValue[a] = h;
     }
-    r && !s && this._commitValue(e);
+    o && !s && this._commitValue(e);
   }
   /** @internal */
   _commitValue(e) {
-    e === _ ? x(this.element).removeAttribute(this.name) : (this._sanitizer === void 0 && (this._sanitizer = j(this.element, this.name)), e = this._sanitizer(e ?? ""), u && u({
+    e === m ? S(this.element).removeAttribute(this.name) : (this._sanitizer === void 0 && (this._sanitizer = O(this.element, this.name, "attribute")), e = this._sanitizer(e ?? ""), u && u({
       kind: "commit attribute",
       element: this.element,
       name: this.name,
       value: e,
       options: this.options
-    }), x(this.element).setAttribute(this.name, e ?? ""));
+    }), S(this.element).setAttribute(this.name, e ?? ""));
   }
 }
-class qe extends W {
+class Nt extends ee {
   constructor() {
-    super(...arguments), this.type = We;
+    super(...arguments), this.type = St;
   }
   /** @internal */
   _commitValue(e) {
-    this._sanitizer === void 0 && (this._sanitizer = j(this.element, this.name)), e = this._sanitizer(e), u && u({
+    this._sanitizer === void 0 && (this._sanitizer = O(this.element, this.name, "property")), e = this._sanitizer(e), u && u({
       kind: "commit property",
       element: this.element,
       name: this.name,
       value: e,
       options: this.options
-    }), this.element[this.name] = e === _ ? void 0 : e;
+    }), this.element[this.name] = e === m ? void 0 : e;
   }
 }
-class Qe extends W {
+class Mt extends ee {
   constructor() {
-    super(...arguments), this.type = Fe;
+    super(...arguments), this.type = vt;
   }
   /** @internal */
   _commitValue(e) {
@@ -452,23 +1172,23 @@ class Qe extends W {
       kind: "commit boolean attribute",
       element: this.element,
       name: this.name,
-      value: !!(e && e !== _),
+      value: !!(e && e !== m),
       options: this.options
-    }), x(this.element).toggleAttribute(this.name, !!e && e !== _);
+    }), S(this.element).toggleAttribute(this.name, !!e && e !== m);
   }
 }
-class Xe extends W {
-  constructor(e, t, i, s, n) {
-    if (super(e, t, i, s, n), this.type = Ke, this.strings !== void 0)
+class Ut extends ee {
+  constructor(e, t, i, s, r) {
+    if (super(e, t, i, s, r), this.type = Pt, this.strings !== void 0)
       throw new Error(`A \`<${e.localName}>\` has a \`@${t}=...\` listener with invalid content. Event listeners in templates must have exactly one expression and no surrounding text.`);
   }
   // EventPart does not use the base _$setValue/_resolveValue implementation
   // since the dirty checking is more complex
   /** @internal */
   _$setValue(e, t = this) {
-    if (e = L(this, e, t, 0) ?? _, e === N)
+    if (e = L(this, e, t, 0) ?? m, e === E)
       return;
-    const i = this._$committedValue, s = e === _ && i !== _ || e.capture !== i.capture || e.once !== i.once || e.passive !== i.passive, n = e !== _ && (i === _ || s);
+    const i = this._$committedValue, s = e === m && i !== m || e.capture !== i.capture || e.once !== i.once || e.passive !== i.passive, r = e !== m && (i === m || s);
     u && u({
       kind: "commit event listener",
       element: this.element,
@@ -476,17 +1196,17 @@ class Xe extends W {
       value: e,
       options: this.options,
       removeListener: s,
-      addListener: n,
+      addListener: r,
       oldListener: i
-    }), s && this.element.removeEventListener(this.name, this, i), n && this.element.addEventListener(this.name, this, e), this._$committedValue = e;
+    }), s && this.element.removeEventListener(this.name, this, i), r && this.element.addEventListener(this.name, this, e), this._$committedValue = e;
   }
   handleEvent(e) {
     typeof this._$committedValue == "function" ? this._$committedValue.call(this.options?.host ?? this.element, e) : this._$committedValue.handleEvent(e);
   }
 }
-class Je {
+class At {
   constructor(e, t, i) {
-    this.element = e, this.type = ne, this._$disconnectableChildren = void 0, this._$parent = t, this.options = i;
+    this.element = e, this.type = ye, this._$disconnectableChildren = void 0, this._$parent = t, this.options = i;
   }
   // See comment in Disconnectable interface for why this is a getter
   get _$isConnected() {
@@ -501,23 +1221,210 @@ class Je {
     }), L(this, e);
   }
 }
-const et = {
-  _ChildPart: oe
-}, tt = $.litHtmlPolyfillSupportDevMode;
-tt?.(U, oe);
-($.litHtmlVersions ??= []).push("3.3.0");
-$.litHtmlVersions.length > 1 && queueMicrotask(() => {
-  I("multiple-versions", "Multiple versions of Lit loaded. Loading multiple versions is not recommended.");
+const Rt = {
+  _ChildPart: X
+}, kt = b.litHtmlPolyfillSupportDevMode;
+kt?.(F, X);
+(b.litHtmlVersions ??= []).push("3.3.0");
+b.litHtmlVersions.length > 1 && queueMicrotask(() => {
+  H("multiple-versions", "Multiple versions of Lit loaded. Loading multiple versions is not recommended.");
 });
-const re = {
+const K = (n, e, t) => {
+  if (e == null)
+    throw new TypeError(`The container to render into may not be ${e}`);
+  const i = ct++, s = t?.renderBefore ?? e;
+  let r = s._$litPart$;
+  if (u && u({
+    kind: "begin render",
+    id: i,
+    value: n,
+    container: e,
+    options: t,
+    part: r
+  }), r === void 0) {
+    const o = t?.renderBefore ?? null;
+    s._$litPart$ = r = new X(e.insertBefore(j(), o), o, void 0, t ?? {});
+  }
+  return r._$setValue(n), u && u({
+    kind: "end render",
+    id: i,
+    value: n,
+    container: e,
+    options: t,
+    part: r
+  }), r;
+};
+K.setSanitizer = pt, K.createSanitizer = ce, K._testOnlyClearSanitizerFactoryDoNotCallOrElse = ut;
+const Ot = (n, e) => n, M = globalThis;
+let Ye;
+M.litIssuedWarnings ??= /* @__PURE__ */ new Set(), Ye = (n, e) => {
+  e += ` See https://lit.dev/msg/${n} for more information.`, !M.litIssuedWarnings.has(e) && !M.litIssuedWarnings.has(n) && (console.warn(e), M.litIssuedWarnings.add(e));
+};
+class D extends C {
+  constructor() {
+    super(...arguments), this.renderOptions = { host: this }, this.__childPart = void 0;
+  }
+  /**
+   * @category rendering
+   */
+  createRenderRoot() {
+    const e = super.createRenderRoot();
+    return this.renderOptions.renderBefore ??= e.firstChild, e;
+  }
+  /**
+   * Updates the element. This method reflects property values to attributes
+   * and calls `render` to render DOM via lit-html. Setting properties inside
+   * this method will *not* trigger another update.
+   * @param changedProperties Map of changed properties with old values
+   * @category updates
+   */
+  update(e) {
+    const t = this.render();
+    this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(e), this.__childPart = K(t, this.renderRoot, this.renderOptions);
+  }
+  /**
+   * Invoked when the component is added to the document's DOM.
+   *
+   * In `connectedCallback()` you should setup tasks that should only occur when
+   * the element is connected to the document. The most common of these is
+   * adding event listeners to nodes external to the element, like a keydown
+   * event handler added to the window.
+   *
+   * ```ts
+   * connectedCallback() {
+   *   super.connectedCallback();
+   *   addEventListener('keydown', this._handleKeydown);
+   * }
+   * ```
+   *
+   * Typically, anything done in `connectedCallback()` should be undone when the
+   * element is disconnected, in `disconnectedCallback()`.
+   *
+   * @category lifecycle
+   */
+  connectedCallback() {
+    super.connectedCallback(), this.__childPart?.setConnected(!0);
+  }
+  /**
+   * Invoked when the component is removed from the document's DOM.
+   *
+   * This callback is the main signal to the element that it may no longer be
+   * used. `disconnectedCallback()` should ensure that nothing is holding a
+   * reference to the element (such as event listeners added to nodes external
+   * to the element), so that it is free to be garbage collected.
+   *
+   * ```ts
+   * disconnectedCallback() {
+   *   super.disconnectedCallback();
+   *   window.removeEventListener('keydown', this._handleKeydown);
+   * }
+   * ```
+   *
+   * An element may be re-connected after being disconnected.
+   *
+   * @category lifecycle
+   */
+  disconnectedCallback() {
+    super.disconnectedCallback(), this.__childPart?.setConnected(!1);
+  }
+  /**
+   * Invoked on each update to perform rendering tasks. This method may return
+   * any value renderable by lit-html's `ChildPart` - typically a
+   * `TemplateResult`. Setting properties inside this method will *not* trigger
+   * the element to update.
+   * @category rendering
+   */
+  render() {
+    return E;
+  }
+}
+D._$litElement$ = !0;
+D[Ot("finalized")] = !0;
+M.litElementHydrateSupport?.({ LitElement: D });
+const Vt = M.litElementPolyfillSupportDevMode;
+Vt?.({ LitElement: D });
+(M.litElementVersions ??= []).push("4.2.0");
+M.litElementVersions.length > 1 && queueMicrotask(() => {
+  Ye("multiple-versions", "Multiple versions of Lit loaded. Loading multiple versions is not recommended.");
+});
+const Lt = (n) => (e, t) => {
+  t !== void 0 ? t.addInitializer(() => {
+    customElements.define(n, e);
+  }) : customElements.define(n, e);
+};
+let Je;
+globalThis.litIssuedWarnings ??= /* @__PURE__ */ new Set(), Je = (n, e) => {
+  e += ` See https://lit.dev/msg/${n} for more information.`, !globalThis.litIssuedWarnings.has(e) && !globalThis.litIssuedWarnings.has(n) && (console.warn(e), globalThis.litIssuedWarnings.add(e));
+};
+const Dt = (n, e, t) => {
+  const i = e.hasOwnProperty(t);
+  return e.constructor.createProperty(t, n), i ? Object.getOwnPropertyDescriptor(e, t) : void 0;
+}, zt = {
+  attribute: !0,
+  type: String,
+  converter: G,
+  reflect: !1,
+  hasChanged: me
+}, It = (n = zt, e, t) => {
+  const { kind: i, metadata: s } = t;
+  s == null && Je("missing-class-metadata", `The class ${e} is missing decorator metadata. This could mean that you're using a compiler that supports decorators but doesn't support decorator metadata, such as TypeScript 5.1. Please update your compiler.`);
+  let r = globalThis.litPropertyMetadata.get(s);
+  if (r === void 0 && globalThis.litPropertyMetadata.set(s, r = /* @__PURE__ */ new Map()), i === "setter" && (n = Object.create(n), n.wrapped = !0), r.set(t.name, n), i === "accessor") {
+    const { name: o } = t;
+    return {
+      set(l) {
+        const a = e.get.call(this);
+        e.set.call(this, l), this.requestUpdate(o, a, n);
+      },
+      init(l) {
+        return l !== void 0 && this._$changeProperty(o, void 0, n, l), l;
+      }
+    };
+  } else if (i === "setter") {
+    const { name: o } = t;
+    return function(l) {
+      const a = this[o];
+      e.call(this, l), this.requestUpdate(o, a, n);
+    };
+  }
+  throw new Error(`Unsupported decorator location: ${i}`);
+};
+function te(n) {
+  return (e, t) => typeof t == "object" ? It(n, e, t) : Dt(n, e, t);
+}
+function z(n) {
+  return te({
+    ...n,
+    // Add both `state` and `attribute` because we found a third party
+    // controller that is keying off of PropertyOptions.state to determine
+    // whether a field is a private internal property or not.
+    state: !0,
+    attribute: !1
+  });
+}
+const Wt = (n, e, t) => (t.configurable = !0, t.enumerable = !0, // We check for Reflect.decorate each time, in case the zombiefill
+// is applied via lazy loading some Angular code.
+Reflect.decorate && typeof e != "object" && Object.defineProperty(n, e, t), t);
+globalThis.litIssuedWarnings ??= /* @__PURE__ */ new Set();
+function Ht(n, e) {
+  return ((t, i, s) => {
+    const r = (o) => o.renderRoot?.querySelector(n) ?? null;
+    return Wt(t, i, {
+      get() {
+        return r(this);
+      }
+    });
+  });
+}
+const be = {
   ATTRIBUTE: 1,
   CHILD: 2
-}, ae = (o) => (...e) => ({
+}, $e = (n) => (...e) => ({
   // This property needs to remain unminified.
-  _$litDirective$: o,
+  _$litDirective$: n,
   values: e
 });
-class le {
+class we {
   constructor(e) {
   }
   // See comment in Disconnectable interface for why this is a getter
@@ -536,10 +1443,10 @@ class le {
     return this.render(...t);
   }
 }
-const Le = "important", Me = " !" + Le, it = 0 - Me.length;
-class st extends le {
+const Qe = "important", Ze = " !" + Qe, jt = 0 - Ze.length;
+class Bt extends we {
   constructor(e) {
-    if (super(e), e.type !== re.ATTRIBUTE || e.name !== "style" || e.strings?.length > 2)
+    if (super(e), e.type !== be.ATTRIBUTE || e.name !== "style" || e.strings?.length > 2)
       throw new Error("The `styleMap` directive must be used in the `style` attribute and must be the only part in the attribute.");
   }
   render(e) {
@@ -555,27 +1462,27 @@ class st extends le {
     for (const s of this._previousStyleProperties)
       t[s] == null && (this._previousStyleProperties.delete(s), s.includes("-") ? i.removeProperty(s) : i[s] = null);
     for (const s in t) {
-      const n = t[s];
-      if (n != null) {
+      const r = t[s];
+      if (r != null) {
         this._previousStyleProperties.add(s);
-        const r = typeof n == "string" && n.endsWith(Me);
-        s.includes("-") || r ? i.setProperty(s, r ? n.slice(0, it) : n, r ? Le : "") : i[s] = n;
+        const o = typeof r == "string" && r.endsWith(Ze);
+        s.includes("-") || o ? i.setProperty(s, o ? r.slice(0, jt) : r, o ? Qe : "") : i[s] = r;
       }
     }
-    return N;
+    return E;
   }
 }
-const q = ae(st);
-const nt = 1;
-class de extends le {
+const ae = $e(Bt);
+const Ft = 1;
+class Se extends we {
   constructor(e) {
-    if (super(e), this._value = _, e.type !== re.CHILD)
+    if (super(e), this._value = m, e.type !== be.CHILD)
       throw new Error(`${this.constructor.directiveName}() can only be used in child bindings`);
   }
   render(e) {
-    if (e === _ || e == null)
+    if (e === m || e == null)
       return this._templateResult = void 0, this._value = e;
-    if (e === N)
+    if (e === E)
       return e;
     if (typeof e != "string")
       throw new Error(`${this.constructor.directiveName}() called with a non-string value`);
@@ -593,127 +1500,127 @@ class de extends le {
     };
   }
 }
-de.directiveName = "unsafeHTML";
-de.resultType = nt;
-const ot = 2;
-class ce extends de {
+Se.directiveName = "unsafeHTML";
+Se.resultType = Ft;
+const qt = 2;
+class ve extends Se {
 }
-ce.directiveName = "unsafeSVG";
-ce.resultType = ot;
-const rt = ae(ce);
-const { _ChildPart: at } = et, T = window.ShadyDOM?.inUse && window.ShadyDOM?.noPatch === !0 ? window.ShadyDOM.wrap : (o) => o, xe = () => document.createComment(""), k = (o, e, t) => {
-  const i = T(o._$startNode).parentNode, s = e === void 0 ? o._$endNode : e._$startNode;
+ve.directiveName = "unsafeSVG";
+ve.resultType = qt;
+const Kt = $e(ve);
+const { _ChildPart: Gt } = Rt, T = window.ShadyDOM?.inUse && window.ShadyDOM?.noPatch === !0 ? window.ShadyDOM.wrap : (n) => n, ze = () => document.createComment(""), W = (n, e, t) => {
+  const i = T(n._$startNode).parentNode, s = e === void 0 ? n._$endNode : e._$startNode;
   if (t === void 0) {
-    const n = T(i).insertBefore(xe(), s), r = T(i).insertBefore(xe(), s);
-    t = new at(n, r, o, o.options);
+    const r = T(i).insertBefore(ze(), s), o = T(i).insertBefore(ze(), s);
+    t = new Gt(r, o, n, n.options);
   } else {
-    const n = T(t._$endNode).nextSibling, r = t._$parent, h = r !== o;
-    if (h) {
-      t._$reparentDisconnectables?.(o), t._$parent = o;
+    const r = T(t._$endNode).nextSibling, o = t._$parent, l = o !== n;
+    if (l) {
+      t._$reparentDisconnectables?.(n), t._$parent = n;
       let a;
-      t._$notifyConnectionChanged !== void 0 && (a = o._$isConnected) !== r._$isConnected && t._$notifyConnectionChanged(a);
+      t._$notifyConnectionChanged !== void 0 && (a = n._$isConnected) !== o._$isConnected && t._$notifyConnectionChanged(a);
     }
-    if (n !== s || h) {
+    if (r !== s || l) {
       let a = t._$startNode;
-      for (; a !== n; ) {
-        const c = T(a).nextSibling;
-        T(i).insertBefore(a, s), a = c;
+      for (; a !== r; ) {
+        const h = T(a).nextSibling;
+        T(i).insertBefore(a, s), a = h;
       }
     }
   }
   return t;
-}, E = (o, e, t = o) => (o._$setValue(e, t), o), lt = {}, dt = (o, e = lt) => o._$committedValue = e, ct = (o) => o._$committedValue, Q = (o) => {
-  o._$notifyConnectionChanged?.(!1, !0);
-  let e = o._$startNode;
-  const t = T(o._$endNode).nextSibling;
+}, A = (n, e, t = n) => (n._$setValue(e, t), n), Yt = {}, Jt = (n, e = Yt) => n._$committedValue = e, Qt = (n) => n._$committedValue, le = (n) => {
+  n._$notifyConnectionChanged?.(!1, !0);
+  let e = n._$startNode;
+  const t = T(n._$endNode).nextSibling;
   for (; e !== t; ) {
     const i = T(e).nextSibling;
     T(e).remove(), e = i;
   }
 };
-const we = (o, e, t) => {
+const Ie = (n, e, t) => {
   const i = /* @__PURE__ */ new Map();
   for (let s = e; s <= t; s++)
-    i.set(o[s], s);
+    i.set(n[s], s);
   return i;
 };
-class ht extends le {
+class Zt extends we {
   constructor(e) {
-    if (super(e), e.type !== re.CHILD)
+    if (super(e), e.type !== be.CHILD)
       throw new Error("repeat() can only be used in text expressions");
   }
   _getValuesAndKeys(e, t, i) {
     let s;
     i === void 0 ? i = t : t !== void 0 && (s = t);
-    const n = [], r = [];
-    let h = 0;
+    const r = [], o = [];
+    let l = 0;
     for (const a of e)
-      n[h] = s ? s(a, h) : h, r[h] = i(a, h), h++;
+      r[l] = s ? s(a, l) : l, o[l] = i(a, l), l++;
     return {
-      values: r,
-      keys: n
+      values: o,
+      keys: r
     };
   }
   render(e, t, i) {
     return this._getValuesAndKeys(e, t, i).values;
   }
   update(e, [t, i, s]) {
-    const n = ct(e), { values: r, keys: h } = this._getValuesAndKeys(t, i, s);
-    if (!Array.isArray(n))
-      return this._itemKeys = h, r;
-    const a = this._itemKeys ??= [], c = [];
-    let f, m, d = 0, l = n.length - 1, p = 0, g = r.length - 1;
-    for (; d <= l && p <= g; )
-      if (n[d] === null)
-        d++;
-      else if (n[l] === null)
-        l--;
-      else if (a[d] === h[p])
-        c[p] = E(n[d], r[p]), d++, p++;
-      else if (a[l] === h[g])
-        c[g] = E(n[l], r[g]), l--, g--;
-      else if (a[d] === h[g])
-        c[g] = E(n[d], r[g]), k(e, c[g + 1], n[d]), d++, g--;
-      else if (a[l] === h[p])
-        c[p] = E(n[l], r[p]), k(e, n[d], n[l]), l--, p++;
-      else if (f === void 0 && (f = we(h, p, g), m = we(a, d, l)), !f.has(a[d]))
-        Q(n[d]), d++;
-      else if (!f.has(a[l]))
-        Q(n[l]), l--;
+    const r = Qt(e), { values: o, keys: l } = this._getValuesAndKeys(t, i, s);
+    if (!Array.isArray(r))
+      return this._itemKeys = l, o;
+    const a = this._itemKeys ??= [], h = [];
+    let g, p, c = 0, d = r.length - 1, f = 0, _ = o.length - 1;
+    for (; c <= d && f <= _; )
+      if (r[c] === null)
+        c++;
+      else if (r[d] === null)
+        d--;
+      else if (a[c] === l[f])
+        h[f] = A(r[c], o[f]), c++, f++;
+      else if (a[d] === l[_])
+        h[_] = A(r[d], o[_]), d--, _--;
+      else if (a[c] === l[_])
+        h[_] = A(r[c], o[_]), W(e, h[_ + 1], r[c]), c++, _--;
+      else if (a[d] === l[f])
+        h[f] = A(r[d], o[f]), W(e, r[c], r[d]), d--, f++;
+      else if (g === void 0 && (g = Ie(l, f, _), p = Ie(a, c, d)), !g.has(a[c]))
+        le(r[c]), c++;
+      else if (!g.has(a[d]))
+        le(r[d]), d--;
       else {
-        const w = m.get(h[p]), F = w !== void 0 ? n[w] : null;
-        if (F === null) {
-          const me = k(e, n[d]);
-          E(me, r[p]), c[p] = me;
+        const P = p.get(l[f]), ie = P !== void 0 ? r[P] : null;
+        if (ie === null) {
+          const xe = W(e, r[c]);
+          A(xe, o[f]), h[f] = xe;
         } else
-          c[p] = E(F, r[p]), k(e, n[d], F), n[w] = null;
-        p++;
+          h[f] = A(ie, o[f]), W(e, r[c], ie), r[P] = null;
+        f++;
       }
-    for (; p <= g; ) {
-      const w = k(e, c[g + 1]);
-      E(w, r[p]), c[p++] = w;
+    for (; f <= _; ) {
+      const P = W(e, h[_ + 1]);
+      A(P, o[f]), h[f++] = P;
     }
-    for (; d <= l; ) {
-      const w = n[d++];
-      w !== null && Q(w);
+    for (; c <= d; ) {
+      const P = r[c++];
+      P !== null && le(P);
     }
-    return this._itemKeys = h, dt(e, c), N;
+    return this._itemKeys = l, Jt(e, h), E;
   }
 }
-const X = ae(ht);
-var mt = Object.defineProperty, pt = Object.getOwnPropertyDescriptor, Pe = (o, e, t, i) => {
-  for (var s = i > 1 ? void 0 : i ? pt(e, t) : e, n = o.length - 1, r; n >= 0; n--)
-    (r = o[n]) && (s = (i ? r(e, t, s) : r(s)) || s);
-  return i && s && mt(e, t, s), s;
+const de = $e(Zt);
+var Xt = Object.defineProperty, ei = Object.getOwnPropertyDescriptor, Xe = (n, e, t, i) => {
+  for (var s = i > 1 ? void 0 : i ? ei(e, t) : e, r = n.length - 1, o; r >= 0; r--)
+    (o = n[r]) && (s = (i ? o(e, t, s) : o(s)) || s);
+  return i && s && Xt(e, t, s), s;
 };
-let B = class extends Te {
+let Q = class extends D {
   render() {
     return y`
             ${this.value !== void 0 ? y`<div class="bar" style="width: ${this.value * 100}%;"></div>` : y`<div class="indeterminate"></div>`}
         `;
   }
 };
-B.styles = ve`
+Q.styles = He`
         :host {
             display: inline-block;
             width: var(--progress-width, 200px);
@@ -755,20 +1662,20 @@ B.styles = ve`
             }
         }
     `;
-Pe([
+Xe([
   te({ type: Number })
-], B.prototype, "value", 2);
-B = Pe([
-  Re("linear-progress")
-], B);
-var ut = Object.defineProperty, C = (o, e, t, i) => {
-  for (var s = void 0, n = o.length - 1, r; n >= 0; n--)
-    (r = o[n]) && (s = r(e, t, s) || s);
-  return s && ut(e, t, s), s;
+], Q.prototype, "value", 2);
+Q = Xe([
+  Lt("linear-progress")
+], Q);
+var ti = Object.defineProperty, N = (n, e, t, i) => {
+  for (var s = void 0, r = n.length - 1, o; r >= 0; r--)
+    (o = n[r]) && (s = o(e, t, s) || s);
+  return s && ti(e, t, s), s;
 };
-const he = class he extends Te {
+const Pe = class Pe extends D {
   constructor() {
-    super(), this.version = "1.0.7", this.getModifier = this.getModifier.bind(this);
+    super(), this.version = "1.0.9", this.getModifier = this.getModifier.bind(this);
   }
   update(e) {
     e.has("inputData") && (this.transform(), this.modifier || this.getModifier()), e.has("theme") && this.registerTheme(this.theme), super.update(e);
@@ -833,20 +1740,20 @@ const he = class he extends Te {
     if (this.baseLayer instanceof HTMLImageElement)
       i = this.baseLayer.naturalWidth, s = this.baseLayer.naturalHeight;
     else {
-      const d = this.baseLayer.querySelector("svg");
-      if (d) {
-        const l = d.viewBox.baseVal;
-        if (console.log(l), l && l.width > 0 && l.height > 0)
-          i = l.width, s = l.height;
+      const c = this.baseLayer.querySelector("svg");
+      if (c) {
+        const d = c.viewBox.baseVal;
+        if (console.log(d), d && d.width > 0 && d.height > 0)
+          i = d.width, s = d.height;
         else {
-          const p = this.baseLayer.getAttribute("width"), g = this.baseLayer.getAttribute("height");
-          p && g && (i = parseFloat(p), s = parseFloat(g));
+          const f = this.baseLayer.getAttribute("width"), _ = this.baseLayer.getAttribute("height");
+          f && _ && (i = parseFloat(f), s = parseFloat(_));
         }
       }
     }
     if (!i || !s) return;
-    const n = e.width / i, r = e.height / s, h = Math.min(n, r), a = i * h, c = s * h, f = (t.width - a) / 2, m = (t.height - c) / 2;
-    this.modifier = { scaler: h, xOffset: f, yOffset: m, visibleWidth: a, visibleHeight: c };
+    const r = e.width / i, o = e.height / s, l = Math.min(r, o), a = i * l, h = s * l, g = (t.width - a) / 2, p = (t.height - h) / 2;
+    this.modifier = { scaler: l, xOffset: g, yOffset: p, visibleWidth: a, visibleHeight: h };
   }
   getOverlayItemPosition(e, t, i) {
     return {
@@ -855,53 +1762,53 @@ const he = class he extends Te {
     };
   }
   renderText(e, t, i) {
-    const s = e, n = this.getOverlayItemPosition(t.relXPos, t.relYPos, i);
-    if (!n) return P;
-    const r = s.textStyle?.precision ?? 1;
-    let h = t.data;
-    const a = Number(h);
-    let c = "#333";
-    if (!Number.isNaN(a) && typeof r == "number" && r >= 0) {
-      h = a.toFixed(r);
-      const m = s.sections?.sectionLimits.findIndex((d) => a <= d) ?? -2;
-      c = (m >= 1 ? s.sections?.colors[m - 1] : "#333") ?? "#333";
+    const s = e, r = this.getOverlayItemPosition(t.relXPos, t.relYPos, i);
+    if (!r) return m;
+    const o = s.textStyle?.precision ?? 1;
+    let l = t.data;
+    const a = Number(l);
+    let h = "#333";
+    if (!Number.isNaN(a) && typeof o == "number" && o >= 0) {
+      l = a.toFixed(o);
+      const p = s.sections?.sectionLimits.findIndex((c) => a <= c) ?? -2;
+      h = (p >= 1 ? s.sections?.colors[p - 1] : "#333") ?? "#333";
     }
-    const f = {
+    const g = {
       "font-size": (s.textStyle.fontSize ?? 14) * i.scaler + "px",
-      color: c,
+      color: h,
       "background-color": s.textStyle.backgroundColor,
       "font-weight": s.textStyle.fontWeight,
-      left: `${n.left}px`,
-      top: `${n.top}px`,
+      left: `${r.left}px`,
+      top: `${r.top}px`,
       "border-radius": 10 * i.scaler + "px",
       "transform-origin": "50% 50%",
       transform: "translate(-50%, -50%)",
       padding: `${6 * i.scaler}px ${12 * i.scaler}px`
     };
     return y`
-            <div class="overlay-item" style=${q(f)}>${t.prefix}${h}${t.suffix}</div>
+            <div class="overlay-item" style=${ae(g)}>${t.prefix}${l}${t.suffix}</div>
         `;
   }
   renderProgress(e, t, i) {
-    const s = e, n = this.getOverlayItemPosition(t.relXPos, t.relYPos, i);
-    if (!n) return P;
-    const r = s.sections?.sectionLimits.findIndex((p) => Number(t.data) <= p) ?? -2, a = {
-      "--progress-color": (r >= 1 ? s.sections?.colors[r - 1] : void 0) ?? "#333",
+    const s = e, r = this.getOverlayItemPosition(t.relXPos, t.relYPos, i);
+    if (!r) return m;
+    const o = s.sections?.sectionLimits.findIndex((f) => Number(t.data) <= f) ?? -2, a = {
+      "--progress-color": (o >= 1 ? s.sections?.colors[o - 1] : void 0) ?? "#333",
       "--progress-width": (s.progressStyle?.width ?? 10) * i.scaler + "px",
       "--progress-height": (s.progressStyle?.height ?? 100) * i.scaler + "px",
       "--progress-background": s.progressStyle?.backgroundColor ?? "#fff",
       "border-radius": 10 * i.scaler + "px",
       "transform-origin": "50% 50%",
       transform: `translate(-50%, -50%) rotate(${s.progressStyle?.rotate ?? 0}deg)`,
-      left: `${n.left}px`,
-      top: `${n.top}px`
-    }, c = Number(t.data), f = s.sections ?? {}, m = Math.min(...f.sectionLimits.map(Number)), d = Math.max(...f.sectionLimits.map(Number));
-    let l = d === m ? 0 : (c - m) / (d - m);
-    return l = Math.min(1, Math.max(0, l)), y` <linear-progress .value=${l} style=${q(a)}></linear-progress> `;
+      left: `${r.left}px`,
+      top: `${r.top}px`
+    }, h = Number(t.data), g = s.sections ?? {}, p = Math.min(...g.sectionLimits.map(Number)), c = Math.max(...g.sectionLimits.map(Number));
+    let d = c === p ? 0 : (h - p) / (c - p);
+    return d = Math.min(1, Math.max(0, d)), y` <linear-progress .value=${d} style=${ae(a)}></linear-progress> `;
   }
   renderLayer(e) {
     const t = this.modifier;
-    if (!t) return P;
+    if (!t) return m;
     const i = {
       left: t.xOffset + "px",
       top: t.yOffset + "px",
@@ -910,7 +1817,7 @@ const he = class he extends Te {
     };
     return y`<div
             class="overlay"
-            style=${q(i)}
+            style=${ae(i)}
             type="${e.layerType}"
             name="${e.layerName}"
         >
@@ -919,19 +1826,19 @@ const he = class he extends Te {
   }
   renderTextLayer(e) {
     const t = this.modifier;
-    return t ? y`${X(
+    return t ? y`${de(
       e.textPins ?? [],
       (i, s) => s,
       (i) => y`${this.renderText(e, i, t)}`
-    )}` : P;
+    )}` : m;
   }
   renderProgressLayer(e) {
     const t = this.modifier;
-    return t ? y`${X(
+    return t ? y`${de(
       e.progressPins ?? [],
       (i, s) => s,
       (i) => y`${this.renderProgress(e, i, t)}`
-    )}` : P;
+    )}` : m;
   }
   render() {
     const e = !!this.inlineSvg || !!this.previewUrl;
@@ -950,14 +1857,14 @@ const he = class he extends Te {
 
                 <div class="paging no-data" ?active=${!e}>No Image</div>
                 <div class="img-container paging" ?active="${e}">
-                    ${this.inlineSvg ? y`<div id="base-layer" class="svg-wrapper">${rt(this.inlineSvg)}</div>` : this.previewUrl ? y`<img
+                    ${this.inlineSvg ? y`<div id="base-layer" class="svg-wrapper">${Kt(this.inlineSvg)}</div>` : this.previewUrl ? y`<img
                                 id="base-layer"
                                 @load="${this.getModifier}"
                                 src="${this.previewUrl}"
                                 alt="Image Widget"
                                 style="object-fit: ${this.inputData?.stretchToFit ? "fill" : "contain"}"
                             />` : ""}
-                    ${X(
+                    ${de(
       this.inputData?.overlays ?? [],
       (t) => t.layerName,
       (t) => y` ${this.renderLayer(t)} `
@@ -967,12 +1874,13 @@ const he = class he extends Te {
         `;
   }
 };
-he.styles = ve`
+Pe.styles = He`
         :host {
             display: block;
             font-family: sans-serif;
             box-sizing: border-box;
             margin: auto;
+            container-type: size;
         }
 
         .paging:not([active]) {
@@ -984,7 +1892,7 @@ he.styles = ve`
             flex-direction: column;
             height: 100%;
             width: 100%;
-            padding: 2%;
+            padding: 2cqh 2cqw;
             box-sizing: border-box;
         }
 
@@ -1050,36 +1958,36 @@ he.styles = ve`
             pointer-events: auto;
         }
     `;
-let b = he;
-C([
+let w = Pe;
+N([
   te({ type: Object })
-], b.prototype, "inputData");
-C([
+], w.prototype, "inputData");
+N([
   te({ type: Object })
-], b.prototype, "theme");
-C([
-  M()
-], b.prototype, "themeBgColor");
-C([
-  M()
-], b.prototype, "themeTitleColor");
-C([
-  M()
-], b.prototype, "themeSubtitleColor");
-C([
-  M()
-], b.prototype, "previewUrl");
-C([
-  M()
-], b.prototype, "inlineSvg");
-C([
-  M()
-], b.prototype, "modifier");
-C([
-  ke("#base-layer")
-], b.prototype, "baseLayer");
-window.customElements.define("widget-overlay-1.0.7", b);
+], w.prototype, "theme");
+N([
+  z()
+], w.prototype, "themeBgColor");
+N([
+  z()
+], w.prototype, "themeTitleColor");
+N([
+  z()
+], w.prototype, "themeSubtitleColor");
+N([
+  z()
+], w.prototype, "previewUrl");
+N([
+  z()
+], w.prototype, "inlineSvg");
+N([
+  z()
+], w.prototype, "modifier");
+N([
+  Ht("#base-layer")
+], w.prototype, "baseLayer");
+window.customElements.define("widget-overlay-1.0.9", w);
 export {
-  b as WidgetImage
+  w as WidgetImage
 };
 //# sourceMappingURL=widget-overlay.js.map