placer-toolkit 0.5.1 → 1.0.0-alpha.2

package/dist/components/dropdown/dropdown.js

@@ -1,5 +1,3757 @@
-import { PcDropdown as PcDropdown$1 } from './dropdown.component.js';
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i7 = decorators.length - 1, decorator; i7 >= 0; i7--)
+    if (decorator = decorators[i7])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
 
-var PcDropdown = PcDropdown$1;
+// node_modules/@lit/reactive-element/css-tag.js
+var t = globalThis;
+var e = t.ShadowRoot && (void 0 === t.ShadyCSS || t.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype;
+var s = Symbol();
+var o = /* @__PURE__ */ new WeakMap();
+var n = class {
+  constructor(t5, e9, o6) {
+    if (this._$cssResult$ = true, o6 !== s) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
+    this.cssText = t5, this.t = e9;
+  }
+  get styleSheet() {
+    let t5 = this.o;
+    const s4 = this.t;
+    if (e && void 0 === t5) {
+      const e9 = void 0 !== s4 && 1 === s4.length;
+      e9 && (t5 = o.get(s4)), void 0 === t5 && ((this.o = t5 = new CSSStyleSheet()).replaceSync(this.cssText), e9 && o.set(s4, t5));
+    }
+    return t5;
+  }
+  toString() {
+    return this.cssText;
+  }
+};
+var r = (t5) => new n("string" == typeof t5 ? t5 : t5 + "", void 0, s);
+var S = (s4, o6) => {
+  if (e) s4.adoptedStyleSheets = o6.map(((t5) => t5 instanceof CSSStyleSheet ? t5 : t5.styleSheet));
+  else for (const e9 of o6) {
+    const o7 = document.createElement("style"), n5 = t.litNonce;
+    void 0 !== n5 && o7.setAttribute("nonce", n5), o7.textContent = e9.cssText, s4.appendChild(o7);
+  }
+};
+var c = e ? (t5) => t5 : (t5) => t5 instanceof CSSStyleSheet ? ((t6) => {
+  let e9 = "";
+  for (const s4 of t6.cssRules) e9 += s4.cssText;
+  return r(e9);
+})(t5) : t5;
 
-export { PcDropdown$1 as PcDropdown, PcDropdown as default };
+// node_modules/@lit/reactive-element/reactive-element.js
+var { is: i2, defineProperty: e2, getOwnPropertyDescriptor: h, getOwnPropertyNames: r2, getOwnPropertySymbols: o2, getPrototypeOf: n2 } = Object;
+var a = globalThis;
+var c2 = a.trustedTypes;
+var l = c2 ? c2.emptyScript : "";
+var p = a.reactiveElementPolyfillSupport;
+var d = (t5, s4) => t5;
+var u = { toAttribute(t5, s4) {
+  switch (s4) {
+    case Boolean:
+      t5 = t5 ? l : null;
+      break;
+    case Object:
+    case Array:
+      t5 = null == t5 ? t5 : JSON.stringify(t5);
+  }
+  return t5;
+}, fromAttribute(t5, s4) {
+  let i7 = t5;
+  switch (s4) {
+    case Boolean:
+      i7 = null !== t5;
+      break;
+    case Number:
+      i7 = null === t5 ? null : Number(t5);
+      break;
+    case Object:
+    case Array:
+      try {
+        i7 = JSON.parse(t5);
+      } catch (t6) {
+        i7 = null;
+      }
+  }
+  return i7;
+} };
+var f = (t5, s4) => !i2(t5, s4);
+var b = { attribute: true, type: String, converter: u, reflect: false, useDefault: false, hasChanged: f };
+Symbol.metadata ?? (Symbol.metadata = Symbol("metadata")), a.litPropertyMetadata ?? (a.litPropertyMetadata = /* @__PURE__ */ new WeakMap());
+var y = class extends HTMLElement {
+  static addInitializer(t5) {
+    this._$Ei(), (this.l ?? (this.l = [])).push(t5);
+  }
+  static get observedAttributes() {
+    return this.finalize(), this._$Eh && [...this._$Eh.keys()];
+  }
+  static createProperty(t5, s4 = b) {
+    if (s4.state && (s4.attribute = false), this._$Ei(), this.prototype.hasOwnProperty(t5) && ((s4 = Object.create(s4)).wrapped = true), this.elementProperties.set(t5, s4), !s4.noAccessor) {
+      const i7 = Symbol(), h3 = this.getPropertyDescriptor(t5, i7, s4);
+      void 0 !== h3 && e2(this.prototype, t5, h3);
+    }
+  }
+  static getPropertyDescriptor(t5, s4, i7) {
+    const { get: e9, set: r6 } = h(this.prototype, t5) ?? { get() {
+      return this[s4];
+    }, set(t6) {
+      this[s4] = t6;
+    } };
+    return { get: e9, set(s5) {
+      const h3 = e9?.call(this);
+      r6?.call(this, s5), this.requestUpdate(t5, h3, i7);
+    }, configurable: true, enumerable: true };
+  }
+  static getPropertyOptions(t5) {
+    return this.elementProperties.get(t5) ?? b;
+  }
+  static _$Ei() {
+    if (this.hasOwnProperty(d("elementProperties"))) return;
+    const t5 = n2(this);
+    t5.finalize(), void 0 !== t5.l && (this.l = [...t5.l]), this.elementProperties = new Map(t5.elementProperties);
+  }
+  static finalize() {
+    if (this.hasOwnProperty(d("finalized"))) return;
+    if (this.finalized = true, this._$Ei(), this.hasOwnProperty(d("properties"))) {
+      const t6 = this.properties, s4 = [...r2(t6), ...o2(t6)];
+      for (const i7 of s4) this.createProperty(i7, t6[i7]);
+    }
+    const t5 = this[Symbol.metadata];
+    if (null !== t5) {
+      const s4 = litPropertyMetadata.get(t5);
+      if (void 0 !== s4) for (const [t6, i7] of s4) this.elementProperties.set(t6, i7);
+    }
+    this._$Eh = /* @__PURE__ */ new Map();
+    for (const [t6, s4] of this.elementProperties) {
+      const i7 = this._$Eu(t6, s4);
+      void 0 !== i7 && this._$Eh.set(i7, t6);
+    }
+    this.elementStyles = this.finalizeStyles(this.styles);
+  }
+  static finalizeStyles(s4) {
+    const i7 = [];
+    if (Array.isArray(s4)) {
+      const e9 = new Set(s4.flat(1 / 0).reverse());
+      for (const s5 of e9) i7.unshift(c(s5));
+    } else void 0 !== s4 && i7.push(c(s4));
+    return i7;
+  }
+  static _$Eu(t5, s4) {
+    const i7 = s4.attribute;
+    return false === i7 ? void 0 : "string" == typeof i7 ? i7 : "string" == typeof t5 ? t5.toLowerCase() : void 0;
+  }
+  constructor() {
+    super(), this._$Ep = void 0, this.isUpdatePending = false, this.hasUpdated = false, this._$Em = null, this._$Ev();
+  }
+  _$Ev() {
+    this._$ES = new Promise(((t5) => this.enableUpdating = t5)), this._$AL = /* @__PURE__ */ new Map(), this._$E_(), this.requestUpdate(), this.constructor.l?.forEach(((t5) => t5(this)));
+  }
+  addController(t5) {
+    (this._$EO ?? (this._$EO = /* @__PURE__ */ new Set())).add(t5), void 0 !== this.renderRoot && this.isConnected && t5.hostConnected?.();
+  }
+  removeController(t5) {
+    this._$EO?.delete(t5);
+  }
+  _$E_() {
+    const t5 = /* @__PURE__ */ new Map(), s4 = this.constructor.elementProperties;
+    for (const i7 of s4.keys()) this.hasOwnProperty(i7) && (t5.set(i7, this[i7]), delete this[i7]);
+    t5.size > 0 && (this._$Ep = t5);
+  }
+  createRenderRoot() {
+    const t5 = this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions);
+    return S(t5, this.constructor.elementStyles), t5;
+  }
+  connectedCallback() {
+    this.renderRoot ?? (this.renderRoot = this.createRenderRoot()), this.enableUpdating(true), this._$EO?.forEach(((t5) => t5.hostConnected?.()));
+  }
+  enableUpdating(t5) {
+  }
+  disconnectedCallback() {
+    this._$EO?.forEach(((t5) => t5.hostDisconnected?.()));
+  }
+  attributeChangedCallback(t5, s4, i7) {
+    this._$AK(t5, i7);
+  }
+  _$ET(t5, s4) {
+    const i7 = this.constructor.elementProperties.get(t5), e9 = this.constructor._$Eu(t5, i7);
+    if (void 0 !== e9 && true === i7.reflect) {
+      const h3 = (void 0 !== i7.converter?.toAttribute ? i7.converter : u).toAttribute(s4, i7.type);
+      this._$Em = t5, null == h3 ? this.removeAttribute(e9) : this.setAttribute(e9, h3), this._$Em = null;
+    }
+  }
+  _$AK(t5, s4) {
+    const i7 = this.constructor, e9 = i7._$Eh.get(t5);
+    if (void 0 !== e9 && this._$Em !== e9) {
+      const t6 = i7.getPropertyOptions(e9), h3 = "function" == typeof t6.converter ? { fromAttribute: t6.converter } : void 0 !== t6.converter?.fromAttribute ? t6.converter : u;
+      this._$Em = e9, this[e9] = h3.fromAttribute(s4, t6.type) ?? this._$Ej?.get(e9) ?? null, this._$Em = null;
+    }
+  }
+  requestUpdate(t5, s4, i7) {
+    if (void 0 !== t5) {
+      const e9 = this.constructor, h3 = this[t5];
+      if (i7 ?? (i7 = e9.getPropertyOptions(t5)), !((i7.hasChanged ?? f)(h3, s4) || i7.useDefault && i7.reflect && h3 === this._$Ej?.get(t5) && !this.hasAttribute(e9._$Eu(t5, i7)))) return;
+      this.C(t5, s4, i7);
+    }
+    false === this.isUpdatePending && (this._$ES = this._$EP());
+  }
+  C(t5, s4, { useDefault: i7, reflect: e9, wrapped: h3 }, r6) {
+    i7 && !(this._$Ej ?? (this._$Ej = /* @__PURE__ */ new Map())).has(t5) && (this._$Ej.set(t5, r6 ?? s4 ?? this[t5]), true !== h3 || void 0 !== r6) || (this._$AL.has(t5) || (this.hasUpdated || i7 || (s4 = void 0), this._$AL.set(t5, s4)), true === e9 && this._$Em !== t5 && (this._$Eq ?? (this._$Eq = /* @__PURE__ */ new Set())).add(t5));
+  }
+  async _$EP() {
+    this.isUpdatePending = true;
+    try {
+      await this._$ES;
+    } catch (t6) {
+      Promise.reject(t6);
+    }
+    const t5 = this.scheduleUpdate();
+    return null != t5 && await t5, !this.isUpdatePending;
+  }
+  scheduleUpdate() {
+    return this.performUpdate();
+  }
+  performUpdate() {
+    if (!this.isUpdatePending) return;
+    if (!this.hasUpdated) {
+      if (this.renderRoot ?? (this.renderRoot = this.createRenderRoot()), this._$Ep) {
+        for (const [t7, s5] of this._$Ep) this[t7] = s5;
+        this._$Ep = void 0;
+      }
+      const t6 = this.constructor.elementProperties;
+      if (t6.size > 0) for (const [s5, i7] of t6) {
+        const { wrapped: t7 } = i7, e9 = this[s5];
+        true !== t7 || this._$AL.has(s5) || void 0 === e9 || this.C(s5, void 0, i7, e9);
+      }
+    }
+    let t5 = false;
+    const s4 = this._$AL;
+    try {
+      t5 = this.shouldUpdate(s4), t5 ? (this.willUpdate(s4), this._$EO?.forEach(((t6) => t6.hostUpdate?.())), this.update(s4)) : this._$EM();
+    } catch (s5) {
+      throw t5 = false, this._$EM(), s5;
+    }
+    t5 && this._$AE(s4);
+  }
+  willUpdate(t5) {
+  }
+  _$AE(t5) {
+    this._$EO?.forEach(((t6) => t6.hostUpdated?.())), this.hasUpdated || (this.hasUpdated = true, this.firstUpdated(t5)), this.updated(t5);
+  }
+  _$EM() {
+    this._$AL = /* @__PURE__ */ new Map(), this.isUpdatePending = false;
+  }
+  get updateComplete() {
+    return this.getUpdateComplete();
+  }
+  getUpdateComplete() {
+    return this._$ES;
+  }
+  shouldUpdate(t5) {
+    return true;
+  }
+  update(t5) {
+    this._$Eq && (this._$Eq = this._$Eq.forEach(((t6) => this._$ET(t6, this[t6])))), this._$EM();
+  }
+  updated(t5) {
+  }
+  firstUpdated(t5) {
+  }
+};
+y.elementStyles = [], y.shadowRootOptions = { mode: "open" }, y[d("elementProperties")] = /* @__PURE__ */ new Map(), y[d("finalized")] = /* @__PURE__ */ new Map(), p?.({ ReactiveElement: y }), (a.reactiveElementVersions ?? (a.reactiveElementVersions = [])).push("2.1.0");
+
+// node_modules/lit-html/lit-html.js
+var t2 = globalThis;
+var i3 = t2.trustedTypes;
+var s2 = i3 ? i3.createPolicy("lit-html", { createHTML: (t5) => t5 }) : void 0;
+var e3 = "$lit$";
+var h2 = `lit$${Math.random().toFixed(9).slice(2)}$`;
+var o3 = "?" + h2;
+var n3 = `<${o3}>`;
+var r3 = document;
+var l2 = () => r3.createComment("");
+var c3 = (t5) => null === t5 || "object" != typeof t5 && "function" != typeof t5;
+var a2 = Array.isArray;
+var u2 = (t5) => a2(t5) || "function" == typeof t5?.[Symbol.iterator];
+var d2 = "[ 	\n\f\r]";
+var f2 = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g;
+var v = /-->/g;
+var _ = />/g;
+var m = RegExp(`>|${d2}(?:([^\\s"'>=/]+)(${d2}*=${d2}*(?:[^ 	
+\f\r"'\`<>=]|("|')|))|$)`, "g");
+var p2 = /'/g;
+var g = /"/g;
+var $ = /^(?:script|style|textarea|title)$/i;
+var y2 = (t5) => (i7, ...s4) => ({ _$litType$: t5, strings: i7, values: s4 });
+var x = y2(1);
+var b2 = y2(2);
+var w = y2(3);
+var T = Symbol.for("lit-noChange");
+var E = Symbol.for("lit-nothing");
+var A = /* @__PURE__ */ new WeakMap();
+var C = r3.createTreeWalker(r3, 129);
+function P(t5, i7) {
+  if (!a2(t5) || !t5.hasOwnProperty("raw")) throw Error("invalid template strings array");
+  return void 0 !== s2 ? s2.createHTML(i7) : i7;
+}
+var V = (t5, i7) => {
+  const s4 = t5.length - 1, o6 = [];
+  let r6, l3 = 2 === i7 ? "<svg>" : 3 === i7 ? "<math>" : "", c4 = f2;
+  for (let i8 = 0; i8 < s4; i8++) {
+    const s5 = t5[i8];
+    let a3, u3, d3 = -1, y3 = 0;
+    for (; y3 < s5.length && (c4.lastIndex = y3, u3 = c4.exec(s5), null !== u3); ) y3 = c4.lastIndex, c4 === f2 ? "!--" === u3[1] ? c4 = v : void 0 !== u3[1] ? c4 = _ : void 0 !== u3[2] ? ($.test(u3[2]) && (r6 = RegExp("</" + u3[2], "g")), c4 = m) : void 0 !== u3[3] && (c4 = m) : c4 === m ? ">" === u3[0] ? (c4 = r6 ?? f2, d3 = -1) : void 0 === u3[1] ? d3 = -2 : (d3 = c4.lastIndex - u3[2].length, a3 = u3[1], c4 = void 0 === u3[3] ? m : '"' === u3[3] ? g : p2) : c4 === g || c4 === p2 ? c4 = m : c4 === v || c4 === _ ? c4 = f2 : (c4 = m, r6 = void 0);
+    const x2 = c4 === m && t5[i8 + 1].startsWith("/>") ? " " : "";
+    l3 += c4 === f2 ? s5 + n3 : d3 >= 0 ? (o6.push(a3), s5.slice(0, d3) + e3 + s5.slice(d3) + h2 + x2) : s5 + h2 + (-2 === d3 ? i8 : x2);
+  }
+  return [P(t5, l3 + (t5[s4] || "<?>") + (2 === i7 ? "</svg>" : 3 === i7 ? "</math>" : "")), o6];
+};
+var N = class _N {
+  constructor({ strings: t5, _$litType$: s4 }, n5) {
+    let r6;
+    this.parts = [];
+    let c4 = 0, a3 = 0;
+    const u3 = t5.length - 1, d3 = this.parts, [f3, v2] = V(t5, s4);
+    if (this.el = _N.createElement(f3, n5), C.currentNode = this.el.content, 2 === s4 || 3 === s4) {
+      const t6 = this.el.content.firstChild;
+      t6.replaceWith(...t6.childNodes);
+    }
+    for (; null !== (r6 = C.nextNode()) && d3.length < u3; ) {
+      if (1 === r6.nodeType) {
+        if (r6.hasAttributes()) for (const t6 of r6.getAttributeNames()) if (t6.endsWith(e3)) {
+          const i7 = v2[a3++], s5 = r6.getAttribute(t6).split(h2), e9 = /([.?@])?(.*)/.exec(i7);
+          d3.push({ type: 1, index: c4, name: e9[2], strings: s5, ctor: "." === e9[1] ? H : "?" === e9[1] ? I : "@" === e9[1] ? L : k }), r6.removeAttribute(t6);
+        } else t6.startsWith(h2) && (d3.push({ type: 6, index: c4 }), r6.removeAttribute(t6));
+        if ($.test(r6.tagName)) {
+          const t6 = r6.textContent.split(h2), s5 = t6.length - 1;
+          if (s5 > 0) {
+            r6.textContent = i3 ? i3.emptyScript : "";
+            for (let i7 = 0; i7 < s5; i7++) r6.append(t6[i7], l2()), C.nextNode(), d3.push({ type: 2, index: ++c4 });
+            r6.append(t6[s5], l2());
+          }
+        }
+      } else if (8 === r6.nodeType) if (r6.data === o3) d3.push({ type: 2, index: c4 });
+      else {
+        let t6 = -1;
+        for (; -1 !== (t6 = r6.data.indexOf(h2, t6 + 1)); ) d3.push({ type: 7, index: c4 }), t6 += h2.length - 1;
+      }
+      c4++;
+    }
+  }
+  static createElement(t5, i7) {
+    const s4 = r3.createElement("template");
+    return s4.innerHTML = t5, s4;
+  }
+};
+function S2(t5, i7, s4 = t5, e9) {
+  if (i7 === T) return i7;
+  let h3 = void 0 !== e9 ? s4._$Co?.[e9] : s4._$Cl;
+  const o6 = c3(i7) ? void 0 : i7._$litDirective$;
+  return h3?.constructor !== o6 && (h3?._$AO?.(false), void 0 === o6 ? h3 = void 0 : (h3 = new o6(t5), h3._$AT(t5, s4, e9)), void 0 !== e9 ? (s4._$Co ?? (s4._$Co = []))[e9] = h3 : s4._$Cl = h3), void 0 !== h3 && (i7 = S2(t5, h3._$AS(t5, i7.values), h3, e9)), i7;
+}
+var M = class {
+  constructor(t5, i7) {
+    this._$AV = [], this._$AN = void 0, this._$AD = t5, this._$AM = i7;
+  }
+  get parentNode() {
+    return this._$AM.parentNode;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  u(t5) {
+    const { el: { content: i7 }, parts: s4 } = this._$AD, e9 = (t5?.creationScope ?? r3).importNode(i7, true);
+    C.currentNode = e9;
+    let h3 = C.nextNode(), o6 = 0, n5 = 0, l3 = s4[0];
+    for (; void 0 !== l3; ) {
+      if (o6 === l3.index) {
+        let i8;
+        2 === l3.type ? i8 = new R(h3, h3.nextSibling, this, t5) : 1 === l3.type ? i8 = new l3.ctor(h3, l3.name, l3.strings, this, t5) : 6 === l3.type && (i8 = new z(h3, this, t5)), this._$AV.push(i8), l3 = s4[++n5];
+      }
+      o6 !== l3?.index && (h3 = C.nextNode(), o6++);
+    }
+    return C.currentNode = r3, e9;
+  }
+  p(t5) {
+    let i7 = 0;
+    for (const s4 of this._$AV) void 0 !== s4 && (void 0 !== s4.strings ? (s4._$AI(t5, s4, i7), i7 += s4.strings.length - 2) : s4._$AI(t5[i7])), i7++;
+  }
+};
+var R = class _R {
+  get _$AU() {
+    return this._$AM?._$AU ?? this._$Cv;
+  }
+  constructor(t5, i7, s4, e9) {
+    this.type = 2, this._$AH = E, this._$AN = void 0, this._$AA = t5, this._$AB = i7, this._$AM = s4, this.options = e9, this._$Cv = e9?.isConnected ?? true;
+  }
+  get parentNode() {
+    let t5 = this._$AA.parentNode;
+    const i7 = this._$AM;
+    return void 0 !== i7 && 11 === t5?.nodeType && (t5 = i7.parentNode), t5;
+  }
+  get startNode() {
+    return this._$AA;
+  }
+  get endNode() {
+    return this._$AB;
+  }
+  _$AI(t5, i7 = this) {
+    t5 = S2(this, t5, i7), c3(t5) ? t5 === E || null == t5 || "" === t5 ? (this._$AH !== E && this._$AR(), this._$AH = E) : t5 !== this._$AH && t5 !== T && this._(t5) : void 0 !== t5._$litType$ ? this.$(t5) : void 0 !== t5.nodeType ? this.T(t5) : u2(t5) ? this.k(t5) : this._(t5);
+  }
+  O(t5) {
+    return this._$AA.parentNode.insertBefore(t5, this._$AB);
+  }
+  T(t5) {
+    this._$AH !== t5 && (this._$AR(), this._$AH = this.O(t5));
+  }
+  _(t5) {
+    this._$AH !== E && c3(this._$AH) ? this._$AA.nextSibling.data = t5 : this.T(r3.createTextNode(t5)), this._$AH = t5;
+  }
+  $(t5) {
+    const { values: i7, _$litType$: s4 } = t5, e9 = "number" == typeof s4 ? this._$AC(t5) : (void 0 === s4.el && (s4.el = N.createElement(P(s4.h, s4.h[0]), this.options)), s4);
+    if (this._$AH?._$AD === e9) this._$AH.p(i7);
+    else {
+      const t6 = new M(e9, this), s5 = t6.u(this.options);
+      t6.p(i7), this.T(s5), this._$AH = t6;
+    }
+  }
+  _$AC(t5) {
+    let i7 = A.get(t5.strings);
+    return void 0 === i7 && A.set(t5.strings, i7 = new N(t5)), i7;
+  }
+  k(t5) {
+    a2(this._$AH) || (this._$AH = [], this._$AR());
+    const i7 = this._$AH;
+    let s4, e9 = 0;
+    for (const h3 of t5) e9 === i7.length ? i7.push(s4 = new _R(this.O(l2()), this.O(l2()), this, this.options)) : s4 = i7[e9], s4._$AI(h3), e9++;
+    e9 < i7.length && (this._$AR(s4 && s4._$AB.nextSibling, e9), i7.length = e9);
+  }
+  _$AR(t5 = this._$AA.nextSibling, i7) {
+    for (this._$AP?.(false, true, i7); t5 && t5 !== this._$AB; ) {
+      const i8 = t5.nextSibling;
+      t5.remove(), t5 = i8;
+    }
+  }
+  setConnected(t5) {
+    void 0 === this._$AM && (this._$Cv = t5, this._$AP?.(t5));
+  }
+};
+var k = class {
+  get tagName() {
+    return this.element.tagName;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  constructor(t5, i7, s4, e9, h3) {
+    this.type = 1, this._$AH = E, this._$AN = void 0, this.element = t5, this.name = i7, this._$AM = e9, this.options = h3, s4.length > 2 || "" !== s4[0] || "" !== s4[1] ? (this._$AH = Array(s4.length - 1).fill(new String()), this.strings = s4) : this._$AH = E;
+  }
+  _$AI(t5, i7 = this, s4, e9) {
+    const h3 = this.strings;
+    let o6 = false;
+    if (void 0 === h3) t5 = S2(this, t5, i7, 0), o6 = !c3(t5) || t5 !== this._$AH && t5 !== T, o6 && (this._$AH = t5);
+    else {
+      const e10 = t5;
+      let n5, r6;
+      for (t5 = h3[0], n5 = 0; n5 < h3.length - 1; n5++) r6 = S2(this, e10[s4 + n5], i7, n5), r6 === T && (r6 = this._$AH[n5]), o6 || (o6 = !c3(r6) || r6 !== this._$AH[n5]), r6 === E ? t5 = E : t5 !== E && (t5 += (r6 ?? "") + h3[n5 + 1]), this._$AH[n5] = r6;
+    }
+    o6 && !e9 && this.j(t5);
+  }
+  j(t5) {
+    t5 === E ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, t5 ?? "");
+  }
+};
+var H = class extends k {
+  constructor() {
+    super(...arguments), this.type = 3;
+  }
+  j(t5) {
+    this.element[this.name] = t5 === E ? void 0 : t5;
+  }
+};
+var I = class extends k {
+  constructor() {
+    super(...arguments), this.type = 4;
+  }
+  j(t5) {
+    this.element.toggleAttribute(this.name, !!t5 && t5 !== E);
+  }
+};
+var L = class extends k {
+  constructor(t5, i7, s4, e9, h3) {
+    super(t5, i7, s4, e9, h3), this.type = 5;
+  }
+  _$AI(t5, i7 = this) {
+    if ((t5 = S2(this, t5, i7, 0) ?? E) === T) return;
+    const s4 = this._$AH, e9 = t5 === E && s4 !== E || t5.capture !== s4.capture || t5.once !== s4.once || t5.passive !== s4.passive, h3 = t5 !== E && (s4 === E || e9);
+    e9 && this.element.removeEventListener(this.name, this, s4), h3 && this.element.addEventListener(this.name, this, t5), this._$AH = t5;
+  }
+  handleEvent(t5) {
+    "function" == typeof this._$AH ? this._$AH.call(this.options?.host ?? this.element, t5) : this._$AH.handleEvent(t5);
+  }
+};
+var z = class {
+  constructor(t5, i7, s4) {
+    this.element = t5, this.type = 6, this._$AN = void 0, this._$AM = i7, this.options = s4;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  _$AI(t5) {
+    S2(this, t5);
+  }
+};
+var j = t2.litHtmlPolyfillSupport;
+j?.(N, R), (t2.litHtmlVersions ?? (t2.litHtmlVersions = [])).push("3.3.0");
+var B = (t5, i7, s4) => {
+  const e9 = s4?.renderBefore ?? i7;
+  let h3 = e9._$litPart$;
+  if (void 0 === h3) {
+    const t6 = s4?.renderBefore ?? null;
+    e9._$litPart$ = h3 = new R(i7.insertBefore(l2(), t6), t6, void 0, s4 ?? {});
+  }
+  return h3._$AI(t5), h3;
+};
+
+// node_modules/lit-element/lit-element.js
+var s3 = globalThis;
+var i4 = class extends y {
+  constructor() {
+    super(...arguments), this.renderOptions = { host: this }, this._$Do = void 0;
+  }
+  createRenderRoot() {
+    var _a;
+    const t5 = super.createRenderRoot();
+    return (_a = this.renderOptions).renderBefore ?? (_a.renderBefore = t5.firstChild), t5;
+  }
+  update(t5) {
+    const r6 = this.render();
+    this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(t5), this._$Do = B(r6, this.renderRoot, this.renderOptions);
+  }
+  connectedCallback() {
+    super.connectedCallback(), this._$Do?.setConnected(true);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), this._$Do?.setConnected(false);
+  }
+  render() {
+    return T;
+  }
+};
+i4._$litElement$ = true, i4["finalized"] = true, s3.litElementHydrateSupport?.({ LitElement: i4 });
+var o4 = s3.litElementPolyfillSupport;
+o4?.({ LitElement: i4 });
+(s3.litElementVersions ?? (s3.litElementVersions = [])).push("4.2.0");
+
+// node_modules/@lit/reactive-element/decorators/custom-element.js
+var t3 = (t5) => (e9, o6) => {
+  void 0 !== o6 ? o6.addInitializer((() => {
+    customElements.define(t5, e9);
+  })) : customElements.define(t5, e9);
+};
+
+// node_modules/@lit/reactive-element/decorators/property.js
+var o5 = { attribute: true, type: String, converter: u, reflect: false, hasChanged: f };
+var r4 = (t5 = o5, e9, r6) => {
+  const { kind: n5, metadata: i7 } = r6;
+  let s4 = globalThis.litPropertyMetadata.get(i7);
+  if (void 0 === s4 && globalThis.litPropertyMetadata.set(i7, s4 = /* @__PURE__ */ new Map()), "setter" === n5 && ((t5 = Object.create(t5)).wrapped = true), s4.set(r6.name, t5), "accessor" === n5) {
+    const { name: o6 } = r6;
+    return { set(r7) {
+      const n6 = e9.get.call(this);
+      e9.set.call(this, r7), this.requestUpdate(o6, n6, t5);
+    }, init(e10) {
+      return void 0 !== e10 && this.C(o6, void 0, t5, e10), e10;
+    } };
+  }
+  if ("setter" === n5) {
+    const { name: o6 } = r6;
+    return function(r7) {
+      const n6 = this[o6];
+      e9.call(this, r7), this.requestUpdate(o6, n6, t5);
+    };
+  }
+  throw Error("Unsupported decorator location: " + n5);
+};
+function n4(t5) {
+  return (e9, o6) => "object" == typeof o6 ? r4(t5, e9, o6) : ((t6, e10, o7) => {
+    const r6 = e10.hasOwnProperty(o7);
+    return e10.constructor.createProperty(o7, t6), r6 ? Object.getOwnPropertyDescriptor(e10, o7) : void 0;
+  })(t5, e9, o6);
+}
+
+// node_modules/@lit/reactive-element/decorators/base.js
+var e4 = (e9, t5, c4) => (c4.configurable = true, c4.enumerable = true, Reflect.decorate && "object" != typeof t5 && Object.defineProperty(e9, t5, c4), c4);
+
+// node_modules/@lit/reactive-element/decorators/query.js
+function e5(e9, r6) {
+  return (n5, s4, i7) => {
+    const o6 = (t5) => t5.renderRoot?.querySelector(e9) ?? null;
+    if (r6) {
+      const { get: e10, set: r7 } = "object" == typeof s4 ? n5 : i7 ?? (() => {
+        const t5 = Symbol();
+        return { get() {
+          return this[t5];
+        }, set(e11) {
+          this[t5] = e11;
+        } };
+      })();
+      return e4(n5, s4, { get() {
+        let t5 = e10.call(this);
+        return void 0 === t5 && (t5 = o6(this), (null !== t5 || this.hasUpdated) && r7.call(this, t5)), t5;
+      } });
+    }
+    return e4(n5, s4, { get() {
+      return o6(this);
+    } });
+  };
+}
+
+// src/styles/component-styles/host.css
+var host_default = ":host {\n    box-sizing: border-box !important;\n}\n\n:host *,\n:host *::before,\n:host *::after {\n    box-sizing: inherit !important;\n}\n\n[hidden] {\n    display: none !important;\n}\n";
+
+// src/internal/placer-element.ts
+var PlacerElement = class extends i4 {
+  constructor() {
+    super();
+    this.hasRecordedInitialProperties = false;
+    this.initialReflectedProperties = /* @__PURE__ */ new Map();
+    /** A method to set and check custom states. */
+    this.customStates = {
+      /** Adds or removes the specified custom state. */
+      set: (customState, active) => {
+        if (!Boolean(this.internals?.states)) {
+          return;
+        }
+        if (active) {
+          this.internals.states.add(customState);
+        } else {
+          this.internals.states.delete(customState);
+        }
+      },
+      /** Determines whether or not the element currently has the specified state. */
+      has: (customState) => {
+        if (!Boolean(this.internals?.states)) {
+          return false;
+        }
+        return this.internals.states.has(customState);
+      }
+    };
+    try {
+      this.internals = this.attachInternals();
+    } catch {
+      console.error(
+        "Element internals are not supported in your browser. Consider using a polyfill."
+      );
+    }
+    this.customStates.set("pc-defined", true);
+    let Self = this.constructor;
+    for (let [property, spec] of Self.elementProperties) {
+      if (spec.default === "inherit" && spec.initial !== void 0 && typeof property === "string") {
+        this.customStates.set(
+          `initial-${property}-${spec.initial}`,
+          true
+        );
+      }
+    }
+  }
+  /** Override the default `styles` property to fetch and convert string CSS files. Components can override this behavior by setting their own `static styles = []` property. */
+  static get styles() {
+    const styles = Array.isArray(this.css) ? this.css : this.css ? [this.css] : [];
+    return [host_default, ...styles].map(
+      (style) => typeof style === "string" ? r(style) : style
+    );
+  }
+  attributeChangedCallback(name, oldValue, newValue) {
+    if (!this.hasRecordedInitialProperties) {
+      this.constructor.elementProperties.forEach((object, property) => {
+        if (typeof property === "string" && object.reflect) {
+          const value = this[property];
+          if (value != null) {
+            this.initialReflectedProperties.set(property, value);
+          }
+        }
+      });
+      this.hasRecordedInitialProperties = true;
+    }
+    super.attributeChangedCallback(name, oldValue, newValue);
+  }
+  willUpdate(changedProperties) {
+    super.willUpdate(changedProperties);
+    this.initialReflectedProperties.forEach((value, prop) => {
+      if (changedProperties.has(prop) && this[prop] == null) {
+        this[prop] = value;
+      }
+    });
+  }
+  firstUpdated(changedProperties) {
+    super.firstUpdated(changedProperties);
+  }
+};
+__decorateClass([
+  n4()
+], PlacerElement.prototype, "lang", 2);
+__decorateClass([
+  n4()
+], PlacerElement.prototype, "dir", 2);
+
+// src/internal/animate.ts
+function animateTo(element, keyframes, options) {
+  return new Promise((resolve) => {
+    if (options?.duration === Infinity) {
+      throw new Error("Promise\u2010based animations must be finite.");
+    }
+    const animation = element.animate(keyframes, {
+      ...options,
+      duration: prefersReducedMotion() ? 0 : options.duration
+    });
+    animation.addEventListener("cancel", resolve, { once: true });
+    animation.addEventListener("finish", resolve, { once: true });
+  });
+}
+function prefersReducedMotion() {
+  const query = window.matchMedia("(prefers-reduced-motion: reduce)");
+  return query.matches;
+}
+function stopAnimations(element) {
+  return Promise.all(
+    element.getAnimations().map((animation) => {
+      return new Promise((resolve) => {
+        animation.cancel();
+        requestAnimationFrame(resolve);
+      });
+    })
+  );
+}
+
+// src/utilities/animation-registry.ts
+var defaultAnimationRegistry = /* @__PURE__ */ new Map();
+var customAnimationRegistry = /* @__PURE__ */ new WeakMap();
+function ensureAnimation(animation) {
+  return animation ?? { keyframes: [], options: { duration: 0 } };
+}
+function getLogicalAnimation(animation, dir) {
+  if (dir.toLowerCase() === "rtl") {
+    return {
+      keyframes: animation.rtlKeyframes || animation.keyframes,
+      options: animation.options
+    };
+  }
+  return animation;
+}
+function setDefaultAnimation(animationName, animation) {
+  defaultAnimationRegistry.set(animationName, ensureAnimation(animation));
+}
+function getAnimation(element, animationName, options) {
+  const customAnimation = customAnimationRegistry.get(element);
+  if (customAnimation?.[animationName]) {
+    return getLogicalAnimation(customAnimation[animationName], options.dir);
+  }
+  const defaultAnimation = defaultAnimationRegistry.get(animationName);
+  if (defaultAnimation) {
+    return getLogicalAnimation(defaultAnimation, options.dir);
+  }
+  return {
+    keyframes: [],
+    options: { duration: 0 }
+  };
+}
+
+// src/translations/index.ts
+var connectedElements = /* @__PURE__ */ new Set();
+var translations = /* @__PURE__ */ new Map();
+var fallback;
+var documentDirection = "ltr";
+var documentLanguage = "en";
+var isClient = typeof MutationObserver !== "undefined" && typeof document !== "undefined" && typeof document.documentElement !== "undefined";
+if (isClient) {
+  const documentElementObserver = new MutationObserver(update);
+  documentDirection = document.documentElement.dir || "ltr";
+  documentLanguage = document.documentElement.lang || navigator.language;
+  documentElementObserver.observe(document.documentElement, {
+    attributes: true,
+    attributeFilter: ["dir", "lang"]
+  });
+}
+function registerTranslation(...translation2) {
+  translation2.map((t5) => {
+    const code = t5.$code.toLowerCase();
+    if (translations.has(code)) {
+      translations.set(code, { ...translations.get(code), ...t5 });
+    } else {
+      translations.set(code, t5);
+    }
+    if (!fallback) {
+      fallback = t5;
+    }
+  });
+  update();
+}
+function update() {
+  if (isClient) {
+    documentDirection = document.documentElement.dir || "ltr";
+    documentLanguage = document.documentElement.lang || navigator.language;
+  }
+  [...connectedElements.keys()].map((element) => {
+    if (element instanceof i4 && typeof element.requestUpdate === "function") {
+      element.requestUpdate();
+    }
+  });
+}
+var LocalizeController = class {
+  constructor(host) {
+    this.host = host;
+    this.host.addController(this);
+  }
+  hostConnected() {
+    connectedElements.add(this.host);
+  }
+  hostDisconnected() {
+    connectedElements.delete(this.host);
+  }
+  /** Gets the host element’s direction as determined by the `dir` attribute. The returned value is lowercase. */
+  dir() {
+    return `${this.host.dir || documentDirection}`.toLowerCase();
+  }
+  /** Gets the host element’s language as determined by the `lang` attribute. The returned value is lowercase. */
+  lang() {
+    return `${this.host.lang || documentLanguage}`.toLowerCase();
+  }
+  getTranslationData(lang) {
+    const locale = new Intl.Locale(lang.replace(/_/g, "-"));
+    const language = locale?.language.toLowerCase();
+    const region = locale?.region?.toLowerCase() ?? "";
+    const primary = translations.get(`${language}-${region}`);
+    const secondary = translations.get(language);
+    return { locale, language, region, primary, secondary };
+  }
+  /** Determines if the specified term exists, optionally checking the fallback translation. */
+  exists(key, options) {
+    const { primary, secondary } = this.getTranslationData(
+      options.lang ?? this.lang()
+    );
+    options = {
+      includeFallback: false,
+      ...options
+    };
+    if (primary && primary[key] || secondary && secondary[key] || options.includeFallback && fallback && fallback[key]) {
+      return true;
+    }
+    return false;
+  }
+  /** Outputs a translated term. */
+  term(key, ...args) {
+    const { primary, secondary } = this.getTranslationData(this.lang());
+    let term;
+    if (primary && primary[key]) {
+      term = primary[key];
+    } else if (secondary && secondary[key]) {
+      term = secondary[key];
+    } else if (fallback && fallback[key]) {
+      term = fallback[key];
+    } else {
+      console.error(`No translation was found for \u201C${String(key)}\u201D.`);
+      return String(key);
+    }
+    if (typeof term === "function") {
+      return term(...args);
+    }
+    return term;
+  }
+  /** Outputs a localised date in the specified format. */
+  date(dateToFormat, options) {
+    dateToFormat = new Date(dateToFormat);
+    return new Intl.DateTimeFormat(this.lang(), options).format(
+      dateToFormat
+    );
+  }
+  /** Outputs a localised number in the specified format. */
+  number(numberToFormat, options) {
+    numberToFormat = Number(numberToFormat);
+    return isNaN(numberToFormat) ? "" : new Intl.NumberFormat(this.lang(), options).format(
+      numberToFormat
+    );
+  }
+  /** Outputs a localised time in relative format. */
+  relativeTime(value, unit, options) {
+    return new Intl.RelativeTimeFormat(this.lang(), options).format(
+      value,
+      unit
+    );
+  }
+};
+
+// src/translations/en.ts
+var translation = {
+  $code: "en",
+  $name: "English",
+  $dir: "ltr",
+  carousel: "Carousel",
+  clearEntry: "Clear entry",
+  close: "Close",
+  copied: "Copied!",
+  copy: "Copy",
+  currentValue: "Current value",
+  error: "Error",
+  goToSlide: (slide, count) => `Go to slide ${slide} of ${count}`,
+  hidePassword: "Hide password",
+  hue: "Hue",
+  loading: "Loading\u2026",
+  nextSlide: "Next slide",
+  numOptionsSelected: (number) => {
+    if (number === 0) {
+      return "No options selected";
+    } else if (number === 1) {
+      return "One option selected";
+    } else {
+      return `${number} options selected`;
+    }
+  },
+  opacity: "Opacity",
+  pickAColorFromTheScreen: "Pick a color from the screen",
+  previousSlide: "Previous slide",
+  progress: "Progress",
+  remove: "Remove",
+  resize: "Resize",
+  scrollableRegion: "Scrollable region",
+  scrollToEnd: "Scroll to end",
+  scrollToStart: "Scroll to start",
+  showPassword: "Show password",
+  slideNum: (slide) => `Slide ${slide}`,
+  toggleColorFormat: "Toggle color format"
+};
+registerTranslation(translation);
+var en_default = translation;
+
+// src/utilities/localize.ts
+var LocalizeController2 = class extends LocalizeController {
+};
+registerTranslation(en_default);
+
+// node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
+var min = Math.min;
+var max = Math.max;
+var round = Math.round;
+var floor = Math.floor;
+var createCoords = (v2) => ({
+  x: v2,
+  y: v2
+});
+var oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+var oppositeAlignmentMap = {
+  start: "end",
+  end: "start"
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split("-")[0];
+}
+function getAlignment(placement) {
+  return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+  return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+  return axis === "y" ? "height" : "width";
+}
+var yAxisSides = /* @__PURE__ */ new Set(["top", "bottom"]);
+function getSideAxis(placement) {
+  return yAxisSides.has(getSide(placement)) ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+}
+var lrPlacement = ["left", "right"];
+var rlPlacement = ["right", "left"];
+var tbPlacement = ["top", "bottom"];
+var btPlacement = ["bottom", "top"];
+function getSideList(side, isStart, rtl) {
+  switch (side) {
+    case "top":
+    case "bottom":
+      if (rtl) return isStart ? rlPlacement : lrPlacement;
+      return isStart ? lrPlacement : rlPlacement;
+    case "left":
+    case "right":
+      return isStart ? tbPlacement : btPlacement;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === "start", rtl);
+  if (alignment) {
+    list = list.map((side) => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...padding
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  const {
+    x: x2,
+    y: y3,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y3,
+    left: x2,
+    right: x2 + width,
+    bottom: y3 + height,
+    x: x2,
+    y: y3
+  };
+}
+
+// node_modules/@floating-ui/core/dist/floating-ui.core.mjs
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+  let {
+    reference,
+    floating
+  } = _ref;
+  const sideAxis = getSideAxis(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const alignLength = getAxisLength(alignmentAxis);
+  const side = getSide(placement);
+  const isVertical = sideAxis === "y";
+  const commonX = reference.x + reference.width / 2 - floating.width / 2;
+  const commonY = reference.y + reference.height / 2 - floating.height / 2;
+  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+  let coords;
+  switch (side) {
+    case "top":
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
+      };
+      break;
+    case "bottom":
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
+      };
+      break;
+    case "right":
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
+      };
+      break;
+    case "left":
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
+      };
+      break;
+    default:
+      coords = {
+        x: reference.x,
+        y: reference.y
+      };
+  }
+  switch (getAlignment(placement)) {
+    case "start":
+      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+    case "end":
+      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+  }
+  return coords;
+}
+var computePosition = async (reference, floating, config) => {
+  const {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform: platform2
+  } = config;
+  const validMiddleware = middleware.filter(Boolean);
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
+  let rects = await platform2.getElementRects({
+    reference,
+    floating,
+    strategy
+  });
+  let {
+    x: x2,
+    y: y3
+  } = computeCoordsFromPlacement(rects, placement, rtl);
+  let statefulPlacement = placement;
+  let middlewareData = {};
+  let resetCount = 0;
+  for (let i7 = 0; i7 < validMiddleware.length; i7++) {
+    const {
+      name,
+      fn
+    } = validMiddleware[i7];
+    const {
+      x: nextX,
+      y: nextY,
+      data,
+      reset
+    } = await fn({
+      x: x2,
+      y: y3,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform: platform2,
+      elements: {
+        reference,
+        floating
+      }
+    });
+    x2 = nextX != null ? nextX : x2;
+    y3 = nextY != null ? nextY : y3;
+    middlewareData = {
+      ...middlewareData,
+      [name]: {
+        ...middlewareData[name],
+        ...data
+      }
+    };
+    if (reset && resetCount <= 50) {
+      resetCount++;
+      if (typeof reset === "object") {
+        if (reset.placement) {
+          statefulPlacement = reset.placement;
+        }
+        if (reset.rects) {
+          rects = reset.rects === true ? await platform2.getElementRects({
+            reference,
+            floating,
+            strategy
+          }) : reset.rects;
+        }
+        ({
+          x: x2,
+          y: y3
+        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+      }
+      i7 = -1;
+    }
+  }
+  return {
+    x: x2,
+    y: y3,
+    placement: statefulPlacement,
+    strategy,
+    middlewareData
+  };
+};
+async function detectOverflow(state, options) {
+  var _await$platform$isEle;
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    x: x2,
+    y: y3,
+    platform: platform2,
+    rects,
+    elements,
+    strategy
+  } = state;
+  const {
+    boundary = "clippingAncestors",
+    rootBoundary = "viewport",
+    elementContext = "floating",
+    altBoundary = false,
+    padding = 0
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
+  const altContext = elementContext === "floating" ? "reference" : "floating";
+  const element = elements[altBoundary ? altContext : elementContext];
+  const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
+    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
+    boundary,
+    rootBoundary,
+    strategy
+  }));
+  const rect = elementContext === "floating" ? {
+    x: x2,
+    y: y3,
+    width: rects.floating.width,
+    height: rects.floating.height
+  } : rects.reference;
+  const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
+  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  };
+  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  }) : rect);
+  return {
+    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+  };
+}
+var arrow = (options) => ({
+  name: "arrow",
+  options,
+  async fn(state) {
+    const {
+      x: x2,
+      y: y3,
+      placement,
+      rects,
+      platform: platform2,
+      elements,
+      middlewareData
+    } = state;
+    const {
+      element,
+      padding = 0
+    } = evaluate(options, state) || {};
+    if (element == null) {
+      return {};
+    }
+    const paddingObject = getPaddingObject(padding);
+    const coords = {
+      x: x2,
+      y: y3
+    };
+    const axis = getAlignmentAxis(placement);
+    const length = getAxisLength(axis);
+    const arrowDimensions = await platform2.getDimensions(element);
+    const isYAxis = axis === "y";
+    const minProp = isYAxis ? "top" : "left";
+    const maxProp = isYAxis ? "bottom" : "right";
+    const clientProp = isYAxis ? "clientHeight" : "clientWidth";
+    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+    const startDiff = coords[axis] - rects.reference[axis];
+    const arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
+    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
+    if (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) {
+      clientSize = elements.floating[clientProp] || rects.floating[length];
+    }
+    const centerToReference = endDiff / 2 - startDiff / 2;
+    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+    const minPadding = min(paddingObject[minProp], largestPossiblePadding);
+    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+    const min$1 = minPadding;
+    const max2 = clientSize - arrowDimensions[length] - maxPadding;
+    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+    const offset3 = clamp(min$1, center, max2);
+    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset3 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0;
+    return {
+      [axis]: coords[axis] + alignmentOffset,
+      data: {
+        [axis]: offset3,
+        centerOffset: center - offset3 - alignmentOffset,
+        ...shouldAddOffset && {
+          alignmentOffset
+        }
+      },
+      reset: shouldAddOffset
+    };
+  }
+});
+var flip = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "flip",
+    options,
+    async fn(state) {
+      var _middlewareData$arrow, _middlewareData$flip;
+      const {
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement,
+        platform: platform2,
+        elements
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true,
+        fallbackPlacements: specifiedFallbackPlacements,
+        fallbackStrategy = "bestFit",
+        fallbackAxisSideDirection = "none",
+        flipAlignment = true,
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      const side = getSide(placement);
+      const initialSideAxis = getSideAxis(initialPlacement);
+      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+      const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
+        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+      }
+      const placements2 = [initialPlacement, ...fallbackPlacements];
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+      if (checkMainAxis) {
+        overflows.push(overflow[side]);
+      }
+      if (checkCrossAxis) {
+        const sides2 = getAlignmentSides(placement, rects, rtl);
+        overflows.push(overflow[sides2[0]], overflow[sides2[1]]);
+      }
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }];
+      if (!overflows.every((side2) => side2 <= 0)) {
+        var _middlewareData$flip2, _overflowsData$filter;
+        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+        const nextPlacement = placements2[nextIndex];
+        if (nextPlacement) {
+          const ignoreCrossAxisOverflow = checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false;
+          if (!ignoreCrossAxisOverflow || // We leave the current main axis only if every placement on that axis
+          // overflows the main axis.
+          overflowsData.every((d3) => getSideAxis(d3.placement) === initialSideAxis ? d3.overflows[0] > 0 : true)) {
+            return {
+              data: {
+                index: nextIndex,
+                overflows: overflowsData
+              },
+              reset: {
+                placement: nextPlacement
+              }
+            };
+          }
+        }
+        let resetPlacement = (_overflowsData$filter = overflowsData.filter((d3) => d3.overflows[0] <= 0).sort((a3, b3) => a3.overflows[1] - b3.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+        if (!resetPlacement) {
+          switch (fallbackStrategy) {
+            case "bestFit": {
+              var _overflowsData$filter2;
+              const placement2 = (_overflowsData$filter2 = overflowsData.filter((d3) => {
+                if (hasFallbackAxisSideDirection) {
+                  const currentSideAxis = getSideAxis(d3.placement);
+                  return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  currentSideAxis === "y";
+                }
+                return true;
+              }).map((d3) => [d3.placement, d3.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a3, b3) => a3[1] - b3[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+              if (placement2) {
+                resetPlacement = placement2;
+              }
+              break;
+            }
+            case "initialPlacement":
+              resetPlacement = initialPlacement;
+              break;
+          }
+        }
+        if (placement !== resetPlacement) {
+          return {
+            reset: {
+              placement: resetPlacement
+            }
+          };
+        }
+      }
+      return {};
+    }
+  };
+};
+var originSides = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords(state, options) {
+  const {
+    placement,
+    platform: platform2,
+    elements
+  } = state;
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
+  const side = getSide(placement);
+  const alignment = getAlignment(placement);
+  const isVertical = getSideAxis(placement) === "y";
+  const mainAxisMulti = originSides.has(side) ? -1 : 1;
+  const crossAxisMulti = rtl && isVertical ? -1 : 1;
+  const rawValue = evaluate(options, state);
+  let {
+    mainAxis,
+    crossAxis,
+    alignmentAxis
+  } = typeof rawValue === "number" ? {
+    mainAxis: rawValue,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: rawValue.mainAxis || 0,
+    crossAxis: rawValue.crossAxis || 0,
+    alignmentAxis: rawValue.alignmentAxis
+  };
+  if (alignment && typeof alignmentAxis === "number") {
+    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+  }
+  return isVertical ? {
+    x: crossAxis * crossAxisMulti,
+    y: mainAxis * mainAxisMulti
+  } : {
+    x: mainAxis * mainAxisMulti,
+    y: crossAxis * crossAxisMulti
+  };
+}
+var offset = function(options) {
+  if (options === void 0) {
+    options = 0;
+  }
+  return {
+    name: "offset",
+    options,
+    async fn(state) {
+      var _middlewareData$offse, _middlewareData$arrow;
+      const {
+        x: x2,
+        y: y3,
+        placement,
+        middlewareData
+      } = state;
+      const diffCoords = await convertValueToCoords(state, options);
+      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      return {
+        x: x2 + diffCoords.x,
+        y: y3 + diffCoords.y,
+        data: {
+          ...diffCoords,
+          placement
+        }
+      };
+    }
+  };
+};
+var shift = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "shift",
+    options,
+    async fn(state) {
+      const {
+        x: x2,
+        y: y3,
+        placement
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = false,
+        limiter = {
+          fn: (_ref) => {
+            let {
+              x: x3,
+              y: y4
+            } = _ref;
+            return {
+              x: x3,
+              y: y4
+            };
+          }
+        },
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const coords = {
+        x: x2,
+        y: y3
+      };
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const crossAxis = getSideAxis(getSide(placement));
+      const mainAxis = getOppositeAxis(crossAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      if (checkMainAxis) {
+        const minSide = mainAxis === "y" ? "top" : "left";
+        const maxSide = mainAxis === "y" ? "bottom" : "right";
+        const min2 = mainAxisCoord + overflow[minSide];
+        const max2 = mainAxisCoord - overflow[maxSide];
+        mainAxisCoord = clamp(min2, mainAxisCoord, max2);
+      }
+      if (checkCrossAxis) {
+        const minSide = crossAxis === "y" ? "top" : "left";
+        const maxSide = crossAxis === "y" ? "bottom" : "right";
+        const min2 = crossAxisCoord + overflow[minSide];
+        const max2 = crossAxisCoord - overflow[maxSide];
+        crossAxisCoord = clamp(min2, crossAxisCoord, max2);
+      }
+      const limitedCoords = limiter.fn({
+        ...state,
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      });
+      return {
+        ...limitedCoords,
+        data: {
+          x: limitedCoords.x - x2,
+          y: limitedCoords.y - y3,
+          enabled: {
+            [mainAxis]: checkMainAxis,
+            [crossAxis]: checkCrossAxis
+          }
+        }
+      };
+    }
+  };
+};
+var size = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "size",
+    options,
+    async fn(state) {
+      var _state$middlewareData, _state$middlewareData2;
+      const {
+        placement,
+        rects,
+        platform: platform2,
+        elements
+      } = state;
+      const {
+        apply = () => {
+        },
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const side = getSide(placement);
+      const alignment = getAlignment(placement);
+      const isYAxis = getSideAxis(placement) === "y";
+      const {
+        width,
+        height
+      } = rects.floating;
+      let heightSide;
+      let widthSide;
+      if (side === "top" || side === "bottom") {
+        heightSide = side;
+        widthSide = alignment === (await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
+      } else {
+        widthSide = side;
+        heightSide = alignment === "end" ? "top" : "bottom";
+      }
+      const maximumClippingHeight = height - overflow.top - overflow.bottom;
+      const maximumClippingWidth = width - overflow.left - overflow.right;
+      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
+      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
+      const noShift = !state.middlewareData.shift;
+      let availableHeight = overflowAvailableHeight;
+      let availableWidth = overflowAvailableWidth;
+      if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {
+        availableWidth = maximumClippingWidth;
+      }
+      if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {
+        availableHeight = maximumClippingHeight;
+      }
+      if (noShift && !alignment) {
+        const xMin = max(overflow.left, 0);
+        const xMax = max(overflow.right, 0);
+        const yMin = max(overflow.top, 0);
+        const yMax = max(overflow.bottom, 0);
+        if (isYAxis) {
+          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
+        } else {
+          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
+        }
+      }
+      await apply({
+        ...state,
+        availableWidth,
+        availableHeight
+      });
+      const nextDimensions = await platform2.getDimensions(elements.floating);
+      if (width !== nextDimensions.width || height !== nextDimensions.height) {
+        return {
+          reset: {
+            rects: true
+          }
+        };
+      }
+      return {};
+    }
+  };
+};
+
+// node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || "").toLowerCase();
+  }
+  return "#document";
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === "undefined") {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+var invalidOverflowDisplayValues = /* @__PURE__ */ new Set(["inline", "contents"]);
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle2(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !invalidOverflowDisplayValues.has(display);
+}
+var tableElements = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function isTableElement(element) {
+  return tableElements.has(getNodeName(element));
+}
+var topLayerSelectors = [":popover-open", ":modal"];
+function isTopLayer(element) {
+  return topLayerSelectors.some((selector) => {
+    try {
+      return element.matches(selector);
+    } catch (_e) {
+      return false;
+    }
+  });
+}
+var transformProperties = ["transform", "translate", "scale", "rotate", "perspective"];
+var willChangeValues = ["transform", "translate", "scale", "rotate", "perspective", "filter"];
+var containValues = ["paint", "layout", "strict", "content"];
+function isContainingBlock(elementOrCss) {
+  const webkit = isWebKit();
+  const css = isElement(elementOrCss) ? getComputedStyle2(elementOrCss) : elementOrCss;
+  return transformProperties.some((value) => css[value] ? css[value] !== "none" : false) || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || willChangeValues.some((value) => (css.willChange || "").includes(value)) || containValues.some((value) => (css.contain || "").includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (typeof CSS === "undefined" || !CSS.supports) return false;
+  return CSS.supports("-webkit-backdrop-filter", "none");
+}
+var lastTraversableNodeNames = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function isLastTraversableNode(node) {
+  return lastTraversableNodeNames.has(getNodeName(node));
+}
+function getComputedStyle2(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === "html") {
+    return node;
+  }
+  const result = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot || // DOM Element detected.
+    node.parentNode || // ShadowRoot detected.
+    isShadowRoot(node) && node.host || // Fallback.
+    getDocumentElement(node)
+  );
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+
+// node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
+function getCssDimensions(element) {
+  const css = getComputedStyle2(element);
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
+  const hasOffset = isHTMLElement(element);
+  const offsetWidth = hasOffset ? element.offsetWidth : width;
+  const offsetHeight = hasOffset ? element.offsetHeight : height;
+  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return {
+    width,
+    height,
+    $: shouldFallback
+  };
+}
+function unwrapElement(element) {
+  return !isElement(element) ? element.contextElement : element;
+}
+function getScale(element) {
+  const domElement = unwrapElement(element);
+  if (!isHTMLElement(domElement)) {
+    return createCoords(1);
+  }
+  const rect = domElement.getBoundingClientRect();
+  const {
+    width,
+    height,
+    $: $2
+  } = getCssDimensions(domElement);
+  let x2 = ($2 ? round(rect.width) : rect.width) / width;
+  let y3 = ($2 ? round(rect.height) : rect.height) / height;
+  if (!x2 || !Number.isFinite(x2)) {
+    x2 = 1;
+  }
+  if (!y3 || !Number.isFinite(y3)) {
+    y3 = 1;
+  }
+  return {
+    x: x2,
+    y: y3
+  };
+}
+var noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(element) {
+  const win = getWindow(element);
+  if (!isWebKit() || !win.visualViewport) {
+    return noOffsets;
+  }
+  return {
+    x: win.visualViewport.offsetLeft,
+    y: win.visualViewport.offsetTop
+  };
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+  if (isFixed === void 0) {
+    isFixed = false;
+  }
+  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
+    return false;
+  }
+  return isFixed;
+}
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+  if (includeScale === void 0) {
+    includeScale = false;
+  }
+  if (isFixedStrategy === void 0) {
+    isFixedStrategy = false;
+  }
+  const clientRect = element.getBoundingClientRect();
+  const domElement = unwrapElement(element);
+  let scale = createCoords(1);
+  if (includeScale) {
+    if (offsetParent) {
+      if (isElement(offsetParent)) {
+        scale = getScale(offsetParent);
+      }
+    } else {
+      scale = getScale(element);
+    }
+  }
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  let x2 = (clientRect.left + visualOffsets.x) / scale.x;
+  let y3 = (clientRect.top + visualOffsets.y) / scale.y;
+  let width = clientRect.width / scale.x;
+  let height = clientRect.height / scale.y;
+  if (domElement) {
+    const win = getWindow(domElement);
+    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    let currentWin = win;
+    let currentIFrame = getFrameElement(currentWin);
+    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+      const iframeScale = getScale(currentIFrame);
+      const iframeRect = currentIFrame.getBoundingClientRect();
+      const css = getComputedStyle2(currentIFrame);
+      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+      x2 *= iframeScale.x;
+      y3 *= iframeScale.y;
+      width *= iframeScale.x;
+      height *= iframeScale.y;
+      x2 += left;
+      y3 += top;
+      currentWin = getWindow(currentIFrame);
+      currentIFrame = getFrameElement(currentWin);
+    }
+  }
+  return rectToClientRect({
+    width,
+    height,
+    x: x2,
+    y: y3
+  });
+}
+function getWindowScrollBarX(element, rect) {
+  const leftScroll = getNodeScroll(element).scrollLeft;
+  if (!rect) {
+    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+  }
+  return rect.left + leftScroll;
+}
+function getHTMLOffset(documentElement, scroll) {
+  const htmlRect = documentElement.getBoundingClientRect();
+  const x2 = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
+  const y3 = htmlRect.top + scroll.scrollTop;
+  return {
+    x: x2,
+    y: y3
+  };
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  let {
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  } = _ref;
+  const isFixed = strategy === "fixed";
+  const documentElement = getDocumentElement(offsetParent);
+  const topLayer = elements ? isTopLayer(elements.floating) : false;
+  if (offsetParent === documentElement || topLayer && isFixed) {
+    return rect;
+  }
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  let scale = createCoords(1);
+  const offsets = createCoords(0);
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent);
+      scale = getScale(offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  return {
+    width: rect.width * scale.x,
+    height: rect.height * scale.y,
+    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+  };
+}
+function getClientRects(element) {
+  return Array.from(element.getClientRects());
+}
+function getDocumentRect(element) {
+  const html = getDocumentElement(element);
+  const scroll = getNodeScroll(element);
+  const body = element.ownerDocument.body;
+  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  let x2 = -scroll.scrollLeft + getWindowScrollBarX(element);
+  const y3 = -scroll.scrollTop;
+  if (getComputedStyle2(body).direction === "rtl") {
+    x2 += max(html.clientWidth, body.clientWidth) - width;
+  }
+  return {
+    width,
+    height,
+    x: x2,
+    y: y3
+  };
+}
+var SCROLLBAR_MAX = 25;
+function getViewportRect(element, strategy) {
+  const win = getWindow(element);
+  const html = getDocumentElement(element);
+  const visualViewport = win.visualViewport;
+  let width = html.clientWidth;
+  let height = html.clientHeight;
+  let x2 = 0;
+  let y3 = 0;
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height;
+    const visualViewportBased = isWebKit();
+    if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
+      x2 = visualViewport.offsetLeft;
+      y3 = visualViewport.offsetTop;
+    }
+  }
+  const windowScrollbarX = getWindowScrollBarX(html);
+  if (windowScrollbarX <= 0) {
+    const doc = html.ownerDocument;
+    const body = doc.body;
+    const bodyStyles = getComputedStyle(body);
+    const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
+    const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+    if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) {
+      width -= clippingStableScrollbarWidth;
+    }
+  } else if (windowScrollbarX <= SCROLLBAR_MAX) {
+    width += windowScrollbarX;
+  }
+  return {
+    width,
+    height,
+    x: x2,
+    y: y3
+  };
+}
+var absoluteOrFixed = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function getInnerBoundingClientRect(element, strategy) {
+  const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
+  const top = clientRect.top + element.clientTop;
+  const left = clientRect.left + element.clientLeft;
+  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+  const width = element.clientWidth * scale.x;
+  const height = element.clientHeight * scale.y;
+  const x2 = left * scale.x;
+  const y3 = top * scale.y;
+  return {
+    width,
+    height,
+    x: x2,
+    y: y3
+  };
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+  let rect;
+  if (clippingAncestor === "viewport") {
+    rect = getViewportRect(element, strategy);
+  } else if (clippingAncestor === "document") {
+    rect = getDocumentRect(getDocumentElement(element));
+  } else if (isElement(clippingAncestor)) {
+    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+  } else {
+    const visualOffsets = getVisualOffsets(element);
+    rect = {
+      x: clippingAncestor.x - visualOffsets.x,
+      y: clippingAncestor.y - visualOffsets.y,
+      width: clippingAncestor.width,
+      height: clippingAncestor.height
+    };
+  }
+  return rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+  const parentNode = getParentNode(element);
+  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
+    return false;
+  }
+  return getComputedStyle2(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
+}
+function getClippingElementAncestors(element, cache) {
+  const cachedResult = cache.get(element);
+  if (cachedResult) {
+    return cachedResult;
+  }
+  let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
+  let currentContainingBlockComputedStyle = null;
+  const elementIsFixed = getComputedStyle2(element).position === "fixed";
+  let currentNode = elementIsFixed ? getParentNode(element) : element;
+  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    const computedStyle = getComputedStyle2(currentNode);
+    const currentNodeIsContaining = isContainingBlock(currentNode);
+    if (!currentNodeIsContaining && computedStyle.position === "fixed") {
+      currentContainingBlockComputedStyle = null;
+    }
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && absoluteOrFixed.has(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    if (shouldDropCurrentNode) {
+      result = result.filter((ancestor) => ancestor !== currentNode);
+    } else {
+      currentContainingBlockComputedStyle = computedStyle;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  cache.set(element, result);
+  return result;
+}
+function getClippingRect(_ref) {
+  let {
+    element,
+    boundary,
+    rootBoundary,
+    strategy
+  } = _ref;
+  const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
+  const firstClippingAncestor = clippingAncestors[0];
+  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+    accRect.top = max(rect.top, accRect.top);
+    accRect.right = min(rect.right, accRect.right);
+    accRect.bottom = min(rect.bottom, accRect.bottom);
+    accRect.left = max(rect.left, accRect.left);
+    return accRect;
+  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+  return {
+    width: clippingRect.right - clippingRect.left,
+    height: clippingRect.bottom - clippingRect.top,
+    x: clippingRect.left,
+    y: clippingRect.top
+  };
+}
+function getDimensions(element) {
+  const {
+    width,
+    height
+  } = getCssDimensions(element);
+  return {
+    width,
+    height
+  };
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  const isFixed = strategy === "fixed";
+  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = createCoords(0);
+  function setLeftRTLScrollbarOffset() {
+    offsets.x = getWindowScrollBarX(documentElement);
+  }
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isOffsetParentAnElement) {
+      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else if (documentElement) {
+      setLeftRTLScrollbarOffset();
+    }
+  }
+  if (isFixed && !isOffsetParentAnElement && documentElement) {
+    setLeftRTLScrollbarOffset();
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const x2 = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
+  const y3 = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
+  return {
+    x: x2,
+    y: y3,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function isStaticPositioned(element) {
+  return getComputedStyle2(element).position === "static";
+}
+function getTrueOffsetParent(element, polyfill) {
+  if (!isHTMLElement(element) || getComputedStyle2(element).position === "fixed") {
+    return null;
+  }
+  if (polyfill) {
+    return polyfill(element);
+  }
+  let rawOffsetParent = element.offsetParent;
+  if (getDocumentElement(element) === rawOffsetParent) {
+    rawOffsetParent = rawOffsetParent.ownerDocument.body;
+  }
+  return rawOffsetParent;
+}
+function getOffsetParent(element, polyfill) {
+  const win = getWindow(element);
+  if (isTopLayer(element)) {
+    return win;
+  }
+  if (!isHTMLElement(element)) {
+    let svgOffsetParent = getParentNode(element);
+    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
+        return svgOffsetParent;
+      }
+      svgOffsetParent = getParentNode(svgOffsetParent);
+    }
+    return win;
+  }
+  let offsetParent = getTrueOffsetParent(element, polyfill);
+  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
+    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+  }
+  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
+    return win;
+  }
+  return offsetParent || getContainingBlock(element) || win;
+}
+var getElementRects = async function(data) {
+  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+  const getDimensionsFn = this.getDimensions;
+  const floatingDimensions = await getDimensionsFn(data.floating);
+  return {
+    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: floatingDimensions.width,
+      height: floatingDimensions.height
+    }
+  };
+};
+function isRTL(element) {
+  return getComputedStyle2(element).direction === "rtl";
+}
+var platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+function rectsAreEqual(a3, b3) {
+  return a3.x === b3.x && a3.y === b3.y && a3.width === b3.width && a3.height === b3.height;
+}
+function observeMove(element, onMove) {
+  let io = null;
+  let timeoutId;
+  const root = getDocumentElement(element);
+  function cleanup() {
+    var _io;
+    clearTimeout(timeoutId);
+    (_io = io) == null || _io.disconnect();
+    io = null;
+  }
+  function refresh(skip, threshold) {
+    if (skip === void 0) {
+      skip = false;
+    }
+    if (threshold === void 0) {
+      threshold = 1;
+    }
+    cleanup();
+    const elementRectForRootMargin = element.getBoundingClientRect();
+    const {
+      left,
+      top,
+      width,
+      height
+    } = elementRectForRootMargin;
+    if (!skip) {
+      onMove();
+    }
+    if (!width || !height) {
+      return;
+    }
+    const insetTop = floor(top);
+    const insetRight = floor(root.clientWidth - (left + width));
+    const insetBottom = floor(root.clientHeight - (top + height));
+    const insetLeft = floor(left);
+    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+    const options = {
+      rootMargin,
+      threshold: max(0, min(1, threshold)) || 1
+    };
+    let isFirstUpdate = true;
+    function handleObserve(entries) {
+      const ratio = entries[0].intersectionRatio;
+      if (ratio !== threshold) {
+        if (!isFirstUpdate) {
+          return refresh();
+        }
+        if (!ratio) {
+          timeoutId = setTimeout(() => {
+            refresh(false, 1e-7);
+          }, 1e3);
+        } else {
+          refresh(false, ratio);
+        }
+      }
+      if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
+        refresh();
+      }
+      isFirstUpdate = false;
+    }
+    try {
+      io = new IntersectionObserver(handleObserve, {
+        ...options,
+        // Handle <iframe>s
+        root: root.ownerDocument
+      });
+    } catch (_e) {
+      io = new IntersectionObserver(handleObserve, options);
+    }
+    io.observe(element);
+  }
+  refresh(true);
+  return cleanup;
+}
+function autoUpdate(reference, floating, update2, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    ancestorScroll = true,
+    ancestorResize = true,
+    elementResize = typeof ResizeObserver === "function",
+    layoutShift = typeof IntersectionObserver === "function",
+    animationFrame = false
+  } = options;
+  const referenceEl = unwrapElement(reference);
+  const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
+  ancestors.forEach((ancestor) => {
+    ancestorScroll && ancestor.addEventListener("scroll", update2, {
+      passive: true
+    });
+    ancestorResize && ancestor.addEventListener("resize", update2);
+  });
+  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update2) : null;
+  let reobserveFrame = -1;
+  let resizeObserver = null;
+  if (elementResize) {
+    resizeObserver = new ResizeObserver((_ref) => {
+      let [firstEntry] = _ref;
+      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+        resizeObserver.unobserve(floating);
+        cancelAnimationFrame(reobserveFrame);
+        reobserveFrame = requestAnimationFrame(() => {
+          var _resizeObserver;
+          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+        });
+      }
+      update2();
+    });
+    if (referenceEl && !animationFrame) {
+      resizeObserver.observe(referenceEl);
+    }
+    resizeObserver.observe(floating);
+  }
+  let frameId;
+  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  if (animationFrame) {
+    frameLoop();
+  }
+  function frameLoop() {
+    const nextRefRect = getBoundingClientRect(reference);
+    if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
+      update2();
+    }
+    prevRefRect = nextRefRect;
+    frameId = requestAnimationFrame(frameLoop);
+  }
+  update2();
+  return () => {
+    var _resizeObserver2;
+    ancestors.forEach((ancestor) => {
+      ancestorScroll && ancestor.removeEventListener("scroll", update2);
+      ancestorResize && ancestor.removeEventListener("resize", update2);
+    });
+    cleanupIo == null || cleanupIo();
+    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+    resizeObserver = null;
+    if (animationFrame) {
+      cancelAnimationFrame(frameId);
+    }
+  };
+}
+var offset2 = offset;
+var shift2 = shift;
+var flip2 = flip;
+var size2 = size;
+var arrow2 = arrow;
+var computePosition2 = (reference, floating, options) => {
+  const cache = /* @__PURE__ */ new Map();
+  const mergedOptions = {
+    platform,
+    ...options
+  };
+  const platformWithCache = {
+    ...mergedOptions.platform,
+    _c: cache
+  };
+  return computePosition(reference, floating, {
+    ...mergedOptions,
+    platform: platformWithCache
+  });
+};
+
+// src/internal/active-elements.ts
+function* activeElements(activeElement = document.activeElement) {
+  if (activeElement === null || activeElement === void 0) {
+    return;
+  }
+  yield activeElement;
+  if ("shadowRoot" in activeElement && activeElement.shadowRoot && activeElement.shadowRoot.mode !== "closed") {
+    yield* activeElements(activeElement.shadowRoot.activeElement);
+  }
+}
+
+// node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// node_modules/nanoid/index.browser.js
+var nanoid = (size3 = 21) => {
+  let id = "";
+  let bytes = crypto.getRandomValues(new Uint8Array(size3 |= 0));
+  while (size3--) {
+    id += urlAlphabet[bytes[size3] & 63];
+  }
+  return id;
+};
+
+// src/internal/math.ts
+function uniqueID(prefix = "") {
+  return `${prefix}${nanoid()}`;
+}
+
+// src/internal/emit.ts
+function emit(target, eventName, eventDetail) {
+  const { detail, cancelable, ...options } = eventDetail || {};
+  const event = new CustomEvent(eventName, {
+    bubbles: true,
+    cancelable: cancelable !== void 0 ? cancelable : false,
+    composed: true,
+    detail,
+    ...options
+  });
+  target.dispatchEvent(event);
+  return event;
+}
+
+// node_modules/lit-html/directive.js
+var t4 = { ATTRIBUTE: 1, CHILD: 2, PROPERTY: 3, BOOLEAN_ATTRIBUTE: 4, EVENT: 5, ELEMENT: 6 };
+var e6 = (t5) => (...e9) => ({ _$litDirective$: t5, values: e9 });
+var i5 = class {
+  constructor(t5) {
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  _$AT(t5, e9, i7) {
+    this._$Ct = t5, this._$AM = e9, this._$Ci = i7;
+  }
+  _$AS(t5, e9) {
+    return this.update(t5, e9);
+  }
+  update(t5, e9) {
+    return this.render(...e9);
+  }
+};
+
+// node_modules/lit-html/directives/class-map.js
+var e7 = e6(class extends i5 {
+  constructor(t5) {
+    if (super(t5), t5.type !== t4.ATTRIBUTE || "class" !== t5.name || t5.strings?.length > 2) throw Error("`classMap()` can only be used in the `class` attribute and must be the only part in the attribute.");
+  }
+  render(t5) {
+    return " " + Object.keys(t5).filter(((s4) => t5[s4])).join(" ") + " ";
+  }
+  update(s4, [i7]) {
+    if (void 0 === this.st) {
+      this.st = /* @__PURE__ */ new Set(), void 0 !== s4.strings && (this.nt = new Set(s4.strings.join(" ").split(/\s/).filter(((t5) => "" !== t5))));
+      for (const t5 in i7) i7[t5] && !this.nt?.has(t5) && this.st.add(t5);
+      return this.render(i7);
+    }
+    const r6 = s4.element.classList;
+    for (const t5 of this.st) t5 in i7 || (r6.remove(t5), this.st.delete(t5));
+    for (const t5 in i7) {
+      const s5 = !!i7[t5];
+      s5 === this.st.has(t5) || this.nt?.has(t5) || (s5 ? (r6.add(t5), this.st.add(t5)) : (r6.remove(t5), this.st.delete(t5)));
+    }
+    return T;
+  }
+});
+
+// node_modules/composed-offset-position/dist/composed-offset-position.browser.min.mjs
+function e8(t5) {
+  return i6(t5);
+}
+function r5(t5) {
+  return t5.assignedSlot ? t5.assignedSlot : t5.parentNode instanceof ShadowRoot ? t5.parentNode.host : t5.parentNode;
+}
+function i6(e9) {
+  for (let t5 = e9; t5; t5 = r5(t5)) if (t5 instanceof Element && "none" === getComputedStyle(t5).display) return null;
+  for (let n5 = r5(e9); n5; n5 = r5(n5)) {
+    if (!(n5 instanceof Element)) continue;
+    const e10 = getComputedStyle(n5);
+    if ("contents" !== e10.display) {
+      if ("static" !== e10.position || isContainingBlock(e10)) return n5;
+      if ("BODY" === n5.tagName) return n5;
+    }
+  }
+  return null;
+}
+
+// src/components/popup/popup.css
+var popup_default = '/*! Popup is a low\u2010level utility built specifically for positioning elements. Do not mistake it for a tooltip or similar because it does not facilitate an accessible experience! Almost every correct usage of it will involve building other components. It should rarely, if ever, occur directly in your HTML. */\n\n:host {\n    --arrow-color: var(--pc-color-neutral-fill-normal);\n    --arrow-size: var(--pc-tooltip-arrow-size);\n\n    /* These properties are computed to account for the arrow\u2019s dimensions\n       after being rotated 45\xB0. The constant 0,7071 is derived from sin(45\xB0),\n       which is the diagonal size of the arrow\u2019s container after rotating. */\n    --arrow-size-diagonal: calc(var(--arrow-size) * 0.7071);\n    --arrow-padding-offset: calc(\n        var(--arrow-size-diagonal) - var(--arrow-size)\n    );\n\n    display: contents;\n}\n\n.popup {\n    position: absolute;\n    isolation: isolate;\n    max-inline-size: var(--auto-size-available-width, none);\n    max-block-size: var(--auto-size-available-height, none);\n    will-change: transform, top, left;\n\n    /* Reset user agent styles for the popover attribute. */\n    :where(&) {\n        inset: unset;\n        margin: unset;\n        padding: unset;\n        inline-size: unset;\n        block-size: unset;\n        /* inline-size and block-size do not affect the width and height\n           properties. This is redefined to be sure it is also unset. */\n        width: unset;\n        height: unset;\n        background: unset;\n        border: unset;\n        overflow: unset;\n    }\n}\n\n.fixed {\n    position: fixed;\n}\n\n.popup:not(.active) {\n    display: none;\n}\n\n.arrow {\n    position: absolute;\n    inline-size: calc(var(--arrow-size-diagonal) * 2);\n    block-size: calc(var(--arrow-size-diagonal) * 2);\n    background-color: var(--arrow-color);\n    rotate: 45deg;\n    z-index: 3;\n}\n\n:host([data-current-placement~="left"]) .arrow {\n    rotate: -45deg;\n}\n\n:host([data-current-placement~="right"]) .arrow {\n    rotate: 135deg;\n}\n\n:host([data-current-placement~="bottom"]) .arrow {\n    rotate: 225deg;\n}\n\n.hover-bridge:not(.hover-bridge-visible) {\n    display: none;\n}\n\n.hover-bridge {\n    position: fixed;\n    inset: 0;\n    clip-path: polygon(\n        var(--hover-bridge-top-left-x, 0) var(--hover-bridge-top-left-y, 0),\n        var(--hover-bridge-top-right-x, 0) var(--hover-bridge-top-right-y, 0),\n        var(--hover-bridge-bottom-right-x, 0)\n            var(--hover-bridge-bottom-right-y, 0),\n        var(--hover-bridge-bottom-left-x, 0)\n            var(--hover-bridge-bottom-left-y, 0)\n    );\n    z-index: 899;\n}\n';
+
+// src/components/popup/popup.ts
+function isVirtualElement(element) {
+  return element !== null && typeof element === "object" && "getBoundingClientRect" in element && ("contextElement" in element ? element instanceof Element : true);
+}
+var supportsPopover = globalThis?.HTMLElement?.prototype.hasOwnProperty("popover");
+var PcPopup = class extends PlacerElement {
+  constructor() {
+    super(...arguments);
+    this.localize = new LocalizeController2(this);
+    this.active = false;
+    this.placement = "top";
+    this.boundary = "viewport";
+    this.distance = 0;
+    this.skidding = 0;
+    this.arrow = false;
+    this.arrowPlacement = "anchor";
+    this.arrowPadding = 10;
+    this.flip = false;
+    this.flipFallbackPlacements = "";
+    this.flipFallbackStrategy = "best-fit";
+    this.flipPadding = 0;
+    this.shift = false;
+    this.shiftPadding = 0;
+    this.autoSizePadding = 0;
+    this.hoverBridge = false;
+    this.updateHoverBridge = () => {
+      if (this.hoverBridge && this.anchorElement) {
+        const anchorRect = this.anchorElement.getBoundingClientRect();
+        const popupRect = this.popup.getBoundingClientRect();
+        const isVertical = this.placement.includes("top") || this.placement.includes("bottom");
+        let topLeftX = 0;
+        let topLeftY = 0;
+        let topRightX = 0;
+        let topRightY = 0;
+        let bottomLeftX = 0;
+        let bottomLeftY = 0;
+        let bottomRightX = 0;
+        let bottomRightY = 0;
+        if (isVertical) {
+          if (anchorRect.top < popupRect.top) {
+            topLeftX = anchorRect.left;
+            topLeftY = anchorRect.bottom;
+            topRightX = anchorRect.right;
+            topRightY = anchorRect.bottom;
+            bottomLeftX = popupRect.left;
+            bottomLeftY = popupRect.top;
+            bottomRightX = popupRect.right;
+            bottomRightY = popupRect.top;
+          } else {
+            topLeftX = popupRect.left;
+            topLeftY = popupRect.bottom;
+            topRightX = popupRect.right;
+            topRightY = popupRect.bottom;
+            bottomLeftX = anchorRect.left;
+            bottomLeftY = anchorRect.top;
+            bottomRightX = anchorRect.right;
+            bottomRightY = anchorRect.top;
+          }
+        } else {
+          if (anchorRect.left < popupRect.left) {
+            topLeftX = anchorRect.right;
+            topLeftY = anchorRect.top;
+            topRightX = popupRect.left;
+            topRightY = popupRect.top;
+            bottomLeftX = anchorRect.right;
+            bottomLeftY = anchorRect.bottom;
+            bottomRightX = popupRect.left;
+            bottomRightY = popupRect.bottom;
+          } else {
+            topLeftX = popupRect.right;
+            topLeftY = popupRect.top;
+            topRightX = anchorRect.left;
+            topRightY = anchorRect.top;
+            bottomLeftX = popupRect.right;
+            bottomLeftY = popupRect.bottom;
+            bottomRightX = anchorRect.left;
+            bottomRightY = anchorRect.bottom;
+          }
+        }
+        this.style.setProperty(
+          "--hover-bridge-top-left-x",
+          `${topLeftX}px`
+        );
+        this.style.setProperty(
+          "--hover-bridge-top-left-y",
+          `${topLeftY}px`
+        );
+        this.style.setProperty(
+          "--hover-bridge-top-right-x",
+          `${topRightX}px`
+        );
+        this.style.setProperty(
+          "--hover-bridge-top-right-y",
+          `${topRightY}px`
+        );
+        this.style.setProperty(
+          "--hover-bridge-bottom-left-x",
+          `${bottomLeftX}px`
+        );
+        this.style.setProperty(
+          "--hover-bridge-bottom-left-y",
+          `${bottomLeftY}px`
+        );
+        this.style.setProperty(
+          "--hover-bridge-bottom-right-x",
+          `${bottomRightX}px`
+        );
+        this.style.setProperty(
+          "--hover-bridge-bottom-right-y",
+          `${bottomRightY}px`
+        );
+      }
+    };
+  }
+  async connectedCallback() {
+    super.connectedCallback();
+    await this.updateComplete;
+    this.start();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.stop();
+  }
+  async updated(changedProperties) {
+    super.updated(changedProperties);
+    if (changedProperties.has("active")) {
+      if (this.active) {
+        this.start();
+      } else {
+        this.stop();
+      }
+    }
+    if (changedProperties.has("anchor")) {
+      this.handleAnchorChange();
+    }
+    if (this.active) {
+      await this.updateComplete;
+      this.reposition();
+    }
+  }
+  async handleAnchorChange() {
+    await this.stop();
+    if (this.anchor && typeof this.anchor === "string") {
+      const root = this.getRootNode();
+      this.anchorElement = root.getElementById(this.anchor);
+    } else if (this.anchor instanceof Element || isVirtualElement(this.anchor)) {
+      this.anchorElement = this.anchor;
+    } else {
+      this.anchorElement = this.querySelector('[slot="anchor"]');
+    }
+    if (this.anchorElement instanceof HTMLSlotElement) {
+      this.anchorElement = this.anchorElement.assignedElements({
+        flatten: true
+      })[0];
+    }
+    if (this.anchorElement) {
+      this.start();
+    }
+  }
+  start() {
+    if (!this.anchorElement || !this.active) {
+      return;
+    }
+    this.popup.showPopover?.();
+    this.cleanup = autoUpdate(this.anchorElement, this.popup, () => {
+      this.reposition();
+    });
+  }
+  async stop() {
+    return new Promise((resolve) => {
+      this.popup.hidePopover?.();
+      if (this.cleanup) {
+        this.cleanup();
+        this.cleanup = void 0;
+        this.removeAttribute("data-current-placement");
+        this.style.removeProperty("--auto-size-available-width");
+        this.style.removeProperty("--auto-size-available-height");
+        requestAnimationFrame(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+  }
+  /** Forces the popup to recalculate and reposition itself. */
+  reposition() {
+    if (!this.active || !this.anchorElement) {
+      return;
+    }
+    const middleware = [
+      offset2({ mainAxis: this.distance, crossAxis: this.skidding })
+    ];
+    if (this.sync) {
+      middleware.push(
+        size2({
+          apply: ({ rects }) => {
+            const syncWidth = this.sync === "width" || this.sync === "both";
+            const syncHeight = this.sync === "height" || this.sync === "both";
+            this.popup.style.inlineSize = syncWidth ? `${rects.reference.width}px` : "";
+            this.popup.style.blockSize = syncHeight ? `${rects.reference.height}px` : "";
+          }
+        })
+      );
+    } else {
+      this.popup.style.inlineSize = "";
+      this.popup.style.blockSize = "";
+    }
+    let defaultBoundary;
+    if (supportsPopover && !isVirtualElement(this.anchor) && this.boundary === "scroll") {
+      defaultBoundary = getOverflowAncestors(
+        this.anchorElement
+      ).filter((element) => element instanceof Element);
+    }
+    if (this.flip) {
+      middleware.push(
+        flip2({
+          boundary: this.flipBoundary || defaultBoundary,
+          // @ts-expect-error — We’re converting the property type of “fallbackPlacements” from a string to an array
+          fallbackPlacements: this.flipFallbackPlacements,
+          fallbackStrategy: this.flipFallbackStrategy === "best-fit" ? "bestFit" : "initialPlacement",
+          padding: this.flipPadding
+        })
+      );
+    }
+    if (this.shift) {
+      middleware.push(
+        shift2({
+          boundary: this.shiftBoundary || defaultBoundary,
+          padding: this.shiftPadding
+        })
+      );
+    }
+    if (this.autoSize) {
+      middleware.push(
+        size2({
+          boundary: this.autoSizeBoundary || defaultBoundary,
+          padding: this.autoSizePadding,
+          apply: ({ availableWidth, availableHeight }) => {
+            if (this.autoSize === "vertical" || this.autoSize === "both") {
+              this.style.setProperty(
+                "--auto-size-available-height",
+                `${availableHeight}px`
+              );
+            } else {
+              this.style.removeProperty(
+                "--auto-size-available-height"
+              );
+            }
+            if (this.autoSize === "horizontal" || this.autoSize === "both") {
+              this.style.setProperty(
+                "--auto-size-available-width",
+                `${availableWidth}px`
+              );
+            } else {
+              this.style.removeProperty(
+                "--auto-size-available-width"
+              );
+            }
+          }
+        })
+      );
+    } else {
+      this.style.removeProperty("--auto-size-available-width");
+      this.style.removeProperty("--auto-size-available-height");
+    }
+    if (this.arrow) {
+      middleware.push(
+        arrow2({
+          element: this.arrowElement,
+          padding: this.arrowPadding
+        })
+      );
+    }
+    const getOffsetParent2 = supportsPopover ? (element) => platform.getOffsetParent(element, e8) : platform.getOffsetParent;
+    computePosition2(this.anchorElement, this.popup, {
+      placement: this.placement,
+      middleware,
+      strategy: supportsPopover ? "absolute" : "fixed",
+      platform: {
+        ...platform,
+        getOffsetParent: getOffsetParent2
+      }
+    }).then(({ x: x2, y: y3, middlewareData, placement }) => {
+      const isRTL2 = this.localize.dir() === "rtl";
+      const staticSide = {
+        top: "bottom",
+        right: "left",
+        bottom: "top",
+        left: "right"
+      }[placement.split("-")[0]];
+      this.setAttribute("data-current-placement", placement);
+      Object.assign(this.popup.style, {
+        left: `${x2}px`,
+        top: `${y3}px`
+      });
+      if (this.arrow) {
+        const arrowX = middlewareData.arrow.x;
+        const arrowY = middlewareData.arrow.y;
+        let top = "";
+        let right = "";
+        let bottom = "";
+        let left = "";
+        if (this.arrowPlacement === "start") {
+          const value = typeof arrowX === "number" ? `calc(${this.arrowPadding}px - var(--arrow-padding-offset))` : "";
+          top = typeof arrowY === "number" ? `calc(${this.arrowPadding}px - var(--arrow-padding-offset))` : "";
+          right = isRTL2 ? value : "";
+          left = isRTL2 ? "" : value;
+        } else if (this.arrowPlacement === "end") {
+          const value = typeof arrowX === "number" ? `calc(${this.arrowPadding}px - var(--arrow-padding-offset))` : "";
+          right = isRTL2 ? "" : value;
+          left = isRTL2 ? value : "";
+          bottom = typeof arrowY === "number" ? `calc(${this.arrowPadding}px - var(--arrow-padding-offset))` : "";
+        } else if (this.arrowPlacement === "center") {
+          left = typeof arrowX === "number" ? `calc(50% - var(--arrow-size-diagonal))` : "";
+          top = typeof arrowY === "number" ? `calc(50% - var(--arrow-size-diagonal))` : "";
+        } else {
+          left = typeof arrowX === "number" ? `${arrowX}px` : "";
+          top = typeof arrowY === "number" ? `${arrowY}px` : "";
+        }
+        Object.assign(this.arrowElement.style, {
+          top,
+          right,
+          bottom,
+          left,
+          [staticSide]: "calc(var(--arrow-size-diagonal) * -1)"
+        });
+      }
+    });
+    requestAnimationFrame(() => this.updateHoverBridge());
+    emit(this, "pc-reposition");
+  }
+  render() {
+    return x`
+            <slot name="anchor" @slotchange=${this.handleAnchorChange}></slot>
+
+            <span
+                part="hover-bridge"
+                class=${e7({
+      "hover-bridge": true,
+      "hover-bridge-visible": this.hoverBridge && this.active
+    })}
+            ></span>
+
+            <div
+                part="popup"
+                popover="manual"
+                class=${e7({
+      "popup": true,
+      "active": this.active,
+      "fixed": !supportsPopover,
+      "has-arrow": this.arrow
+    })}
+            >
+                <slot></slot>
+                ${this.arrow ? x`
+                          <div
+                              part="arrow"
+                              class="arrow"
+                              role="presentation"
+                          ></div>
+                      ` : ""}
+            </div>
+        `;
+  }
+};
+/** @internal This is an internal static property. */
+PcPopup.css = popup_default;
+__decorateClass([
+  e5(".popup")
+], PcPopup.prototype, "popup", 2);
+__decorateClass([
+  e5(".arrow")
+], PcPopup.prototype, "arrowElement", 2);
+__decorateClass([
+  n4()
+], PcPopup.prototype, "anchor", 2);
+__decorateClass([
+  n4({ type: Boolean, reflect: true })
+], PcPopup.prototype, "active", 2);
+__decorateClass([
+  n4({ reflect: true })
+], PcPopup.prototype, "placement", 2);
+__decorateClass([
+  n4()
+], PcPopup.prototype, "boundary", 2);
+__decorateClass([
+  n4({ type: Number })
+], PcPopup.prototype, "distance", 2);
+__decorateClass([
+  n4({ type: Number })
+], PcPopup.prototype, "skidding", 2);
+__decorateClass([
+  n4({ type: Boolean })
+], PcPopup.prototype, "arrow", 2);
+__decorateClass([
+  n4({ attribute: "arrow-placement" })
+], PcPopup.prototype, "arrowPlacement", 2);
+__decorateClass([
+  n4({ attribute: "arrow-padding", type: Number })
+], PcPopup.prototype, "arrowPadding", 2);
+__decorateClass([
+  n4({ type: Boolean })
+], PcPopup.prototype, "flip", 2);
+__decorateClass([
+  n4({
+    attribute: "flip-fallback-placements",
+    converter: {
+      fromAttribute: (value) => {
+        return value.split(" ").map((placement) => placement.trim()).filter((placement) => placement !== "");
+      },
+      toAttribute: (value) => {
+        return value.join(" ");
+      }
+    }
+  })
+], PcPopup.prototype, "flipFallbackPlacements", 2);
+__decorateClass([
+  n4({ attribute: "flip-fallback-strategy" })
+], PcPopup.prototype, "flipFallbackStrategy", 2);
+__decorateClass([
+  n4({ type: Object })
+], PcPopup.prototype, "flipBoundary", 2);
+__decorateClass([
+  n4({ attribute: "flip-padding", type: Number })
+], PcPopup.prototype, "flipPadding", 2);
+__decorateClass([
+  n4({ type: Boolean })
+], PcPopup.prototype, "shift", 2);
+__decorateClass([
+  n4({ type: Object })
+], PcPopup.prototype, "shiftBoundary", 2);
+__decorateClass([
+  n4({ attribute: "shift-padding", type: Number })
+], PcPopup.prototype, "shiftPadding", 2);
+__decorateClass([
+  n4({ attribute: "auto-size" })
+], PcPopup.prototype, "autoSize", 2);
+__decorateClass([
+  n4()
+], PcPopup.prototype, "sync", 2);
+__decorateClass([
+  n4({ type: Object })
+], PcPopup.prototype, "autoSizeBoundary", 2);
+__decorateClass([
+  n4({ attribute: "auto-size-padding", type: Number })
+], PcPopup.prototype, "autoSizePadding", 2);
+__decorateClass([
+  n4({ attribute: "hover-bridge", type: Boolean })
+], PcPopup.prototype, "hoverBridge", 2);
+PcPopup = __decorateClass([
+  t3("pc-popup")
+], PcPopup);
+
+// src/styles/utilities/size.css
+var size_default = '@layer pc-utilities {\n    :host([size="small"]),\n    .pc-size-s {\n        font-size: var(--pc-font-size-s);\n    }\n\n    :host([size="medium"]),\n    .pc-size-m {\n        font-size: var(--pc-font-size-m);\n    }\n\n    :host([size="large"]),\n    .pc-size-l {\n        font-size: var(--pc-font-size-l);\n    }\n}\n';
+
+// src/components/dropdown/dropdown.css
+var dropdown_default = ':host {\n    display: contents;\n}\n\n#menu {\n    display: flex;\n    flex-direction: column;\n    margin: 0;\n    padding: 0.25em;\n    inline-size: max-content;\n    max-inline-size: var(--auto-size-available-width) !important;\n    max-block-size: var(--auto-size-available-height) !important;\n    background-color: var(--pc-color-surface-raised);\n    color: var(--pc-color-text-normal);\n    border: var(--pc-border-width-s) var(--pc-border-style)\n        var(--pc-color-surface-border);\n    border-radius: calc(var(--pc-border-radius-m) + 0.25em);\n    text-align: start;\n    user-select: none;\n    overflow: auto;\n    box-shadow: var(--pc-shadow-m);\n}\n\n#menu ::slotted(h1),\n#menu ::slotted(h2),\n#menu ::slotted(h3),\n#menu ::slotted(h4),\n#menu ::slotted(h5),\n#menu ::slotted(h6) {\n    display: block !important;\n    margin-block: 0.25em !important;\n    margin-inline: 0 !important;\n    padding-block: 0.25em !important;\n    padding-inline: 1.1em !important;\n    color: var(--pc-color-text-quiet) !important;\n    font-family: var(--pc-font-sans) !important;\n    font-weight: var(--pc-font-weight-semibold) !important;\n    font-size: var(--pc-font-size-smaller) !important;\n}\n\n#menu ::slotted(pc-dropdown-item[checkbox-adjacent]) h1,\n#menu ::slotted(pc-dropdown-item[checkbox-adjacent]) h2,\n#menu ::slotted(pc-dropdown-item[checkbox-adjacent]) h3,\n#menu ::slotted(pc-dropdown-item[checkbox-adjacent]) h4,\n#menu ::slotted(pc-dropdown-item[checkbox-adjacent]) h5,\n#menu ::slotted(pc-dropdown-item[checkbox-adjacent]) h6 {\n    padding-inline: 2.25em !important;\n}\n\n#menu ::slotted(pc-divider) {\n    --spacing: 0.25em;\n}\n\npc-popup[data-current-placement^="top"] #menu {\n    transform-origin: bottom;\n}\n\npc-popup[data-current-placement^="bottom"] #menu {\n    transform-origin: top;\n}\n\npc-popup[data-current-placement^="left"] #menu {\n    transform-origin: right;\n}\n\npc-popup[data-current-placement^="right"] #menu {\n    transform-origin: left;\n}\n\npc-popup[data-current-placement="left-start"] #menu {\n    transform-origin: right top;\n}\n\npc-popup[data-current-placement="left-end"] #menu {\n    transform-origin: right bottom;\n}\n\npc-popup[data-current-placement="right-start"] #menu {\n    transform-origin: left top;\n}\n\npc-popup[data-current-placement="right-end"] #menu {\n    transform-origin: left bottom;\n}\n';
+
+// src/components/dropdown/dropdown.ts
+var openDropdowns = /* @__PURE__ */ new Set();
+setDefaultAnimation("dropdown.show", {
+  keyframes: [
+    {
+      offset: 0,
+      opacity: 0,
+      transform: "scaleY(0.35) scaleX(0.95) translateY(-10px) rotate(1deg)"
+    },
+    {
+      offset: 0.25,
+      opacity: 1,
+      transform: "scaleY(1.03) scaleX(1.005) translateY(2px) rotate(-0.5deg)"
+    },
+    {
+      offset: 0.5,
+      transform: "scaleY(0.995) scaleX(0.999) translateY(-0.5px) rotate(0.1deg)"
+    },
+    {
+      offset: 0.75,
+      transform: "scaleY(1.002) scaleX(1.0005) translateY(0.2px) rotate(-0.05deg)"
+    },
+    {
+      offset: 1,
+      opacity: 1,
+      transform: "scaleY(1) scaleX(1) translateY(0) rotate(0deg)"
+    }
+  ],
+  options: {
+    duration: 1e3,
+    easing: "cubic-bezier(0.2, 0.8, 0.2, 1)",
+    fill: "forwards"
+  }
+});
+setDefaultAnimation("dropdown.hide", {
+  keyframes: [
+    {
+      offset: 0,
+      opacity: 1,
+      transform: "scaleY(1) scaleX(1) translateY(0) rotate(0deg)"
+    },
+    {
+      offset: 0.15,
+      transform: "scaleY(1.005) scaleX(1.001) translateY(0.5px) rotate(-0.002deg)"
+    },
+    {
+      offset: 0.4,
+      transform: "scaleY(0.99) scaleX(0.998) translateY(-1px) rotate(0.008deg)"
+    },
+    {
+      offset: 0.75,
+      transform: "scaleY(0.6) scaleX(0.9) translateY(10px) rotate(0.007deg)"
+    },
+    {
+      offset: 1,
+      opacity: 0,
+      transform: "scaleY(0.3) scaleX(0.8) translateY(25px) rotate(0.01deg)"
+    }
+  ],
+  options: {
+    duration: 400,
+    easing: "cubic-bezier(0.6, 0.05, 0.8, 0.2)",
+    fill: "forwards"
+  }
+});
+var PcDropdown = class extends PlacerElement {
+  constructor() {
+    super(...arguments);
+    this.submenuCleanups = /* @__PURE__ */ new Map();
+    this.localize = new LocalizeController2(this);
+    this.userTypedQuery = "";
+    this.openSubmenuStack = [];
+    this.open = false;
+    this.size = "medium";
+    this.placement = "bottom-start";
+    this.distance = 0;
+    this.skidding = 0;
+    /** Handles key down events when the menu is open. */
+    this.handleDocumentKeyDown = async (event) => {
+      const isRTL2 = this.localize.dir() === "rtl";
+      if (event.key === "Escape") {
+        const trigger = this.getTrigger();
+        event.preventDefault();
+        event.stopPropagation();
+        this.open = false;
+        trigger?.focus();
+        return;
+      }
+      const activeElement = [...activeElements()].find(
+        (element) => element.localName === "pc-dropdown-item"
+      );
+      const isFocusedOnItem = activeElement?.localName === "pc-dropdown-item";
+      const currentSubmenuItem = this.getCurrentSubmenuItem();
+      const isInSubmenu = !!currentSubmenuItem;
+      let items;
+      let activeItem;
+      let activeItemIndex;
+      if (isInSubmenu) {
+        items = this.getSubmenuItems(currentSubmenuItem);
+        activeItem = items.find(
+          (item) => item.active || item === activeElement
+        );
+        activeItemIndex = activeItem ? items.indexOf(activeItem) : -1;
+      } else {
+        items = this.getItems();
+        activeItem = items.find(
+          (item) => item.active || item === activeElement
+        );
+        activeItemIndex = activeItem ? items.indexOf(activeItem) : -1;
+      }
+      let itemToSelect;
+      if (event.key === "ArrowUp") {
+        event.preventDefault();
+        event.stopPropagation();
+        if (activeItemIndex > 0) {
+          itemToSelect = items[activeItemIndex - 1];
+        } else {
+          itemToSelect = items[items.length - 1];
+        }
+      }
+      if (event.key === "ArrowDown") {
+        event.preventDefault();
+        event.stopPropagation();
+        if (activeItemIndex !== -1 && activeItemIndex < items.length - 1) {
+          itemToSelect = items[activeItemIndex + 1];
+        } else {
+          itemToSelect = items[0];
+        }
+      }
+      if (event.key === (isRTL2 ? "ArrowLeft" : "ArrowRight") && isFocusedOnItem && activeItem) {
+        if (activeItem.hasSubmenu) {
+          event.preventDefault();
+          event.stopPropagation();
+          activeItem.submenuOpen = true;
+          this.addToSubmenuStack(activeItem);
+          setTimeout(() => {
+            const submenuItems = this.getSubmenuItems(activeItem);
+            if (submenuItems.length > 0) {
+              submenuItems.forEach(
+                (item, index) => item.active = index === 0
+              );
+              submenuItems[0].focus();
+            }
+          }, 0);
+          return;
+        }
+      }
+      if (event.key === (isRTL2 ? "ArrowRight" : "ArrowLeft") && isInSubmenu) {
+        event.preventDefault();
+        event.stopPropagation();
+        const removedItem = this.removeFromSubmenuStack();
+        if (removedItem) {
+          removedItem.submenuOpen = false;
+          setTimeout(() => {
+            removedItem.focus();
+            removedItem.active = true;
+            const parentItems = removedItem.slot === "submenu" ? this.getSubmenuItems(
+              removedItem.parentElement
+            ) : this.getItems();
+            parentItems.forEach((item) => {
+              if (item !== removedItem) {
+                item.active = false;
+              }
+            });
+          }, 0);
+        }
+        return;
+      }
+      if (event.key === "Home" || event.key === "End") {
+        event.preventDefault();
+        event.stopPropagation();
+        itemToSelect = event.key === "Home" ? items[0] : items[items.length - 1];
+      }
+      if (event.key === "Tab") {
+        await this.hideMenu();
+      }
+      if (event.key.length === 1 && !(event.metaKey || event.ctrlKey || event.altKey) && !(event.key === " " && this.userTypedQuery === "")) {
+        clearTimeout(this.userTypedTimeout);
+        this.userTypedTimeout = setTimeout(() => {
+          this.userTypedQuery = "";
+        }, 1e3);
+        this.userTypedQuery += event.key;
+        items.some((item) => {
+          const label = (item.textContent || "").trim().toLowerCase();
+          const selectionQuery = this.userTypedQuery.trim().toLowerCase();
+          if (label.startsWith(selectionQuery)) {
+            itemToSelect = item;
+            return true;
+          }
+          return false;
+        });
+      }
+      if (itemToSelect) {
+        event.preventDefault();
+        event.stopPropagation();
+        items.forEach((item) => item.active = item === itemToSelect);
+        itemToSelect.focus();
+        return;
+      }
+      if ((event.key === "Enter" || event.key === " " && this.userTypedQuery === "") && isFocusedOnItem && activeItem) {
+        event.preventDefault();
+        event.stopPropagation();
+        if (activeItem.hasSubmenu) {
+          activeItem.submenuOpen = true;
+          this.addToSubmenuStack(activeItem);
+          setTimeout(() => {
+            const submenuItems = this.getSubmenuItems(activeItem);
+            if (submenuItems.length > 0) {
+              submenuItems.forEach(
+                (item, index) => item.active = index === 0
+              );
+              submenuItems[0].focus();
+            }
+          }, 0);
+        } else {
+          this.makeSelection(activeItem);
+        }
+      }
+    };
+    /** Handles pointer down events when the dropdown is open. */
+    this.handleDocumentPointerDown = (event) => {
+      const path = event.composedPath();
+      const isInDropdownHierarchy = path.some((element) => {
+        if (element instanceof HTMLElement) {
+          return element === this || element.closest('pc-dropdown, [part="submenu"]');
+        }
+        return false;
+      });
+      if (!isInDropdownHierarchy) {
+        this.open = false;
+      }
+    };
+    /** Handle global mouse movement for safe triangle logic. */
+    this.handleGlobalMouseMove = (event) => {
+      const currentSubmenuItem = this.getCurrentSubmenuItem();
+      if (!currentSubmenuItem?.submenuOpen || !currentSubmenuItem.submenuElement) {
+        return;
+      }
+      const submenuRect = currentSubmenuItem.submenuElement.getBoundingClientRect();
+      const isRTL2 = this.localize.dir() === "rtl";
+      const submenuEdgeX = isRTL2 ? submenuRect.right : submenuRect.left;
+      const constrainedX = isRTL2 ? Math.max(event.clientX, submenuEdgeX) : Math.min(event.clientX, submenuEdgeX);
+      const constrainedY = Math.max(
+        submenuRect.top,
+        Math.min(event.clientY, submenuRect.bottom)
+      );
+      currentSubmenuItem.submenuElement.style.setProperty(
+        "--safe-triangle-cursor-x",
+        `${constrainedX}px`
+      );
+      currentSubmenuItem.submenuElement.style.setProperty(
+        "--safe-triangle-cursor-y",
+        `${constrainedY}px`
+      );
+      const isOverItem = currentSubmenuItem.matches(":hover");
+      const isOverSubmenu = currentSubmenuItem.submenuElement?.matches(":hover") || !!event.composedPath().find(
+        (element) => element instanceof HTMLElement && element.closest('[part="submenu"]') === currentSubmenuItem.submenuElement
+      );
+      if (!isOverItem && !isOverSubmenu) {
+        setTimeout(() => {
+          if (!currentSubmenuItem.matches(":hover") && !currentSubmenuItem.submenuElement?.matches(":hover")) {
+            currentSubmenuItem.submenuOpen = false;
+          }
+        }, 100);
+      }
+    };
+  }
+  firstUpdated() {
+    this.syncARIAAttributes();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    clearInterval(this.userTypedTimeout);
+    this.closeAllSubmenus();
+    this.submenuCleanups.forEach((cleanup) => cleanup());
+    this.submenuCleanups.clear();
+    document.removeEventListener("mousemove", this.handleGlobalMouseMove);
+  }
+  async updated(changedProperties) {
+    if (changedProperties.has("open")) {
+      this.customStates.set("open", this.open);
+      if (this.open) {
+        await this.showMenu();
+      } else {
+        this.closeAllSubmenus();
+        await this.hideMenu();
+      }
+    }
+    if (changedProperties.has("size")) {
+      this.syncItemSizes();
+    }
+  }
+  /** Gets all dropdown items slotted in the menu. */
+  getItems(includeDisabled = false) {
+    const items = this.defaultSlot.assignedElements({ flatten: true }).filter(
+      (element) => element.localName === "pc-dropdown-item"
+    );
+    return includeDisabled ? items : items.filter((item) => !item.disabled);
+  }
+  /** Gets all dropdown items in a specific submenu. */
+  getSubmenuItems(parentItem, includeDisabled = false) {
+    const submenuSlot = parentItem.shadowRoot?.querySelector(
+      'slot[name="submenu"]'
+    ) || parentItem.querySelector('slot[name="submenu"]');
+    if (!submenuSlot) {
+      return [];
+    }
+    const items = submenuSlot.assignedElements({ flatten: true }).filter(
+      (element) => element.localName === "pc-dropdown-item"
+    );
+    return includeDisabled ? items : items.filter((item) => !item.disabled);
+  }
+  /** Syncs item sizes with the dropdown’s size property. */
+  syncItemSizes() {
+    const items = this.defaultSlot.assignedElements({ flatten: true }).filter(
+      (element) => element.localName === "pc-dropdown-item"
+    );
+    items.forEach((item) => item.size = this.size);
+  }
+  /** Handles the submenu navigation stack. */
+  addToSubmenuStack(item) {
+    const index = this.openSubmenuStack.indexOf(item);
+    if (index !== -1) {
+      this.openSubmenuStack = this.openSubmenuStack.slice(0, index + 1);
+    } else {
+      this.openSubmenuStack.push(item);
+    }
+  }
+  /** Removes the last item from the submenu stack. */
+  removeFromSubmenuStack() {
+    return this.openSubmenuStack.pop();
+  }
+  /** Gets the current active submenu item. */
+  getCurrentSubmenuItem() {
+    return this.openSubmenuStack.length > 0 ? this.openSubmenuStack[this.openSubmenuStack.length - 1] : void 0;
+  }
+  /** Closes all submenus in the dropdown. */
+  closeAllSubmenus() {
+    const items = this.getItems(true);
+    items.forEach((item) => {
+      item.submenuOpen = false;
+    });
+    this.openSubmenuStack = [];
+  }
+  /** Closes sibling submenus at the same level as the specified item. */
+  closeSiblingSubmenus(item) {
+    const parentDropdownItem = item.closest(
+      'pc-dropdown-item:not([slot="submenu"])'
+    );
+    let siblingItems;
+    if (parentDropdownItem) {
+      siblingItems = this.getSubmenuItems(parentDropdownItem, true);
+    } else {
+      siblingItems = this.getItems(true);
+    }
+    siblingItems.forEach((siblingItem) => {
+      if (siblingItem !== item && siblingItem.submenuOpen) {
+        siblingItem.submenuOpen = false;
+      }
+    });
+    if (!this.openSubmenuStack.includes(item)) {
+      this.openSubmenuStack.push(item);
+    }
+  }
+  /** Get the slotted trigger button, a <pc-button> or <button> element. */
+  getTrigger() {
+    return this.querySelector(
+      '[slot="trigger"]'
+    );
+  }
+  /** Shows the dropdown menu. This should be only called from within `updated()`. */
+  async showMenu() {
+    const anchor = this.getTrigger();
+    if (!anchor) {
+      return;
+    }
+    const pcShow = emit(this, "pc-show", {
+      cancelable: true
+    });
+    if (pcShow.defaultPrevented) {
+      this.open = false;
+      return;
+    }
+    openDropdowns.forEach((dropdown) => dropdown.open = false);
+    this.popup.active = true;
+    this.open = true;
+    openDropdowns.add(this);
+    this.syncARIAAttributes();
+    document.addEventListener("keydown", this.handleDocumentKeyDown);
+    document.addEventListener(
+      "pointerdown",
+      this.handleDocumentPointerDown
+    );
+    document.addEventListener("mousemove", this.handleGlobalMouseMove);
+    this.menu.hidden = false;
+    const { keyframes, options } = getAnimation(this, "dropdown.show", {
+      dir: this.localize.dir()
+    });
+    await animateTo(this.menu, keyframes, options);
+    await stopAnimations(this);
+    const items = this.getItems();
+    if (items.length > 0) {
+      items.forEach((item, index) => item.active = index === 0);
+      items[0].focus();
+    }
+    emit(this, "pc-after-show");
+  }
+  /** Hides the dropdown menu. This should be only called from within `updated()`. */
+  async hideMenu() {
+    const pcHide = emit(this, "pc-hide", {
+      cancelable: true
+    });
+    if (pcHide.defaultPrevented) {
+      this.open = true;
+      return;
+    }
+    this.open = false;
+    openDropdowns.delete(this);
+    this.syncARIAAttributes();
+    document.removeEventListener("keydown", this.handleDocumentKeyDown);
+    document.removeEventListener(
+      "pointerdown",
+      this.handleDocumentPointerDown
+    );
+    document.removeEventListener("mousemove", this.handleGlobalMouseMove);
+    const { keyframes, options } = getAnimation(this, "dropdown.hide", {
+      dir: this.localize.dir()
+    });
+    await animateTo(this.menu, keyframes, options);
+    await stopAnimations(this);
+    this.menu.hidden = true;
+    emit(this, "pc-after-hide");
+  }
+  /** Handles clicks on the menu. */
+  handleMenuClick(event) {
+    const item = event.target.closest("pc-dropdown-item");
+    if (!item || item.disabled) {
+      return;
+    }
+    if (item.hasSubmenu) {
+      if (!item.submenuOpen) {
+        this.closeSiblingSubmenus(item);
+        this.addToSubmenuStack(item);
+        item.submenuOpen = true;
+      }
+      event.stopPropagation();
+      return;
+    }
+    this.makeSelection(item);
+  }
+  /** Prepares dropdown items when they get added or removed. */
+  async handleMenuSlotChange() {
+    const items = this.getItems(true);
+    await Promise.all(items.map((item) => item.updateComplete));
+    this.syncItemSizes();
+    const hasCheckbox = items.some((item) => item.type === "checkbox");
+    const hasSubmenu = items.some((item) => item.hasSubmenu);
+    items.forEach((item, index) => {
+      item.active = index === 0;
+      item.checkboxAdjacent = hasCheckbox;
+      item.submenuAdjacent = hasSubmenu;
+    });
+  }
+  /** Toggles the dropdown menu. */
+  handleTriggerClick() {
+    this.open = !this.open;
+  }
+  /** Handles submenu opening events. */
+  handleSubmenuOpening(event) {
+    const openingItem = event.detail.item;
+    this.closeSiblingSubmenus(openingItem);
+    this.addToSubmenuStack(openingItem);
+    this.setupSubmenuPosition(openingItem);
+    this.processSubmenuItems(openingItem);
+  }
+  /** Sets up submenu positioning with `autoUpdate`. */
+  setupSubmenuPosition(item) {
+    if (!item.submenuElement) {
+      return;
+    }
+    this.cleanupSubmenuPosition(item);
+    const cleanup = autoUpdate(item, item.submenuElement, () => {
+      this.positionSubmenu(item);
+      this.updateSafeTriangleCoordinates(item);
+    });
+    this.submenuCleanups.set(item, cleanup);
+    const submenuSlot = item.submenuElement.querySelector(
+      'slot[name="submenu"]'
+    );
+    if (submenuSlot) {
+      submenuSlot.removeEventListener(
+        "slotchange",
+        PcDropdown.handleSubmenuSlotChange
+      );
+      submenuSlot.addEventListener(
+        "slotchange",
+        PcDropdown.handleSubmenuSlotChange
+      );
+      PcDropdown.handleSubmenuSlotChange({
+        target: submenuSlot
+      });
+    }
+  }
+  static handleSubmenuSlotChange(event) {
+    const slot = event.target;
+    if (!slot) {
+      return;
+    }
+    const items = slot.assignedElements().filter(
+      (element) => element.localName === "pc-dropdown-item"
+    );
+    if (items.length === 0) {
+      return;
+    }
+    const hasSubmenuItems = items.some((item) => item.hasSubmenu);
+    const hasCheckboxItems = items.some((item) => item.type === "checkbox");
+    items.forEach((item) => {
+      item.submenuAdjacent = hasSubmenuItems;
+      item.checkboxAdjacent = hasCheckboxItems;
+    });
+  }
+  processSubmenuItems(item) {
+    if (!item.submenuElement) {
+      return;
+    }
+    const submenuItems = this.getSubmenuItems(item, true);
+    const hasSubmenuItems = submenuItems.some(
+      (subItem) => subItem.hasSubmenu
+    );
+    const hasCheckboxItems = submenuItems.some(
+      (subItem) => subItem.type === "checkbox"
+    );
+    submenuItems.forEach((subItem) => {
+      subItem.submenuAdjacent = hasSubmenuItems;
+      subItem.checkboxAdjacent = hasCheckboxItems;
+    });
+  }
+  /** Cleans up the submenu positioning. */
+  cleanupSubmenuPosition(item) {
+    const cleanup = this.submenuCleanups.get(item);
+    if (cleanup) {
+      cleanup();
+      this.submenuCleanups.delete(item);
+    }
+  }
+  /** Positions a submenu relative to its parent item. */
+  positionSubmenu(item) {
+    if (!item.submenuElement) {
+      return;
+    }
+    const isRTL2 = this.localize.dir() === "rtl";
+    const placement = isRTL2 ? "left-start" : "right-start";
+    computePosition2(item, item.submenuElement, {
+      placement,
+      middleware: [
+        offset2({
+          mainAxis: 0,
+          crossAxis: -5
+        }),
+        flip2({
+          fallbackStrategy: "bestFit"
+        }),
+        shift2({
+          padding: 8
+        })
+      ]
+    }).then(({ x: x2, y: y3, placement: placement2 }) => {
+      item.submenuElement.setAttribute("data-placement", placement2);
+      Object.assign(item.submenuElement.style, {
+        left: `${x2}px`,
+        top: `${y3}px`
+      });
+    });
+  }
+  /** Updates the safe triangle coordinates for a submenu. */
+  updateSafeTriangleCoordinates(item) {
+    if (!item.submenuElement || !item.submenuOpen) {
+      return;
+    }
+    const isKeyboardNavigation = document.activeElement?.matches(":focus-visible");
+    if (isKeyboardNavigation) {
+      item.submenuElement.style.setProperty(
+        "--safe-triangle-visible",
+        "none"
+      );
+      return;
+    }
+    item.submenuElement.style.setProperty(
+      "--safe-triangle-visible",
+      "block"
+    );
+    const submenuRect = item.submenuElement.getBoundingClientRect();
+    const isRTL2 = this.localize.dir() === "rtl";
+    item.submenuElement.style.setProperty(
+      "--safe-triangle-submenu-start-x",
+      `${isRTL2 ? submenuRect.right : submenuRect.left}px`
+    );
+    item.submenuElement.style.setProperty(
+      "--safe-triangle-submenu-start-y",
+      `${submenuRect.top}px`
+    );
+    item.submenuElement.style.setProperty(
+      "--safe-triangle-submenu-end-x",
+      `${isRTL2 ? submenuRect.right : submenuRect.left}px`
+    );
+    item.submenuElement.style.setProperty(
+      "--safe-triangle-submenu-end-y",
+      `${submenuRect.bottom}px`
+    );
+  }
+  /** Makes a selection, emits the `pc-select` event and closes the dropdown. */
+  makeSelection(item) {
+    const trigger = this.getTrigger();
+    if (item.disabled) {
+      return;
+    }
+    if (item.type === "checkbox") {
+      item.checked = !item.checked;
+    }
+    const pcSelect = emit(this, "pc-select", {
+      cancelable: true,
+      detail: { item }
+    });
+    if (!pcSelect.defaultPrevented) {
+      this.open = false;
+      trigger?.focus();
+    }
+  }
+  /** Syncs ARIA attributes on the slotted trigger element and the menu based on the dropdown’s current state. */
+  async syncARIAAttributes() {
+    const trigger = this.getTrigger();
+    let nativeButton;
+    if (!trigger) {
+      return;
+    }
+    if (trigger.localName === "pc-button") {
+      await customElements.whenDefined("pc-button");
+      await trigger.updateComplete;
+      nativeButton = trigger.shadowRoot.querySelector(
+        '[part="base"]'
+      );
+    } else {
+      nativeButton = trigger;
+    }
+    if (!nativeButton.hasAttribute("id")) {
+      nativeButton.setAttribute("id", uniqueID("pc-dropdown-trigger-"));
+    }
+    nativeButton.setAttribute("aria-haspopup", "menu");
+    nativeButton.setAttribute(
+      "aria-expanded",
+      this.open ? "true" : "false"
+    );
+    this.menu.setAttribute("aria-expanded", "false");
+  }
+  render() {
+    let active = this.hasUpdated ? this.popup.active : this.open;
+    return x`
+            <pc-popup
+                placement=${this.placement}
+                distance=${this.distance}
+                skidding=${this.skidding}
+                ?active=${active}
+                flip-fallback-strategy="best-fit"
+                shift-padding="10"
+                auto-size="vertical"
+                auto-size-padding="10"
+                shift
+                flip
+            >
+                <slot
+                    name="trigger"
+                    slot="anchor"
+                    @click=${this.handleTriggerClick}
+                    @slotchange=${this.syncARIAAttributes}
+                ></slot>
+
+                <div
+                    part="menu"
+                    id="menu"
+                    role="menu"
+                    tabindex="-1"
+                    aria-orientation="vertical"
+                    @click=${this.handleMenuClick}
+                    @pc-submenu-opening=${this.handleSubmenuOpening}
+                >
+                    <slot @slotchange=${this.handleMenuSlotChange}></slot>
+                </div>
+            </pc-popup>
+        `;
+  }
+};
+/** @internal This is an internal static property. */
+PcDropdown.css = [size_default, dropdown_default];
+/** @internal This is an internal static property. */
+PcDropdown.dependencies = { "pc-popup": PcPopup };
+__decorateClass([
+  e5("slot:not([name])")
+], PcDropdown.prototype, "defaultSlot", 2);
+__decorateClass([
+  e5("#menu")
+], PcDropdown.prototype, "menu", 2);
+__decorateClass([
+  e5("pc-popup")
+], PcDropdown.prototype, "popup", 2);
+__decorateClass([
+  n4({ type: Boolean, reflect: true })
+], PcDropdown.prototype, "open", 2);
+__decorateClass([
+  n4({ reflect: true })
+], PcDropdown.prototype, "size", 2);
+__decorateClass([
+  n4({ reflect: true })
+], PcDropdown.prototype, "placement", 2);
+__decorateClass([
+  n4({ type: Number })
+], PcDropdown.prototype, "distance", 2);
+__decorateClass([
+  n4({ type: Number })
+], PcDropdown.prototype, "skidding", 2);
+PcDropdown = __decorateClass([
+  t3("pc-dropdown")
+], PcDropdown);
+export {
+  PcDropdown
+};
+//! Popup is a low‐level utility built specifically for positioning elements. Do not mistake it for a tooltip or similar because it does not facilitate an accessible experience! Almost every correct usage of it will involve building other components. It should rarely, if ever, occur directly in your HTML.
+/*! Bundled license information:
+
+@lit/reactive-element/css-tag.js:
+  (**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+
+@lit/reactive-element/reactive-element.js:
+lit-html/lit-html.js:
+lit-element/lit-element.js:
+@lit/reactive-element/decorators/custom-element.js:
+@lit/reactive-element/decorators/property.js:
+@lit/reactive-element/decorators/state.js:
+@lit/reactive-element/decorators/event-options.js:
+@lit/reactive-element/decorators/base.js:
+@lit/reactive-element/decorators/query.js:
+@lit/reactive-element/decorators/query-all.js:
+@lit/reactive-element/decorators/query-async.js:
+@lit/reactive-element/decorators/query-assigned-nodes.js:
+lit-html/directive.js:
+  (**
+   * @license
+   * Copyright 2017 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+
+lit-html/is-server.js:
+  (**
+   * @license
+   * Copyright 2022 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+
+@lit/reactive-element/decorators/query-assigned-elements.js:
+  (**
+   * @license
+   * Copyright 2021 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+
+lit-html/directives/class-map.js:
+  (**
+   * @license
+   * Copyright 2018 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+*/