@geoscene/charts-components 5.0.19

package/dist/cdn/KRZ433BT.js

@@ -0,0 +1,2106 @@
+/* COPYRIGHT  - https://js.geoscene.cn/5.0/LICENSE.txt */
+var Y = globalThis,
+  Z =
+    Y.ShadowRoot &&
+    (Y.ShadyCSS === void 0 || Y.ShadyCSS.nativeShadow) &&
+    "adoptedStyleSheets" in Document.prototype &&
+    "replace" in CSSStyleSheet.prototype,
+  gt = Symbol(),
+  Rt = new WeakMap(),
+  k = class {
+    constructor(t, e, s) {
+      if (((this._$cssResult$ = !0), s !== gt))
+        throw Error(
+          "CSSResult is not constructable. Use `unsafeCSS` or `css` instead."
+        );
+      (this.cssText = t), (this.t = e);
+    }
+    get styleSheet() {
+      let t = this.o,
+        e = this.t;
+      if (Z && t === void 0) {
+        let s = e !== void 0 && e.length === 1;
+        s && (t = Rt.get(e)),
+          t === void 0 &&
+            ((this.o = t = new CSSStyleSheet()).replaceSync(this.cssText),
+            s && Rt.set(e, t));
+      }
+      return t;
+    }
+    toString() {
+      return this.cssText;
+    }
+  },
+  Mt = (o) => new k(typeof o == "string" ? o : o + "", void 0, gt),
+  be = (o, ...t) => {
+    let e =
+      o.length === 1
+        ? o[0]
+        : t.reduce(
+            (s, r, i) =>
+              s +
+              ((n) => {
+                if (n._$cssResult$ === !0) return n.cssText;
+                if (typeof n == "number") return n;
+                throw Error(
+                  "Value passed to 'css' function must be a 'css' function result: " +
+                    n +
+                    ". Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security."
+                );
+              })(r) +
+              o[i + 1],
+            o[0]
+          );
+    return new k(e, o, gt);
+  },
+  It = (o, t) => {
+    if (Z)
+      o.adoptedStyleSheets = t.map((e) =>
+        e instanceof CSSStyleSheet ? e : e.styleSheet
+      );
+    else
+      for (let e of t) {
+        let s = document.createElement("style"),
+          r = Y.litNonce;
+        r !== void 0 && s.setAttribute("nonce", r),
+          (s.textContent = e.cssText),
+          o.appendChild(s);
+      }
+  },
+  vt = Z
+    ? (o) => o
+    : (o) =>
+        o instanceof CSSStyleSheet
+          ? ((t) => {
+              let e = "";
+              for (let s of t.cssRules) e += s.cssText;
+              return Mt(e);
+            })(o)
+          : o;
+var {
+    is: _e,
+    defineProperty: Ae,
+    getOwnPropertyDescriptor: Ce,
+    getOwnPropertyNames: we,
+    getOwnPropertySymbols: Oe,
+    getPrototypeOf: Te,
+  } = Object,
+  tt = globalThis,
+  kt = tt.trustedTypes,
+  Se = kt ? kt.emptyScript : "",
+  Pe = tt.reactiveElementPolyfillSupport,
+  j = (o, t) => o,
+  X = {
+    toAttribute(o, t) {
+      switch (t) {
+        case Boolean:
+          o = o ? Se : null;
+          break;
+        case Object:
+        case Array:
+          o = o == null ? o : JSON.stringify(o);
+      }
+      return o;
+    },
+    fromAttribute(o, t) {
+      let e = o;
+      switch (t) {
+        case Boolean:
+          e = o !== null;
+          break;
+        case Number:
+          e = o === null ? null : Number(o);
+          break;
+        case Object:
+        case Array:
+          try {
+            e = JSON.parse(o);
+          } catch {
+            e = null;
+          }
+      }
+      return e;
+    },
+  },
+  H = (o, t) => !_e(o, t),
+  jt = {
+    attribute: !0,
+    type: String,
+    converter: X,
+    reflect: !1,
+    useDefault: !1,
+    hasChanged: H,
+  };
+(Symbol.metadata ??= Symbol("metadata")),
+  (tt.litPropertyMetadata ??= new WeakMap());
+var _ = class extends HTMLElement {
+  static addInitializer(t) {
+    this._$Ei(), (this.l ??= []).push(t);
+  }
+  static get observedAttributes() {
+    return this.finalize(), this._$Eh && [...this._$Eh.keys()];
+  }
+  static createProperty(t, e = jt) {
+    if (
+      (e.state && (e.attribute = !1),
+      this._$Ei(),
+      this.prototype.hasOwnProperty(t) && ((e = Object.create(e)).wrapped = !0),
+      this.elementProperties.set(t, e),
+      !e.noAccessor)
+    ) {
+      let s = Symbol(),
+        r = this.getPropertyDescriptor(t, s, e);
+      r !== void 0 && Ae(this.prototype, t, r);
+    }
+  }
+  static getPropertyDescriptor(t, e, s) {
+    let { get: r, set: i } = Ce(this.prototype, t) ?? {
+      get() {
+        return this[e];
+      },
+      set(n) {
+        this[e] = n;
+      },
+    };
+    return {
+      get: r,
+      set(n) {
+        let a = r?.call(this);
+        i?.call(this, n), this.requestUpdate(t, a, s);
+      },
+      configurable: !0,
+      enumerable: !0,
+    };
+  }
+  static getPropertyOptions(t) {
+    return this.elementProperties.get(t) ?? jt;
+  }
+  static _$Ei() {
+    if (this.hasOwnProperty(j("elementProperties"))) return;
+    let t = Te(this);
+    t.finalize(),
+      t.l !== void 0 && (this.l = [...t.l]),
+      (this.elementProperties = new Map(t.elementProperties));
+  }
+  static finalize() {
+    if (this.hasOwnProperty(j("finalized"))) return;
+    if (
+      ((this.finalized = !0), this._$Ei(), this.hasOwnProperty(j("properties")))
+    ) {
+      let e = this.properties,
+        s = [...we(e), ...Oe(e)];
+      for (let r of s) this.createProperty(r, e[r]);
+    }
+    let t = this[Symbol.metadata];
+    if (t !== null) {
+      let e = litPropertyMetadata.get(t);
+      if (e !== void 0) for (let [s, r] of e) this.elementProperties.set(s, r);
+    }
+    this._$Eh = new Map();
+    for (let [e, s] of this.elementProperties) {
+      let r = this._$Eu(e, s);
+      r !== void 0 && this._$Eh.set(r, e);
+    }
+    this.elementStyles = this.finalizeStyles(this.styles);
+  }
+  static finalizeStyles(t) {
+    let e = [];
+    if (Array.isArray(t)) {
+      let s = new Set(t.flat(1 / 0).reverse());
+      for (let r of s) e.unshift(vt(r));
+    } else t !== void 0 && e.push(vt(t));
+    return e;
+  }
+  static _$Eu(t, e) {
+    let s = e.attribute;
+    return s === !1
+      ? void 0
+      : typeof s == "string"
+      ? s
+      : typeof t == "string"
+      ? t.toLowerCase()
+      : void 0;
+  }
+  constructor() {
+    super(),
+      (this._$Ep = void 0),
+      (this.isUpdatePending = !1),
+      (this.hasUpdated = !1),
+      (this._$Em = null),
+      this._$Ev();
+  }
+  _$Ev() {
+    (this._$ES = new Promise((t) => (this.enableUpdating = t))),
+      (this._$AL = new Map()),
+      this._$E_(),
+      this.requestUpdate(),
+      this.constructor.l?.forEach((t) => t(this));
+  }
+  addController(t) {
+    (this._$EO ??= new Set()).add(t),
+      this.renderRoot !== void 0 && this.isConnected && t.hostConnected?.();
+  }
+  removeController(t) {
+    this._$EO?.delete(t);
+  }
+  _$E_() {
+    let t = new Map(),
+      e = this.constructor.elementProperties;
+    for (let s of e.keys())
+      this.hasOwnProperty(s) && (t.set(s, this[s]), delete this[s]);
+    t.size > 0 && (this._$Ep = t);
+  }
+  createRenderRoot() {
+    let t =
+      this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions);
+    return It(t, this.constructor.elementStyles), t;
+  }
+  connectedCallback() {
+    (this.renderRoot ??= this.createRenderRoot()),
+      this.enableUpdating(!0),
+      this._$EO?.forEach((t) => t.hostConnected?.());
+  }
+  enableUpdating(t) {}
+  disconnectedCallback() {
+    this._$EO?.forEach((t) => t.hostDisconnected?.());
+  }
+  attributeChangedCallback(t, e, s) {
+    this._$AK(t, s);
+  }
+  _$ET(t, e) {
+    let s = this.constructor.elementProperties.get(t),
+      r = this.constructor._$Eu(t, s);
+    if (r !== void 0 && s.reflect === !0) {
+      let i = (
+        s.converter?.toAttribute !== void 0 ? s.converter : X
+      ).toAttribute(e, s.type);
+      (this._$Em = t),
+        i == null ? this.removeAttribute(r) : this.setAttribute(r, i),
+        (this._$Em = null);
+    }
+  }
+  _$AK(t, e) {
+    let s = this.constructor,
+      r = s._$Eh.get(t);
+    if (r !== void 0 && this._$Em !== r) {
+      let i = s.getPropertyOptions(r),
+        n =
+          typeof i.converter == "function"
+            ? { fromAttribute: i.converter }
+            : i.converter?.fromAttribute !== void 0
+            ? i.converter
+            : X;
+      this._$Em = r;
+      let a = n.fromAttribute(e, i.type);
+      (this[r] = a ?? this._$Ej?.get(r) ?? a), (this._$Em = null);
+    }
+  }
+  requestUpdate(t, e, s, r = !1, i) {
+    if (t !== void 0) {
+      let n = this.constructor;
+      if (
+        (r === !1 && (i = this[t]),
+        (s ??= n.getPropertyOptions(t)),
+        !(
+          (s.hasChanged ?? H)(i, e) ||
+          (s.useDefault &&
+            s.reflect &&
+            i === this._$Ej?.get(t) &&
+            !this.hasAttribute(n._$Eu(t, s)))
+        ))
+      )
+        return;
+      this.C(t, e, s);
+    }
+    this.isUpdatePending === !1 && (this._$ES = this._$EP());
+  }
+  C(t, e, { useDefault: s, reflect: r, wrapped: i }, n) {
+    (s &&
+      !(this._$Ej ??= new Map()).has(t) &&
+      (this._$Ej.set(t, n ?? e ?? this[t]), i !== !0 || n !== void 0)) ||
+      (this._$AL.has(t) ||
+        (this.hasUpdated || s || (e = void 0), this._$AL.set(t, e)),
+      r === !0 && this._$Em !== t && (this._$Eq ??= new Set()).add(t));
+  }
+  async _$EP() {
+    this.isUpdatePending = !0;
+    try {
+      await this._$ES;
+    } catch (e) {
+      Promise.reject(e);
+    }
+    let t = this.scheduleUpdate();
+    return t != null && (await t), !this.isUpdatePending;
+  }
+  scheduleUpdate() {
+    return this.performUpdate();
+  }
+  performUpdate() {
+    if (!this.isUpdatePending) return;
+    if (!this.hasUpdated) {
+      if (((this.renderRoot ??= this.createRenderRoot()), this._$Ep)) {
+        for (let [r, i] of this._$Ep) this[r] = i;
+        this._$Ep = void 0;
+      }
+      let s = this.constructor.elementProperties;
+      if (s.size > 0)
+        for (let [r, i] of s) {
+          let { wrapped: n } = i,
+            a = this[r];
+          n !== !0 ||
+            this._$AL.has(r) ||
+            a === void 0 ||
+            this.C(r, void 0, i, a);
+        }
+    }
+    let t = !1,
+      e = this._$AL;
+    try {
+      (t = this.shouldUpdate(e)),
+        t
+          ? (this.willUpdate(e),
+            this._$EO?.forEach((s) => s.hostUpdate?.()),
+            this.update(e))
+          : this._$EM();
+    } catch (s) {
+      throw ((t = !1), this._$EM(), s);
+    }
+    t && this._$AE(e);
+  }
+  willUpdate(t) {}
+  _$AE(t) {
+    this._$EO?.forEach((e) => e.hostUpdated?.()),
+      this.hasUpdated || ((this.hasUpdated = !0), this.firstUpdated(t)),
+      this.updated(t);
+  }
+  _$EM() {
+    (this._$AL = new Map()), (this.isUpdatePending = !1);
+  }
+  get updateComplete() {
+    return this.getUpdateComplete();
+  }
+  getUpdateComplete() {
+    return this._$ES;
+  }
+  shouldUpdate(t) {
+    return !0;
+  }
+  update(t) {
+    (this._$Eq &&= this._$Eq.forEach((e) => this._$ET(e, this[e]))),
+      this._$EM();
+  }
+  updated(t) {}
+  firstUpdated(t) {}
+};
+(_.elementStyles = []),
+  (_.shadowRootOptions = { mode: "open" }),
+  (_[j("elementProperties")] = new Map()),
+  (_[j("finalized")] = new Map()),
+  Pe?.({ ReactiveElement: _ }),
+  (tt.reactiveElementVersions ??= []).push("2.1.2");
+var $t = globalThis,
+  Ht = (o) => o,
+  et = $t.trustedTypes,
+  Vt = et ? et.createPolicy("lit-html", { createHTML: (o) => o }) : void 0,
+  bt = "$lit$",
+  A = `lit$${Math.random().toFixed(9).slice(2)}$`,
+  _t = "?" + A,
+  Ne = `<${_t}>`,
+  T = document,
+  z = () => T.createComment(""),
+  B = (o) => o === null || (typeof o != "object" && typeof o != "function"),
+  At = Array.isArray,
+  Gt = (o) => At(o) || typeof o?.[Symbol.iterator] == "function",
+  Et = `[ 	
+\f\r]`,
+  V = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g,
+  zt = /-->/g,
+  Bt = />/g,
+  w = RegExp(
+    `>|${Et}(?:([^\\s"'>=/]+)(${Et}*=${Et}*(?:[^ 	
+\f\r"'\`<>=]|("|')|))|$)`,
+    "g"
+  ),
+  Wt = /'/g,
+  Ft = /"/g,
+  Kt = /^(?:script|style|textarea|title)$/i,
+  Ct =
+    (o) =>
+    (t, ...e) => ({ _$litType$: o, strings: t, values: e }),
+  us = Ct(1),
+  fs = Ct(2),
+  ms = Ct(3),
+  f = Symbol.for("lit-noChange"),
+  d = Symbol.for("lit-nothing"),
+  qt = new WeakMap(),
+  O = T.createTreeWalker(T, 129);
+function Qt(o, t) {
+  if (!At(o) || !o.hasOwnProperty("raw"))
+    throw Error("invalid template strings array");
+  return Vt !== void 0 ? Vt.createHTML(t) : t;
+}
+var Jt = (o, t) => {
+    let e = o.length - 1,
+      s = [],
+      r,
+      i = t === 2 ? "<svg>" : t === 3 ? "<math>" : "",
+      n = V;
+    for (let a = 0; a < e; a++) {
+      let c = o[a],
+        l,
+        u,
+        h = -1,
+        y = 0;
+      for (; y < c.length && ((n.lastIndex = y), (u = n.exec(c)), u !== null); )
+        (y = n.lastIndex),
+          n === V
+            ? u[1] === "!--"
+              ? (n = zt)
+              : u[1] !== void 0
+              ? (n = Bt)
+              : u[2] !== void 0
+              ? (Kt.test(u[2]) && (r = RegExp("</" + u[2], "g")), (n = w))
+              : u[3] !== void 0 && (n = w)
+            : n === w
+            ? u[0] === ">"
+              ? ((n = r ?? V), (h = -1))
+              : u[1] === void 0
+              ? (h = -2)
+              : ((h = n.lastIndex - u[2].length),
+                (l = u[1]),
+                (n = u[3] === void 0 ? w : u[3] === '"' ? Ft : Wt))
+            : n === Ft || n === Wt
+            ? (n = w)
+            : n === zt || n === Bt
+            ? (n = V)
+            : ((n = w), (r = void 0));
+      let g = n === w && o[a + 1].startsWith("/>") ? " " : "";
+      i +=
+        n === V
+          ? c + Ne
+          : h >= 0
+          ? (s.push(l), c.slice(0, h) + bt + c.slice(h) + A + g)
+          : c + A + (h === -2 ? a : g);
+    }
+    return [
+      Qt(
+        o,
+        i + (o[e] || "<?>") + (t === 2 ? "</svg>" : t === 3 ? "</math>" : "")
+      ),
+      s,
+    ];
+  },
+  W = class o {
+    constructor({ strings: t, _$litType$: e }, s) {
+      let r;
+      this.parts = [];
+      let i = 0,
+        n = 0,
+        a = t.length - 1,
+        c = this.parts,
+        [l, u] = Jt(t, e);
+      if (
+        ((this.el = o.createElement(l, s)),
+        (O.currentNode = this.el.content),
+        e === 2 || e === 3)
+      ) {
+        let h = this.el.content.firstChild;
+        h.replaceWith(...h.childNodes);
+      }
+      for (; (r = O.nextNode()) !== null && c.length < a; ) {
+        if (r.nodeType === 1) {
+          if (r.hasAttributes())
+            for (let h of r.getAttributeNames())
+              if (h.endsWith(bt)) {
+                let y = u[n++],
+                  g = r.getAttribute(h).split(A),
+                  C = /([.?@])?(.*)/.exec(y);
+                c.push({
+                  type: 1,
+                  index: i,
+                  name: C[2],
+                  strings: g,
+                  ctor:
+                    C[1] === "."
+                      ? ot
+                      : C[1] === "?"
+                      ? rt
+                      : C[1] === "@"
+                      ? it
+                      : P,
+                }),
+                  r.removeAttribute(h);
+              } else
+                h.startsWith(A) &&
+                  (c.push({ type: 6, index: i }), r.removeAttribute(h));
+          if (Kt.test(r.tagName)) {
+            let h = r.textContent.split(A),
+              y = h.length - 1;
+            if (y > 0) {
+              r.textContent = et ? et.emptyScript : "";
+              for (let g = 0; g < y; g++)
+                r.append(h[g], z()),
+                  O.nextNode(),
+                  c.push({ type: 2, index: ++i });
+              r.append(h[y], z());
+            }
+          }
+        } else if (r.nodeType === 8)
+          if (r.data === _t) c.push({ type: 2, index: i });
+          else {
+            let h = -1;
+            for (; (h = r.data.indexOf(A, h + 1)) !== -1; )
+              c.push({ type: 7, index: i }), (h += A.length - 1);
+          }
+        i++;
+      }
+    }
+    static createElement(t, e) {
+      let s = T.createElement("template");
+      return (s.innerHTML = t), s;
+    }
+  };
+function S(o, t, e = o, s) {
+  if (t === f) return t;
+  let r = s !== void 0 ? e._$Co?.[s] : e._$Cl,
+    i = B(t) ? void 0 : t._$litDirective$;
+  return (
+    r?.constructor !== i &&
+      (r?._$AO?.(!1),
+      i === void 0 ? (r = void 0) : ((r = new i(o)), r._$AT(o, e, s)),
+      s !== void 0 ? ((e._$Co ??= [])[s] = r) : (e._$Cl = r)),
+    r !== void 0 && (t = S(o, r._$AS(o, t.values), r, s)),
+    t
+  );
+}
+var st = class {
+    constructor(t, e) {
+      (this._$AV = []), (this._$AN = void 0), (this._$AD = t), (this._$AM = e);
+    }
+    get parentNode() {
+      return this._$AM.parentNode;
+    }
+    get _$AU() {
+      return this._$AM._$AU;
+    }
+    u(t) {
+      let {
+          el: { content: e },
+          parts: s,
+        } = this._$AD,
+        r = (t?.creationScope ?? T).importNode(e, !0);
+      O.currentNode = r;
+      let i = O.nextNode(),
+        n = 0,
+        a = 0,
+        c = s[0];
+      for (; c !== void 0; ) {
+        if (n === c.index) {
+          let l;
+          c.type === 2
+            ? (l = new U(i, i.nextSibling, this, t))
+            : c.type === 1
+            ? (l = new c.ctor(i, c.name, c.strings, this, t))
+            : c.type === 6 && (l = new nt(i, this, t)),
+            this._$AV.push(l),
+            (c = s[++a]);
+        }
+        n !== c?.index && ((i = O.nextNode()), n++);
+      }
+      return (O.currentNode = T), r;
+    }
+    p(t) {
+      let e = 0;
+      for (let s of this._$AV)
+        s !== void 0 &&
+          (s.strings !== void 0
+            ? (s._$AI(t, s, e), (e += s.strings.length - 2))
+            : s._$AI(t[e])),
+          e++;
+    }
+  },
+  U = class o {
+    get _$AU() {
+      return this._$AM?._$AU ?? this._$Cv;
+    }
+    constructor(t, e, s, r) {
+      (this.type = 2),
+        (this._$AH = d),
+        (this._$AN = void 0),
+        (this._$AA = t),
+        (this._$AB = e),
+        (this._$AM = s),
+        (this.options = r),
+        (this._$Cv = r?.isConnected ?? !0);
+    }
+    get parentNode() {
+      let t = this._$AA.parentNode,
+        e = this._$AM;
+      return e !== void 0 && t?.nodeType === 11 && (t = e.parentNode), t;
+    }
+    get startNode() {
+      return this._$AA;
+    }
+    get endNode() {
+      return this._$AB;
+    }
+    _$AI(t, e = this) {
+      (t = S(this, t, e)),
+        B(t)
+          ? t === d || t == null || t === ""
+            ? (this._$AH !== d && this._$AR(), (this._$AH = d))
+            : t !== this._$AH && t !== f && this._(t)
+          : t._$litType$ !== void 0
+          ? this.$(t)
+          : t.nodeType !== void 0
+          ? this.T(t)
+          : Gt(t)
+          ? this.k(t)
+          : this._(t);
+    }
+    O(t) {
+      return this._$AA.parentNode.insertBefore(t, this._$AB);
+    }
+    T(t) {
+      this._$AH !== t && (this._$AR(), (this._$AH = this.O(t)));
+    }
+    _(t) {
+      this._$AH !== d && B(this._$AH)
+        ? (this._$AA.nextSibling.data = t)
+        : this.T(T.createTextNode(t)),
+        (this._$AH = t);
+    }
+    $(t) {
+      let { values: e, _$litType$: s } = t,
+        r =
+          typeof s == "number"
+            ? this._$AC(t)
+            : (s.el === void 0 &&
+                (s.el = W.createElement(Qt(s.h, s.h[0]), this.options)),
+              s);
+      if (this._$AH?._$AD === r) this._$AH.p(e);
+      else {
+        let i = new st(r, this),
+          n = i.u(this.options);
+        i.p(e), this.T(n), (this._$AH = i);
+      }
+    }
+    _$AC(t) {
+      let e = qt.get(t.strings);
+      return e === void 0 && qt.set(t.strings, (e = new W(t))), e;
+    }
+    k(t) {
+      At(this._$AH) || ((this._$AH = []), this._$AR());
+      let e = this._$AH,
+        s,
+        r = 0;
+      for (let i of t)
+        r === e.length
+          ? e.push((s = new o(this.O(z()), this.O(z()), this, this.options)))
+          : (s = e[r]),
+          s._$AI(i),
+          r++;
+      r < e.length && (this._$AR(s && s._$AB.nextSibling, r), (e.length = r));
+    }
+    _$AR(t = this._$AA.nextSibling, e) {
+      for (this._$AP?.(!1, !0, e); t !== this._$AB; ) {
+        let s = Ht(t).nextSibling;
+        Ht(t).remove(), (t = s);
+      }
+    }
+    setConnected(t) {
+      this._$AM === void 0 && ((this._$Cv = t), this._$AP?.(t));
+    }
+  },
+  P = class {
+    get tagName() {
+      return this.element.tagName;
+    }
+    get _$AU() {
+      return this._$AM._$AU;
+    }
+    constructor(t, e, s, r, i) {
+      (this.type = 1),
+        (this._$AH = d),
+        (this._$AN = void 0),
+        (this.element = t),
+        (this.name = e),
+        (this._$AM = r),
+        (this.options = i),
+        s.length > 2 || s[0] !== "" || s[1] !== ""
+          ? ((this._$AH = Array(s.length - 1).fill(new String())),
+            (this.strings = s))
+          : (this._$AH = d);
+    }
+    _$AI(t, e = this, s, r) {
+      let i = this.strings,
+        n = !1;
+      if (i === void 0)
+        (t = S(this, t, e, 0)),
+          (n = !B(t) || (t !== this._$AH && t !== f)),
+          n && (this._$AH = t);
+      else {
+        let a = t,
+          c,
+          l;
+        for (t = i[0], c = 0; c < i.length - 1; c++)
+          (l = S(this, a[s + c], e, c)),
+            l === f && (l = this._$AH[c]),
+            (n ||= !B(l) || l !== this._$AH[c]),
+            l === d ? (t = d) : t !== d && (t += (l ?? "") + i[c + 1]),
+            (this._$AH[c] = l);
+      }
+      n && !r && this.j(t);
+    }
+    j(t) {
+      t === d
+        ? this.element.removeAttribute(this.name)
+        : this.element.setAttribute(this.name, t ?? "");
+    }
+  },
+  ot = class extends P {
+    constructor() {
+      super(...arguments), (this.type = 3);
+    }
+    j(t) {
+      this.element[this.name] = t === d ? void 0 : t;
+    }
+  },
+  rt = class extends P {
+    constructor() {
+      super(...arguments), (this.type = 4);
+    }
+    j(t) {
+      this.element.toggleAttribute(this.name, !!t && t !== d);
+    }
+  },
+  it = class extends P {
+    constructor(t, e, s, r, i) {
+      super(t, e, s, r, i), (this.type = 5);
+    }
+    _$AI(t, e = this) {
+      if ((t = S(this, t, e, 0) ?? d) === f) return;
+      let s = this._$AH,
+        r =
+          (t === d && s !== d) ||
+          t.capture !== s.capture ||
+          t.once !== s.once ||
+          t.passive !== s.passive,
+        i = t !== d && (s === d || r);
+      r && this.element.removeEventListener(this.name, this, s),
+        i && this.element.addEventListener(this.name, this, t),
+        (this._$AH = t);
+    }
+    handleEvent(t) {
+      typeof this._$AH == "function"
+        ? this._$AH.call(this.options?.host ?? this.element, t)
+        : this._$AH.handleEvent(t);
+    }
+  },
+  nt = class {
+    constructor(t, e, s) {
+      (this.element = t),
+        (this.type = 6),
+        (this._$AN = void 0),
+        (this._$AM = e),
+        (this.options = s);
+    }
+    get _$AU() {
+      return this._$AM._$AU;
+    }
+    _$AI(t) {
+      S(this, t);
+    }
+  },
+  Yt = {
+    M: bt,
+    P: A,
+    A: _t,
+    C: 1,
+    L: Jt,
+    R: st,
+    D: Gt,
+    V: S,
+    I: U,
+    H: P,
+    N: rt,
+    U: it,
+    B: ot,
+    F: nt,
+  },
+  De = $t.litHtmlPolyfillSupport;
+De?.(W, U), ($t.litHtmlVersions ??= []).push("3.3.2");
+var at = (o, t, e) => {
+  let s = e?.renderBefore ?? t,
+    r = s._$litPart$;
+  if (r === void 0) {
+    let i = e?.renderBefore ?? null;
+    s._$litPart$ = r = new U(t.insertBefore(z(), i), i, void 0, e ?? {});
+  }
+  return r._$AI(o), r;
+};
+var wt = globalThis,
+  $ = class extends _ {
+    constructor() {
+      super(...arguments),
+        (this.renderOptions = { host: this }),
+        (this._$Do = void 0);
+    }
+    createRenderRoot() {
+      let t = super.createRenderRoot();
+      return (this.renderOptions.renderBefore ??= t.firstChild), t;
+    }
+    update(t) {
+      let e = this.render();
+      this.hasUpdated || (this.renderOptions.isConnected = this.isConnected),
+        super.update(t),
+        (this._$Do = at(e, this.renderRoot, this.renderOptions));
+    }
+    connectedCallback() {
+      super.connectedCallback(), this._$Do?.setConnected(!0);
+    }
+    disconnectedCallback() {
+      super.disconnectedCallback(), this._$Do?.setConnected(!1);
+    }
+    render() {
+      return f;
+    }
+  };
+($._$litElement$ = !0),
+  ($.finalized = !0),
+  wt.litElementHydrateSupport?.({ LitElement: $ });
+var xe = wt.litElementPolyfillSupport;
+xe?.({ LitElement: $ });
+(wt.litElementVersions ??= []).push("4.2.2");
+var Zt = new Set(),
+  Xt;
+var te = (o) =>
+    typeof o == "string"
+      ? o
+      : "el" in o
+      ? o.el.localName
+      : "localName" in o
+      ? o.localName
+      : o.declaredClass,
+  Ss = (o, t, e, s) => {
+    let r = te(t);
+    if (s?.once) {
+      let n = `${o}${r}${e}`;
+      if (Zt.has(n)) return;
+      Zt.add(n);
+    }
+    let i;
+    if (s?.detail) {
+      i = {};
+      for (let [n, a] of Object.entries(s.detail))
+        if ((typeof a == "object" || typeof a == "function") && a !== null) {
+          let c = new WeakRef(a);
+          Object.defineProperty(i, n, {
+            get() {
+              return c.deref();
+            },
+          });
+        } else i[n] = a;
+      Xt?.log.interceptors?.forEach((n) => n(o, r, e, i)),
+        console[o](`[${r}]: ${e}`, i);
+    } else
+      Xt?.log.interceptors?.forEach((n) => n(o, r, e)),
+        console[o](`[${r}]: ${e}`);
+  },
+  ee = (o) => {
+    let t = `[${te(o)}] `;
+    return (e) => {
+      let s = e instanceof Error && e.message ? e : new Error(String(e));
+      (s.message = `${t}${s.message}`),
+        setTimeout(() => {
+          throw e;
+        });
+    };
+  };
+var p = (o, t, ...e) => {
+    try {
+      return o?.call(t, ...e);
+    } catch (s) {
+      console.error(s, o);
+    }
+  },
+  F = async (o, t, ...e) => {
+    try {
+      return await o?.call(t, ...e);
+    } catch (s) {
+      console.error(s, o);
+    }
+  };
+var G = Symbol.for("controller"),
+  Le = (o) =>
+    typeof o == "object" &&
+    o !== null &&
+    (G in o ||
+      "hostConnected" in o ||
+      "hostDisconnected" in o ||
+      "hostUpdate" in o ||
+      "hostUpdated" in o),
+  Ds = (o) => typeof o?.then == "function";
+var q,
+  D = (o) => {
+    q !== o && ((q = o), queueMicrotask(() => (q === o ? (q = void 0) : 0)));
+  },
+  K = (o) => q,
+  N = [],
+  se = (o) => {
+    if (o === void 0) {
+      N = [];
+      return;
+    }
+    let t = N.indexOf(o);
+    (N = t === -1 ? [...N, o] : N.slice(0, t + 1)),
+      queueMicrotask(() => (N = []));
+  },
+  oe = () => N,
+  R,
+  xs = (o) => {
+    R !== o && ((R = o), queueMicrotask(() => (R === o ? (R = void 0) : 0)));
+  },
+  Ue = () => {
+    let o = R;
+    return (R = void 0), o;
+  },
+  re = async (o, t) => {
+    let e = lt(o);
+    if (e === void 0) return o;
+    if ((await e.ready, typeof t == "function")) {
+      let s = e.watchExports((r) => t(r, s));
+    }
+    return e.exports;
+  },
+  ie = async (o) => {
+    let t = lt(o);
+    return await t.ready, t;
+  },
+  lt = (o) => {
+    let e = K().manager.X(o);
+    if (e !== void 0) return e;
+    if (Le(o)) return o;
+    let s = Ue();
+    if (s !== void 0) return s;
+  },
+  ct = !1,
+  Ls = (o) => {
+    ct = !0;
+    try {
+      return o();
+    } finally {
+      ct = !1;
+    }
+  };
+var b = class {
+    constructor() {
+      this.promise = new Promise((t, e) => {
+        (this.resolve = t), (this.reject = e);
+      });
+    }
+  },
+  ne = (o, t) => {
+    let e = t > Re ? Me : t / Ie,
+      s = 0,
+      r = setInterval(() => {
+        (s += e), s >= t && (clearInterval(r), o());
+      }, e);
+    return r;
+  },
+  Re = 4e3,
+  Me = 2e3,
+  Ie = 4;
+var ke = (o, t, e) => {
+    let s = Object.keys(o),
+      r = s.length;
+    M === void 0 && queueMicrotask(I), (M ??= new Map());
+    let i = M.get(o);
+    return (
+      i === void 0 && ((i = { callbacks: [], keyCount: r }), M.set(o, i)),
+      i.keyCount !== r &&
+        (i.callbacks.forEach((n) => n(s)),
+        (i.callbacks = []),
+        (i.keyCount = r)),
+      i.callbacks.push((n) => {
+        let a = (l) => p(t, null, l),
+          c = n[r];
+        c === void 0 ? a(void 0) : o[c] === e ? a(c) : a(void 0);
+      }),
+      e
+    );
+  },
+  M,
+  I = () => {
+    M?.forEach(({ callbacks: o }, t) => {
+      let e = Object.keys(t);
+      o.forEach((s) => s(e));
+    }),
+      (M = void 0);
+  },
+  je = (o, t, e) => {
+    let s = o.manager;
+    return (
+      s.V !== d && s.V !== e && s.S(void 0, void 0),
+      s.T.length === 0 && queueMicrotask(() => s.S(void 0, void 0)),
+      (s.V = e),
+      s.T.push((r, i) => p(t, void 0, e === i ? r : void 0)),
+      e
+    );
+  },
+  He = (o = [K(), ...oe()], t, e) => {
+    let s = Array.isArray(o) ? o : [o],
+      r = s.length + 1,
+      i = (n) => {
+        (r -= 1), n !== void 0 && (r = Math.min(r, 0)), r === 0 && t(n);
+      };
+    s.forEach((n) =>
+      ke(
+        n,
+        (a) => i(a === void 0 ? void 0 : { key: a, host: n, isReactive: !1 }),
+        e
+      )
+    );
+    for (let n of s)
+      if ("manager" in n && n.manager.component === n) {
+        je(
+          n,
+          (a) => i(a === void 0 ? void 0 : { key: a, host: n, isReactive: !0 }),
+          e
+        );
+        break;
+      }
+    return e;
+  },
+  Ve = (o = "", t = {}, e = K()) => {
+    let s = {
+      emit: (r) => {
+        o === "" && I();
+        let i = new CustomEvent(o, {
+          detail: r,
+          cancelable: !0,
+          bubbles: !0,
+          composed: !0,
+          ...t,
+        });
+        return e.el.dispatchEvent(i), i;
+      },
+    };
+    return o === "" && He(void 0, (r) => (o = r.key), s), s;
+  },
+  ze = Ve.bind(null, ""),
+  le;
+le = G;
+var Ot = class {
+  constructor(t) {
+    (this.#t = []),
+      (this.#e = []),
+      (this.#s = []),
+      (this.#r = []),
+      (this.#i = []),
+      (this.#c = []),
+      (this.#l = []),
+      (this.#p = []),
+      (this.#h = []),
+      (this.#d = !1),
+      (this.P = new b()),
+      (this.connectedCalled = !1),
+      (this.loadedCalled = !1),
+      (this[le] = !0),
+      (this.#a = []);
+    let e = this,
+      s = t ?? K(new.target.name);
+    (e.#o = s),
+      (e.ready = e.P.promise),
+      (e.#n = ce(e)),
+      (e.component = s),
+      e.#o.addController(e),
+      e.#o.manager === void 0 ||
+        (se(e), queueMicrotask(() => e.catchUpLifecycle()));
+  }
+  #t;
+  #e;
+  #s;
+  #r;
+  #i;
+  #c;
+  #l;
+  #p;
+  #h;
+  #d;
+  #o;
+  catchUpLifecycle() {
+    let { manager: t } = this.#o;
+    t.connectedCalled && !this.connectedCalled && this.triggerConnected(),
+      t.#d &&
+        this.triggerLoad()
+          .then(() => t.loadedCalled && this.triggerLoaded())
+          .catch(ee(this.#o));
+  }
+  #n;
+  get exports() {
+    return this.#n;
+  }
+  set exports(t) {
+    let e = this.#n;
+    e !== t &&
+      ((this.#n = t),
+      this.#a.forEach(p),
+      this.connectedCalled &&
+        this.O !== !1 &&
+        this.#o.requestUpdate(this.O, e)),
+      this.P.resolve(t);
+  }
+  setProvisionalExports(t, e = !0) {
+    (this.#n = e ? ce(t) : t), this.#a.forEach(p);
+  }
+  #a;
+  watchExports(t) {
+    let e = () => t(this.#n);
+    return this.#a.push(e), () => void this.#a.splice(this.#a.indexOf(e), 1);
+  }
+  get use() {
+    return D(this.#o), re;
+  }
+  get useRef() {
+    return D(this.#o), ie;
+  }
+  get useRefSync() {
+    return D(this.#o), lt;
+  }
+  controllerRemoved() {
+    this.#o.el.isConnected && this.triggerDisconnected(), this.triggerDestroy();
+  }
+  onConnected(t) {
+    this.#t.push(t);
+  }
+  onDisconnected(t) {
+    this.#e.push(t);
+  }
+  onLoad(t) {
+    this.#s.push(t);
+  }
+  onLoaded(t) {
+    this.#r.push(t);
+  }
+  onUpdate(t) {
+    this.#i.push(t);
+  }
+  onUpdated(t) {
+    this.#c.push(t);
+  }
+  onDestroy(t) {
+    this.#l.push(t);
+  }
+  onLifecycle(t) {
+    this.#p.push(t),
+      this.connectedCalled && this.#o.el.isConnected && this.#u(t);
+  }
+  triggerConnected() {
+    let t = this;
+    t.hostConnected && p(t.hostConnected, t),
+      t.#t.forEach(p),
+      t.triggerLifecycle(),
+      (t.connectedCalled = !0);
+  }
+  triggerDisconnected() {
+    let t = this;
+    t.hostDisconnected && p(t.hostDisconnected, t),
+      t.#e.forEach(p),
+      t.#h.forEach(p),
+      (t.#h = []);
+  }
+  async triggerLoad() {
+    if (this.#d) return;
+    this.#d = !0;
+    let t = this;
+    t.hostLoad && (await F(t.hostLoad, t)),
+      this.#s.length > 0 && (await Promise.allSettled(this.#s.map(F))),
+      this.P.resolve(this.#n);
+  }
+  triggerLoaded() {
+    this.loadedCalled ||
+      (this.hostLoaded && p(this.hostLoaded, this),
+      this.#r.forEach(p),
+      (this.loadedCalled = !0));
+  }
+  triggerUpdate(t) {
+    this.hostUpdate && p(this.hostUpdate, this, t), this.#i.forEach(ae, t);
+  }
+  triggerUpdated(t) {
+    this.hostUpdated && p(this.hostUpdated, this, t), this.#c.forEach(ae, t);
+  }
+  triggerDestroy() {
+    this.hostDestroy && p(this.hostDestroy, this), this.#l.forEach(p);
+  }
+  triggerLifecycle() {
+    this.hostLifecycle && this.#u(() => this.hostLifecycle()),
+      this.#p.forEach(this.#u, this);
+  }
+  #u(t) {
+    D(this.#o);
+    let e = p(t);
+    (Array.isArray(e) ? e : [e]).forEach((r) => {
+      typeof r == "function"
+        ? this.#h.push(r)
+        : typeof r == "object" &&
+          typeof r.remove == "function" &&
+          this.#h.push(r.remove);
+    });
+  }
+};
+function ae(o) {
+  p(o, void 0, this);
+}
+var he = Ot,
+  ce = (o) => {
+    if ((typeof o != "object" && typeof o != "function") || o === null)
+      return o;
+    let t = {
+        get(s, r, i) {
+          if (
+            !((r === "exports" || r === "_exports") && r in s && s[r] === e) &&
+            (r in s || r in Promise.prototype || typeof r == "symbol")
+          )
+            return typeof s == "function" ? s[r] : Reflect.get(s, r, i);
+        },
+      },
+      e = new Proxy(o, t);
+    return e;
+  };
+var { I: Be } = Yt,
+  de = (o) => o;
+var ht = (o) => o.strings === void 0,
+  pe = () => document.createComment(""),
+  Ws = (o, t, e) => {
+    let s = o._$AA.parentNode,
+      r = t === void 0 ? o._$AB : t._$AA;
+    if (e === void 0) {
+      let i = s.insertBefore(pe(), r),
+        n = s.insertBefore(pe(), r);
+      e = new Be(i, n, o, o.options);
+    } else {
+      let i = e._$AB.nextSibling,
+        n = e._$AM,
+        a = n !== o;
+      if (a) {
+        let c;
+        e._$AQ?.(o),
+          (e._$AM = o),
+          e._$AP !== void 0 && (c = o._$AU) !== n._$AU && e._$AP(c);
+      }
+      if (i !== r || a) {
+        let c = e._$AA;
+        for (; c !== i; ) {
+          let l = de(c).nextSibling;
+          de(s).insertBefore(c, r), (c = l);
+        }
+      }
+    }
+    return e;
+  },
+  Fs = (o, t, e = o) => (o._$AI(t, e), o),
+  We = {},
+  ue = (o, t = We) => (o._$AH = t),
+  qs = (o) => o._$AH,
+  Gs = (o) => {
+    o._$AR(), o._$AA.remove();
+  };
+var m = {
+    ATTRIBUTE: 1,
+    CHILD: 2,
+    PROPERTY: 3,
+    BOOLEAN_ATTRIBUTE: 4,
+    EVENT: 5,
+    ELEMENT: 6,
+  },
+  E =
+    (o) =>
+    (...t) => ({ _$litDirective$: o, values: t }),
+  v = class {
+    constructor(t) {}
+    get _$AU() {
+      return this._$AM._$AU;
+    }
+    _$AT(t, e, s) {
+      (this._$Ct = t), (this._$AM = e), (this._$Ci = s);
+    }
+    _$AS(t, e) {
+      return this.update(t, e);
+    }
+    update(t, e) {
+      return this.render(...e);
+    }
+  };
+var Q = (o, t) => {
+    let e = o._$AN;
+    if (e === void 0) return !1;
+    for (let s of e) s._$AO?.(t, !1), Q(s, t);
+    return !0;
+  },
+  dt = (o) => {
+    let t, e;
+    do {
+      if ((t = o._$AM) === void 0) break;
+      (e = t._$AN), e.delete(o), (o = t);
+    } while (e?.size === 0);
+  },
+  fe = (o) => {
+    for (let t; (t = o._$AM); o = t) {
+      let e = t._$AN;
+      if (e === void 0) t._$AN = e = new Set();
+      else if (e.has(o)) break;
+      e.add(o), Ge(t);
+    }
+  };
+function Fe(o) {
+  this._$AN !== void 0
+    ? (dt(this), (this._$AM = o), fe(this))
+    : (this._$AM = o);
+}
+function qe(o, t = !1, e = 0) {
+  let s = this._$AH,
+    r = this._$AN;
+  if (r !== void 0 && r.size !== 0)
+    if (t)
+      if (Array.isArray(s))
+        for (let i = e; i < s.length; i++) Q(s[i], !1), dt(s[i]);
+      else s != null && (Q(s, !1), dt(s));
+    else Q(this, o);
+}
+var Ge = (o) => {
+    o.type == m.CHILD && ((o._$AP ??= qe), (o._$AQ ??= Fe));
+  },
+  pt = class extends v {
+    constructor() {
+      super(...arguments), (this._$AN = void 0);
+    }
+    _$AT(t, e, s) {
+      super._$AT(t, e, s), fe(this), (this.isConnected = t._$AU);
+    }
+    _$AO(t, e = !0) {
+      t !== this.isConnected &&
+        ((this.isConnected = t),
+        t ? this.reconnected?.() : this.disconnected?.()),
+        e && (Q(this, t), dt(this));
+    }
+    setValue(t) {
+      if (ht(this._$Ct)) this._$Ct._$AI(t, this);
+      else {
+        let e = [...this._$Ct._$AH];
+        (e[this._$Ci] = t), this._$Ct._$AI(e, this, 0);
+      }
+    }
+    disconnected() {}
+    reconnected() {}
+  };
+var oo = () => new St(),
+  St = class {},
+  Tt = new WeakMap(),
+  Pt = E(
+    class extends pt {
+      render(o) {
+        return d;
+      }
+      update(o, [t]) {
+        let e = t !== this.G;
+        return (
+          e && this.G !== void 0 && this.rt(void 0),
+          (e || this.lt !== this.ct) &&
+            ((this.G = t),
+            (this.ht = o.options?.host),
+            this.rt((this.ct = o.element))),
+          d
+        );
+      }
+      rt(o) {
+        if ((this.isConnected || (o = void 0), typeof this.G == "function")) {
+          let t = this.ht ?? globalThis,
+            e = Tt.get(t);
+          e === void 0 && ((e = new WeakMap()), Tt.set(t, e)),
+            e.get(this.G) !== void 0 && this.G.call(this.ht, void 0),
+            e.set(this.G, o),
+            o !== void 0 && this.G.call(this.ht, o);
+        } else this.G.value = o;
+      }
+      get lt() {
+        return typeof this.G == "function"
+          ? Tt.get(this.ht ?? globalThis)?.get(this.G)
+          : this.G?.value;
+      }
+      disconnected() {
+        this.lt === this.ct && this.rt(void 0);
+      }
+      reconnected() {
+        this.rt(this.ct);
+      }
+    }
+  );
+var ut = (o) =>
+    o.replace(Qe, (t, e) => `${e === 0 ? "" : "-"}${t.toLowerCase()}`),
+  Qe = /[A-Z]+(?![a-z])|[A-Z]/gu;
+var go = "randomUUID" in crypto;
+var Dt = (o) => {
+    let t = o;
+    for (; (t = t.parentNode ?? t.host); )
+      if (t?.constructor?.lumina) {
+        let e = t;
+        return (
+          e.manager?.loadedCalled || (e.J ?? e._offspring).push(o),
+          (e.I ?? e._postLoad).promise
+        );
+      }
+    return !1;
+  },
+  xt = {};
+function Lt() {}
+var Je = (o, t) =>
+    function (s, r) {
+      if (!globalThis.customElements) return;
+      let n = (r ?? s ?? {}).resourcesUrl;
+      n && o.setAssetPath(n);
+      for (let [a, [c, l = ""]] of Object.entries(t)) {
+        if (customElements.get(a)) continue;
+        let [u, h, y] = l.split(";"),
+          g = u ? u?.split(",").map(Ye) : void 0,
+          C = g?.map(([L]) => L),
+          x = class extends Nt {
+            static {
+              this.observedAttributes = g
+                ?.map(([, L]) => L)
+                .filter((L) => L !== "");
+            }
+            static {
+              this.C = C;
+            }
+            static {
+              this.E = h ? h?.split(",") : void 0;
+            }
+            static {
+              this.D = y?.split(",");
+            }
+            static {
+              this.L = a;
+            }
+            static {
+              this.K = o;
+            }
+            constructor() {
+              !x.B && ((x.B = c()), x.F()), super();
+            }
+          };
+        customElements.define(a, x);
+      }
+    },
+  ft = Object.defineProperty,
+  Ye = (o) => {
+    let t = o.split(":");
+    return t.length === 1 ? [t[0], ut(t[0])] : t;
+  },
+  Ze = globalThis.HTMLElement ?? Lt,
+  Nt = class extends Ze {
+    constructor() {
+      super(),
+        (this.#e = {}),
+        (this.#s = []),
+        (this.I = new b()),
+        (this.H = new b()),
+        (this.J = []);
+      let t = this,
+        e = t.constructor;
+      (t._offspring = t.J),
+        (t._postLoad = t.I),
+        e.C?.forEach((s) => {
+          Object.hasOwn(t, s) && ((t.#e[s] = t[s]), delete t[s]);
+        }),
+        e.A
+          ? t.#r({ a: e.A })
+          : e.B.then(async (s) => {
+              await e.K.p,
+                t.#r(
+                  await (s.default?.then((r) =>
+                    typeof r == "function" ? { a: r } : r
+                  ) ?? s)
+                );
+            }).catch((s) => {
+              t.H.reject(s),
+                setTimeout(() => {
+                  throw s;
+                });
+            });
+    }
+    static {
+      this.lumina = !0;
+    }
+    static F() {
+      for (let t of this.C ?? [])
+        ft(this.prototype, t, {
+          configurable: !0,
+          enumerable: !0,
+          get() {
+            return this.#e[t];
+          },
+          set(e) {
+            this.#e[t] = e;
+          },
+        });
+      for (let t of this.E ?? [])
+        ft(this.prototype, t, {
+          async value(...e) {
+            return this.#t || (await this.H.promise), await this.#t[t](...e);
+          },
+          configurable: !0,
+        });
+      for (let t of this.D ?? [])
+        ft(this.prototype, t, {
+          value(...e) {
+            return this.#t[t](...e);
+          },
+          configurable: !0,
+        });
+    }
+    #t;
+    #e;
+    #s;
+    get manager() {
+      return this.#t?.manager;
+    }
+    attributeChangedCallback(t, e, s) {
+      this.#t?.attributeChangedCallback(t, e, s), this.#t || this.#s.push(t);
+    }
+    connectedCallback() {
+      this.#t
+        ? this.#t.connectedCallback?.()
+        : queueMicrotask(() => (this.G = Dt(this)));
+    }
+    disconnectedCallback() {
+      this.#t?.disconnectedCallback?.();
+    }
+    async componentOnReady() {
+      return await this.H.promise, this;
+    }
+    #r(t) {
+      let e = this.constructor,
+        s = e.L,
+        r = this.#e,
+        i = Object.values(t).find((h) => h.L === s),
+        n = `${s}--lazy`,
+        a = i;
+      for (; a && !Object.hasOwn(a, "lumina"); ) a = Object.getPrototypeOf(a);
+      ts(a), !e.A && ((e.A = i), customElements.define(n, i)), (i.N = this);
+      let l = document.createElement(n);
+      (i.N = void 0),
+        (this.#t = l),
+        (this.#e = l),
+        this.#s.forEach((h) =>
+          l.attributeChangedCallback(h, null, this.getAttribute(h))
+        ),
+        Object.entries(r).forEach(Xe, l);
+      let u = this.isConnected;
+      (u || this.G) && (l.connectedCallback?.(), u || l.disconnectedCallback());
+    }
+    addController() {}
+    requestUpdate() {
+      this.#t?.requestUpdate();
+    }
+  };
+function Xe([o, t]) {
+  this[o] = t;
+}
+var ts = (o) => {
+  let t = o.prototype,
+    e = Element.prototype;
+  Object.hasOwn(t, "isConnected") ||
+    ((t.setAttribute = function (r, i) {
+      e.setAttribute.call(this.el, r, i);
+    }),
+    (t.removeAttribute = function (r) {
+      e.removeAttribute.call(this.el, r);
+    }),
+    ft(t, "isConnected", {
+      get() {
+        return Reflect.get(e, "isConnected", this.el);
+      },
+    }));
+};
+var mt = class extends he {
+    constructor(t) {
+      super(t),
+        (this.destroyed = !1),
+        (this.R = !1),
+        (this.V = d),
+        (this.T = []),
+        (this.#s = new WeakMap()),
+        (this.#e = t),
+        (this.exports = void 0),
+        (this.hasDestroy = yt in t && typeof t.destroy == "function"),
+        $.prototype.addController.call(t, {
+          hostConnected: () => {
+            if (this.destroyed) {
+              let e = t.el.localName;
+              throw (
+                (t.el.remove(),
+                new Error(
+                  `The ${e} component has already been destroyed. It cannot be used again. If you meant to disconnect and reconnect a component without automatic destroy, set the ${yt} prop.`
+                ))
+              );
+            }
+            this.#t !== void 0 && clearTimeout(this.#t), I();
+            for (let e of t.M)
+              "triggerConnected" in e
+                ? e.triggerConnected()
+                : p(e.hostConnected, e);
+          },
+          hostDisconnected: () => {
+            for (let e of t.M)
+              "triggerDisconnected" in e
+                ? e.triggerDisconnected()
+                : p(e.hostDisconnected, e);
+            this.hasDestroy && !this.destroyed && this.U();
+          },
+          hostUpdate: () => {
+            for (let e of t.M)
+              "triggerUpdate" in e
+                ? e.triggerUpdate(this.Q)
+                : p(e.hostUpdate, e, this.Q);
+          },
+          hostUpdated: () => {
+            for (let e of t.M)
+              "triggerUpdated" in e
+                ? e.triggerUpdated(this.Q)
+                : p(e.hostUpdated, e, this.Q);
+            this.Q = void 0;
+          },
+        }),
+        queueMicrotask(() => (this.R = !0)),
+        D(t);
+    }
+    #t;
+    #e;
+    async destroy() {
+      if (!this.destroyed) {
+        this.#e.el.isConnected && ((this.hasDestroy = !1), this.#e.el.remove()),
+          (this.#t = void 0),
+          (this.destroyed = !0);
+        for (let t of this.#e.M)
+          "triggerDestroy" in t ? t.triggerDestroy() : p(t.hostDestroy, t);
+        this.#e.M.splice(0);
+      }
+    }
+    U() {
+      if (
+        (this.#t !== void 0 && clearTimeout(this.#t),
+        !this.#e.el.isConnected && !this.#e.autoDestroyDisabled)
+      ) {
+        let t = () => void this.#e.destroy();
+        this.#t = ne(t, es);
+      }
+    }
+    S(t, e) {
+      let s = this.T;
+      (this.V = d), (this.T = []), s.forEach((r) => r(t, e));
+    }
+    #s;
+    W(t, e) {
+      ((typeof e == "object" && e !== null) || typeof e == "function") &&
+        this.#s.set(e, t);
+    }
+    X(t) {
+      if ((typeof t == "object" && t !== null) || typeof t == "function")
+        return this.#s.get(t);
+    }
+  },
+  es = 1e3,
+  yt = "autoDestroyDisabled";
+var ye = E(
+  class extends v {
+    constructor(o) {
+      if (
+        (super(o),
+        o.type !== m.ATTRIBUTE || o.name !== "class" || o.strings?.length > 2)
+      )
+        throw Error(
+          "`classMap()` can only be used in the `class` attribute and must be the only part in the attribute."
+        );
+    }
+    render(o) {
+      return (
+        " " +
+        Object.keys(o)
+          .filter((t) => o[t])
+          .join(" ") +
+        " "
+      );
+    }
+    update(o, [t]) {
+      if (this.st === void 0) {
+        (this.st = new Set()),
+          o.strings !== void 0 &&
+            (this.nt = new Set(
+              o.strings
+                .join(" ")
+                .split(/\s/)
+                .filter((s) => s !== "")
+            ));
+        for (let s in t) t[s] && !this.nt?.has(s) && this.st.add(s);
+        return this.render(t);
+      }
+      let e = o.element.classList;
+      for (let s of this.st) s in t || (e.remove(s), this.st.delete(s));
+      for (let s in t) {
+        let r = !!t[s];
+        r === this.st.has(s) ||
+          this.nt?.has(s) ||
+          (r ? (e.add(s), this.st.add(s)) : (e.remove(s), this.st.delete(s)));
+      }
+      return f;
+    }
+  }
+);
+var ge = "important",
+  ss = " !" + ge,
+  ve = E(
+    class extends v {
+      constructor(o) {
+        if (
+          (super(o),
+          o.type !== m.ATTRIBUTE || o.name !== "style" || o.strings?.length > 2)
+        )
+          throw Error(
+            "The `styleMap` directive must be used in the `style` attribute and must be the only part in the attribute."
+          );
+      }
+      render(o) {
+        return Object.keys(o).reduce((t, e) => {
+          let s = o[e];
+          return s == null
+            ? t
+            : t +
+                `${(e = e.includes("-")
+                  ? e
+                  : e
+                      .replace(/(?:^(webkit|moz|ms|o)|)(?=[A-Z])/g, "-$&")
+                      .toLowerCase())}:${s};`;
+        }, "");
+      }
+      update(o, [t]) {
+        let { style: e } = o.element;
+        if (this.ft === void 0)
+          return (this.ft = new Set(Object.keys(t))), this.render(t);
+        for (let s of this.ft)
+          t[s] == null &&
+            (this.ft.delete(s),
+            s.includes("-") ? e.removeProperty(s) : (e[s] = null));
+        for (let s in t) {
+          let r = t[s];
+          if (r != null) {
+            this.ft.add(s);
+            let i = typeof r == "string" && r.endsWith(ss);
+            s.includes("-") || i
+              ? e.setProperty(s, i ? r.slice(0, -11) : r, i ? ge : "")
+              : (e[s] = r);
+          }
+        }
+        return f;
+      }
+    }
+  );
+var os = E(
+  class extends v {
+    constructor(o) {
+      if (
+        (super(o),
+        o.type !== m.PROPERTY &&
+          o.type !== m.ATTRIBUTE &&
+          o.type !== m.BOOLEAN_ATTRIBUTE)
+      )
+        throw Error(
+          "The `live` directive is not allowed on child or event bindings"
+        );
+      if (!ht(o))
+        throw Error("`live` bindings can only contain a single expression");
+    }
+    render(o) {
+      return o;
+    }
+    update(o, [t]) {
+      if (t === f || t === d) return t;
+      let e = o.element,
+        s = o.name;
+      if (o.type === m.PROPERTY) {
+        if (t === e[s]) return f;
+      } else if (o.type === m.BOOLEAN_ATTRIBUTE) {
+        if (!!t === e.hasAttribute(s)) return f;
+      } else if (o.type === m.ATTRIBUTE && e.getAttribute(s) === t + "")
+        return f;
+      return ue(o), t;
+    }
+  }
+);
+var Ee = class o extends $ {
+  constructor() {
+    super(), (this.M = []), (this.manager = new mt(this));
+    let t = this,
+      e = t.constructor,
+      s = e.N,
+      r = e.K.o,
+      i = o.prototype.shouldUpdate;
+    (t.#r = s?.H ?? new b()),
+      (t.I = s?.I ?? new b()),
+      (t.J = s?.J ?? []),
+      (t._offspring = t.J),
+      (t._postLoad = t.I),
+      (t.el = s ?? t),
+      (t.#s = t.enableUpdating),
+      (t.enableUpdating = Lt),
+      t.shouldUpdate !== i && ((t.#e = t.shouldUpdate), (t.shouldUpdate = i)),
+      r &&
+        ((t.#t = new Map()),
+        e.elementProperties.forEach((n, a) => t.#t.set(a, r()))),
+      !1;
+  }
+  static finalizeStyles(t) {
+    let e = super.finalizeStyles(t),
+      s = this.shadowRootOptions === xt;
+    return this.K?.commonStyles === void 0 || s
+      ? e
+      : [this.K.commonStyles, ...e];
+  }
+  static createProperty(t, e) {
+    let s = typeof e == "number" ? e : Array.isArray(e) ? e[0] : 0,
+      r = Array.isArray(e) ? e[1] : void 0,
+      i = r?.hasChanged ?? H,
+      n = {
+        attribute: s & 1 && typeof t == "string" ? ut(t) : !1,
+        reflect: !!(s & 2),
+        type: s & 4 ? Boolean : s & 8 ? Number : void 0,
+        state: !!(s & 16),
+        readOnly: !!(s & 32),
+        noAccessor: !!(s & 64),
+        c: !1,
+        ...r,
+        hasChanged(a, c) {
+          let l = i(a, c);
+          return (n.c = l), l;
+        },
+      };
+    super.createProperty(t, n);
+  }
+  static getPropertyDescriptor(t, e, s) {
+    let r = this.K,
+      i = super.getPropertyDescriptor(t, e, s);
+    return (
+      (s.d = i),
+      {
+        ...i,
+        get() {
+          return r.t?.(this.#t.get(t)), i.get?.call(this);
+        },
+        set(n) {
+          let a = this.manager;
+          if (s.readOnly && !ct && (a.R || a.connectedCalled))
+            throw Error(
+              `Cannot assign to read-only property "${t}" of ${this.el.localName}. Trying to assign "${n}"`
+            );
+          i.set.call(this, n ?? void 0),
+            s.c && this.#t?.get(t)?.notify(),
+            a.T.length > 0 && (I(), a?.S(t, n));
+        },
+      }
+    );
+  }
+  static {
+    this.lumina = !0;
+  }
+  #t;
+  #e;
+  #s;
+  #r;
+  #i;
+  connectedCallback() {
+    if (this.el.hasAttribute("defer-hydration")) return;
+    let t = this.constructor.K.c?.(() => this.requestUpdate());
+    this.#i = t;
+    let e = !this.manager.connectedCalled;
+    super.connectedCallback(),
+      e
+        ? queueMicrotask(() =>
+            this.#l().catch((s) => {
+              this.#r.reject(s),
+                setTimeout(() => {
+                  throw s;
+                });
+            })
+          )
+        : t && this.requestUpdate();
+  }
+  #c(t) {
+    try {
+      this.#i.clear(), this.constructor.K.r(this.#i, () => super.update(t));
+    } catch (e) {
+      throw (this.#i.clear(), e);
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), this.#i?.destroy(), (this.#i = void 0);
+  }
+  createRenderRoot() {
+    let t = this.el.shadowRoot,
+      e = this.constructor,
+      s = e.shadowRootOptions,
+      i = t ?? (s === xt ? this.el : this.el.attachShadow(s));
+    if (this.isConnected) {
+      let n = i.getRootNode();
+      n.adoptedStyleSheets = [
+        ...n.adoptedStyleSheets,
+        ...e.elementStyles.map((a) => ("styleSheet" in a ? a.styleSheet : a)),
+      ];
+    }
+    return i;
+  }
+  async #l() {
+    let t = this.el.G ?? Dt(this.el);
+    t && (await t);
+    let e = [];
+    for (let r of this.M)
+      "triggerLoad" in r ? e.push(r.triggerLoad()) : e.push(F(r.hostLoad, r));
+    await Promise.all(e),
+      await this.load?.(),
+      this.manager.hasDestroy &&
+        this.manager.onUpdate((r) => r.has(yt) && this.manager.U()),
+      this.#s(!0),
+      this.performUpdate(),
+      this.I.resolve(),
+      await Promise.resolve();
+    let s = this.J.filter((r) => !r.manager?.loadedCalled);
+    s.length &&
+      (await Promise.allSettled(
+        s.map(async (r) => await r.componentOnReady())
+      )),
+      (this.J.length = 0),
+      this.el.setAttribute(this.constructor.K.hydratedAttribute, "");
+    for (let r of this.M)
+      "triggerLoaded" in r ? r.triggerLoaded() : p(r.hostLoaded, r);
+    this.loaded?.(), this.#r.resolve();
+  }
+  shouldUpdate(t) {
+    return (this.manager.Q = t), this.#e?.(t) ?? !0;
+  }
+  update(t) {
+    this.#i ? this.#c(t) : super.update(t);
+  }
+  listen(t, e, s) {
+    let r = e?.bind(this) ?? e;
+    this.manager.onLifecycle(
+      () => (
+        this.el.addEventListener(t, r, s),
+        () => this.el.removeEventListener(t, r, s)
+      )
+    );
+  }
+  listenOn(t, e, s, r) {
+    let i = s?.bind(this) ?? s;
+    this.manager.onLifecycle(
+      () => (t.addEventListener(e, i, r), () => t.removeEventListener(e, i, r))
+    );
+  }
+  async componentOnReady() {
+    return await this.#r.promise, this;
+  }
+  addController(t) {
+    this.M.push(t),
+      !(G in t) &&
+        this.renderRoot &&
+        this.el.isConnected &&
+        t.hostConnected?.();
+  }
+  removeController(t) {
+    this.M.splice(this.M.indexOf(t), 1), t.controllerRemoved?.();
+  }
+};
+var $e = (o) => {
+  let t,
+    e = (r) => {
+      t = new URL(r, globalThis.location?.href || void 0).href;
+    },
+    s = {
+      ...o,
+      getAssetPath(r) {
+        let i = new URL(r, t);
+        return i.origin !== globalThis.location?.origin ? i.href : i.pathname;
+      },
+      setAssetPath: e,
+      customElement(r, i) {
+        (i.K = s),
+          (i.L = r),
+          customElements.get(r) || customElements.define(r, i);
+      },
+    };
+  return e(o.defaultAssetPath), s;
+};
+var Or = (o) => (typeof o == "object" && o != null ? ye(o) : o),
+  Tr = (o) => (typeof o == "object" && o != null ? ve(o) : o);
+var Ut = class extends v {
+    #t;
+    #e;
+    constructor(t) {
+      super(t);
+      let e = this;
+      this.#e = function (r) {
+        return e.#t.call(this, r);
+      };
+    }
+    render(t) {
+      return typeof t == "function" ? ((this.#t = t), Pt(this.#e)) : Pt(t);
+    }
+  },
+  Sr = E(Ut);
+var Pr = d;
+var Nr = (o) => {
+  let t = document.createElement("div");
+  return at(o, t), t.firstElementChild;
+};
+var J = $e({
+    defaultAssetPath: "https://js.geoscene.cn/5.0.19/charts-components/",
+    hydratedAttribute: "hydrated",
+  }),
+  { customElement: Rr, getAssetPath: Mr, setAssetPath: Ir } = J;
+J.t = void 0;
+J.o = void 0;
+J.c = void 0;
+J.r = void 0;
+export {
+  Ds as a,
+  D as b,
+  se as c,
+  oe as d,
+  xs as e,
+  Ls as f,
+  be as g,
+  us as h,
+  f as i,
+  d as j,
+  Ss as k,
+  He as l,
+  ze as m,
+  Ot as n,
+  Je as o,
+  m as p,
+  E as q,
+  v as r,
+  Ws as s,
+  Fs as t,
+  ue as u,
+  qs as v,
+  Gs as w,
+  oo as x,
+  Pt as y,
+  Ee as z,
+  Or as A,
+  Tr as B,
+  Pr as C,
+  Nr as D,
+  J as E,
+  Rr as F,
+  Mr as G,
+};