@nasa-terra/components 0.0.174 → 0.0.176

package/cdn/chunks/chunk.J3X6X5OR.js

@@ -0,0 +1,34 @@
+import {
+  TerraRadioGroup
+} from "./chunk.Q2JJZEWT.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/radio-group/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "terra-radio-group";
+TerraRadioGroup.define("terra-radio-group");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraRadioGroup,
+  react: React,
+  events: {
+    onTerraChange: "terra-change",
+    onTerraInput: "terra-input",
+    onTerraInvalid: "terra-invalid"
+  },
+  displayName: "TerraRadioGroup"
+});
+var radio_group_default = reactWrapper;
+
+export {
+  radio_group_default
+};

package/cdn/chunks/chunk.J7YS7AX6.js

@@ -0,0 +1,19 @@
+import {
+  TerraButtonGroup
+} from "./chunk.IYZOHIBX.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/button-group/button-group.ts
+init_dirname();
+init_buffer();
+init_process();
+var button_group_default = TerraButtonGroup;
+TerraButtonGroup.define("terra-button-group");
+
+export {
+  button_group_default
+};

package/cdn/chunks/chunk.JFAXLGEJ.js

@@ -0,0 +1,264 @@
+import {
+  waitForEvent
+} from "./chunk.6P5ZFZXZ.js";
+import {
+  HasSlotController
+} from "./chunk.PACUQ7ID.js";
+import {
+  e
+} from "./chunk.KGXAA5I2.js";
+import {
+  watch
+} from "./chunk.MPVZOQYA.js";
+import {
+  TerraElement,
+  component_styles_default,
+  e as e2,
+  n,
+  r
+} from "./chunk.ECHFPVLW.js";
+import {
+  alert_styles_default
+} from "./chunk.Z2SC4DOK.js";
+import {
+  b
+} from "./chunk.RRCYT4LP.js";
+import {
+  __decorateClass,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/components/alert/alert.component.ts
+init_dirname();
+init_buffer();
+init_process();
+var _TerraAlert = class _TerraAlert extends TerraElement {
+  constructor() {
+    super(...arguments);
+    this.hasSlotController = new HasSlotController(this, "icon", "suffix");
+    this.open = false;
+    this.closable = false;
+    this.variant = "primary";
+    this.appearance = "filled";
+    this.duration = Infinity;
+    this.remainingTime = this.duration;
+  }
+  static get toastStack() {
+    if (!this.currentToastStack) {
+      this.currentToastStack = Object.assign(document.createElement("div"), {
+        className: "terra-toast-stack"
+      });
+    }
+    return this.currentToastStack;
+  }
+  firstUpdated() {
+    this.base.hidden = !this.open;
+  }
+  restartAutoHide() {
+    this.handleCountdownChange();
+    clearTimeout(this.autoHideTimeout);
+    clearInterval(this.remainingTimeInterval);
+    if (this.open && this.duration < Infinity) {
+      this.autoHideTimeout = window.setTimeout(() => this.hide(), this.duration);
+      this.remainingTime = this.duration;
+      this.remainingTimeInterval = window.setInterval(() => {
+        this.remainingTime -= 100;
+      }, 100);
+    }
+  }
+  pauseAutoHide() {
+    var _a;
+    (_a = this.countdownAnimation) == null ? void 0 : _a.pause();
+    clearTimeout(this.autoHideTimeout);
+    clearInterval(this.remainingTimeInterval);
+  }
+  resumeAutoHide() {
+    var _a;
+    if (this.duration < Infinity) {
+      this.autoHideTimeout = window.setTimeout(
+        () => this.hide(),
+        this.remainingTime
+      );
+      this.remainingTimeInterval = window.setInterval(() => {
+        this.remainingTime -= 100;
+      }, 100);
+      (_a = this.countdownAnimation) == null ? void 0 : _a.play();
+    }
+  }
+  handleCountdownChange() {
+    if (this.open && this.duration < Infinity && this.countdown) {
+      const { countdownElement } = this;
+      const start = "100%";
+      const end = "0";
+      this.countdownAnimation = countdownElement.animate(
+        [{ width: start }, { width: end }],
+        {
+          duration: this.duration,
+          easing: "linear"
+        }
+      );
+    }
+  }
+  handleCloseClick() {
+    this.hide();
+  }
+  async handleOpenChange() {
+    this.base.hidden = !this.open;
+    if (this.open) {
+      this.emit("terra-show");
+      if (this.duration < Infinity) {
+        this.restartAutoHide();
+      }
+      this.emit("terra-after-show");
+    } else {
+      this.emit("terra-hide");
+      clearTimeout(this.autoHideTimeout);
+      clearInterval(this.remainingTimeInterval);
+      this.emit("terra-after-hide");
+    }
+  }
+  handleDurationChange() {
+    this.restartAutoHide();
+  }
+  /** Shows the alert. */
+  async show() {
+    if (this.open) {
+      return void 0;
+    }
+    this.open = true;
+    return waitForEvent(this, "terra-after-show");
+  }
+  /** Hides the alert */
+  async hide() {
+    if (!this.open) {
+      return void 0;
+    }
+    this.open = false;
+    return waitForEvent(this, "terra-after-hide");
+  }
+  /**
+   * Displays the alert as a toast notification. This will move the alert out of its position in the DOM and, when
+   * dismissed, it will be removed from the DOM completely. By storing a reference to the alert, you can reuse it by
+   * calling this method again. The returned promise will resolve after the alert is hidden.
+   */
+  async toast() {
+    return new Promise((resolve) => {
+      this.handleCountdownChange();
+      if (_TerraAlert.toastStack.parentElement === null) {
+        document.body.append(_TerraAlert.toastStack);
+      }
+      _TerraAlert.toastStack.appendChild(this);
+      requestAnimationFrame(() => {
+        this.clientWidth;
+        this.show();
+      });
+      this.addEventListener(
+        "terra-after-hide",
+        () => {
+          _TerraAlert.toastStack.removeChild(this);
+          resolve();
+          if (_TerraAlert.toastStack.querySelector("terra-alert") === null) {
+            _TerraAlert.toastStack.remove();
+          }
+        },
+        { once: true }
+      );
+    });
+  }
+  render() {
+    return b`
+            <div
+                part="base"
+                class=${e({
+      alert: true,
+      "alert--open": this.open,
+      "alert--closable": this.closable,
+      "alert--has-countdown": !!this.countdown,
+      "alert--has-icon": this.hasSlotController.test("icon"),
+      "alert--primary": this.variant === "primary",
+      "alert--success": this.variant === "success",
+      "alert--neutral": this.variant === "neutral",
+      "alert--warning": this.variant === "warning",
+      "alert--danger": this.variant === "danger",
+      "alert--filled": this.appearance === "filled",
+      "alert--white": this.appearance === "white"
+    })}
+                role="alert"
+                aria-hidden=${this.open ? "false" : "true"}
+                @mouseenter=${this.pauseAutoHide}
+                @mouseleave=${this.resumeAutoHide}
+            >
+                <div part="icon" class="alert__icon">
+                    <slot name="icon"></slot>
+                </div>
+
+                <div part="message" class="alert__message" aria-live="polite">
+                    <slot></slot>
+                </div>
+
+                ${this.closable ? b`
+                          <terra-icon
+                              class="alert__close-button"
+                              name="solid-x-mark"
+                              library="heroicons"
+                              @click=${this.handleCloseClick}
+                          ></terra-icon>
+                      ` : ""}
+
+                <div role="timer" class="alert__timer">${this.remainingTime}</div>
+
+                ${this.countdown ? b`
+                          <div
+                              class=${e({
+      alert__countdown: true,
+      "alert__countdown--ltr": this.countdown === "ltr"
+    })}
+                          >
+                              <div class="alert__countdown-elapsed"></div>
+                          </div>
+                      ` : ""}
+            </div>
+        `;
+  }
+};
+_TerraAlert.styles = [component_styles_default, alert_styles_default];
+__decorateClass([
+  e2('[part~="base"]')
+], _TerraAlert.prototype, "base", 2);
+__decorateClass([
+  e2(".alert__countdown-elapsed")
+], _TerraAlert.prototype, "countdownElement", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], _TerraAlert.prototype, "open", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], _TerraAlert.prototype, "closable", 2);
+__decorateClass([
+  n({ reflect: true })
+], _TerraAlert.prototype, "variant", 2);
+__decorateClass([
+  n({ reflect: true })
+], _TerraAlert.prototype, "appearance", 2);
+__decorateClass([
+  n({ type: Number })
+], _TerraAlert.prototype, "duration", 2);
+__decorateClass([
+  n({ type: String, reflect: true })
+], _TerraAlert.prototype, "countdown", 2);
+__decorateClass([
+  r()
+], _TerraAlert.prototype, "remainingTime", 2);
+__decorateClass([
+  watch("open", { waitUntilFirstUpdate: true })
+], _TerraAlert.prototype, "handleOpenChange", 1);
+__decorateClass([
+  watch("duration")
+], _TerraAlert.prototype, "handleDurationChange", 1);
+var TerraAlert = _TerraAlert;
+
+export {
+  TerraAlert
+};

package/cdn/chunks/chunk.JPMBV4LX.js

@@ -0,0 +1,29 @@
+import {
+  TerraDivider
+} from "./chunk.HPM2H4NS.js";
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// src/react/divider/index.ts
+init_dirname();
+init_buffer();
+init_process();
+import * as React from "react";
+import { createComponent } from "@lit/react";
+var tagName = "terra-divider";
+TerraDivider.define("terra-divider");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: TerraDivider,
+  react: React,
+  events: {},
+  displayName: "TerraDivider"
+});
+var divider_default = reactWrapper;
+
+export {
+  divider_default
+};

package/cdn/chunks/chunk.JS5TDQ5C.js

@@ -0,0 +1,348 @@
+import {
+  init_buffer,
+  init_dirname,
+  init_process
+} from "./chunk.ZEOVK2FE.js";
+
+// node_modules/@lit/reactive-element/css-tag.js
+init_dirname();
+init_buffer();
+init_process();
+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(t2, e3, o3) {
+    if (this._$cssResult$ = true, o3 !== s)
+      throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
+    this.cssText = t2, this.t = e3;
+  }
+  get styleSheet() {
+    let t2 = this.o;
+    const s2 = this.t;
+    if (e && void 0 === t2) {
+      const e3 = void 0 !== s2 && 1 === s2.length;
+      e3 && (t2 = o.get(s2)), void 0 === t2 && ((this.o = t2 = new CSSStyleSheet()).replaceSync(this.cssText), e3 && o.set(s2, t2));
+    }
+    return t2;
+  }
+  toString() {
+    return this.cssText;
+  }
+};
+var r = (t2) => new n("string" == typeof t2 ? t2 : t2 + "", void 0, s);
+var i = (t2, ...e3) => {
+  const o3 = 1 === t2.length ? t2[0] : e3.reduce((e4, s2, o4) => e4 + ((t3) => {
+    if (true === t3._$cssResult$)
+      return t3.cssText;
+    if ("number" == typeof t3)
+      return t3;
+    throw Error("Value passed to 'css' function must be a 'css' function result: " + t3 + ". Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security.");
+  })(s2) + t2[o4 + 1], t2[0]);
+  return new n(o3, t2, s);
+};
+var S = (s2, o3) => {
+  if (e)
+    s2.adoptedStyleSheets = o3.map((t2) => t2 instanceof CSSStyleSheet ? t2 : t2.styleSheet);
+  else
+    for (const e3 of o3) {
+      const o4 = document.createElement("style"), n3 = t.litNonce;
+      void 0 !== n3 && o4.setAttribute("nonce", n3), o4.textContent = e3.cssText, s2.appendChild(o4);
+    }
+};
+var c = e ? (t2) => t2 : (t2) => t2 instanceof CSSStyleSheet ? ((t3) => {
+  let e3 = "";
+  for (const s2 of t3.cssRules)
+    e3 += s2.cssText;
+  return r(e3);
+})(t2) : t2;
+
+// node_modules/@lit/reactive-element/reactive-element.js
+init_dirname();
+init_buffer();
+init_process();
+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 = (t2, s2) => t2;
+var u = { toAttribute(t2, s2) {
+  switch (s2) {
+    case Boolean:
+      t2 = t2 ? l : null;
+      break;
+    case Object:
+    case Array:
+      t2 = null == t2 ? t2 : JSON.stringify(t2);
+  }
+  return t2;
+}, fromAttribute(t2, s2) {
+  let i3 = t2;
+  switch (s2) {
+    case Boolean:
+      i3 = null !== t2;
+      break;
+    case Number:
+      i3 = null === t2 ? null : Number(t2);
+      break;
+    case Object:
+    case Array:
+      try {
+        i3 = JSON.parse(t2);
+      } catch (t3) {
+        i3 = null;
+      }
+  }
+  return i3;
+} };
+var f = (t2, s2) => !i2(t2, s2);
+var b = { attribute: true, type: String, converter: u, reflect: false, useDefault: false, hasChanged: f };
+var _a, _b;
+(_a = Symbol.metadata) != null ? _a : Symbol.metadata = Symbol("metadata"), (_b = a.litPropertyMetadata) != null ? _b : a.litPropertyMetadata = /* @__PURE__ */ new WeakMap();
+var y = class extends HTMLElement {
+  static addInitializer(t2) {
+    var _a3;
+    this._$Ei(), ((_a3 = this.l) != null ? _a3 : this.l = []).push(t2);
+  }
+  static get observedAttributes() {
+    return this.finalize(), this._$Eh && [...this._$Eh.keys()];
+  }
+  static createProperty(t2, s2 = b) {
+    if (s2.state && (s2.attribute = false), this._$Ei(), this.prototype.hasOwnProperty(t2) && ((s2 = Object.create(s2)).wrapped = true), this.elementProperties.set(t2, s2), !s2.noAccessor) {
+      const i3 = Symbol(), h2 = this.getPropertyDescriptor(t2, i3, s2);
+      void 0 !== h2 && e2(this.prototype, t2, h2);
+    }
+  }
+  static getPropertyDescriptor(t2, s2, i3) {
+    var _a3;
+    const { get: e3, set: r3 } = (_a3 = h(this.prototype, t2)) != null ? _a3 : { get() {
+      return this[s2];
+    }, set(t3) {
+      this[s2] = t3;
+    } };
+    return { get: e3, set(s3) {
+      const h2 = e3 == null ? void 0 : e3.call(this);
+      r3 == null ? void 0 : r3.call(this, s3), this.requestUpdate(t2, h2, i3);
+    }, configurable: true, enumerable: true };
+  }
+  static getPropertyOptions(t2) {
+    var _a3;
+    return (_a3 = this.elementProperties.get(t2)) != null ? _a3 : b;
+  }
+  static _$Ei() {
+    if (this.hasOwnProperty(d("elementProperties")))
+      return;
+    const t2 = n2(this);
+    t2.finalize(), void 0 !== t2.l && (this.l = [...t2.l]), this.elementProperties = new Map(t2.elementProperties);
+  }
+  static finalize() {
+    if (this.hasOwnProperty(d("finalized")))
+      return;
+    if (this.finalized = true, this._$Ei(), this.hasOwnProperty(d("properties"))) {
+      const t3 = this.properties, s2 = [...r2(t3), ...o2(t3)];
+      for (const i3 of s2)
+        this.createProperty(i3, t3[i3]);
+    }
+    const t2 = this[Symbol.metadata];
+    if (null !== t2) {
+      const s2 = litPropertyMetadata.get(t2);
+      if (void 0 !== s2)
+        for (const [t3, i3] of s2)
+          this.elementProperties.set(t3, i3);
+    }
+    this._$Eh = /* @__PURE__ */ new Map();
+    for (const [t3, s2] of this.elementProperties) {
+      const i3 = this._$Eu(t3, s2);
+      void 0 !== i3 && this._$Eh.set(i3, t3);
+    }
+    this.elementStyles = this.finalizeStyles(this.styles);
+  }
+  static finalizeStyles(s2) {
+    const i3 = [];
+    if (Array.isArray(s2)) {
+      const e3 = new Set(s2.flat(1 / 0).reverse());
+      for (const s3 of e3)
+        i3.unshift(c(s3));
+    } else
+      void 0 !== s2 && i3.push(c(s2));
+    return i3;
+  }
+  static _$Eu(t2, s2) {
+    const i3 = s2.attribute;
+    return false === i3 ? void 0 : "string" == typeof i3 ? i3 : "string" == typeof t2 ? t2.toLowerCase() : void 0;
+  }
+  constructor() {
+    super(), this._$Ep = void 0, this.isUpdatePending = false, this.hasUpdated = false, this._$Em = null, this._$Ev();
+  }
+  _$Ev() {
+    var _a3;
+    this._$ES = new Promise((t2) => this.enableUpdating = t2), this._$AL = /* @__PURE__ */ new Map(), this._$E_(), this.requestUpdate(), (_a3 = this.constructor.l) == null ? void 0 : _a3.forEach((t2) => t2(this));
+  }
+  addController(t2) {
+    var _a3, _b2;
+    ((_a3 = this._$EO) != null ? _a3 : this._$EO = /* @__PURE__ */ new Set()).add(t2), void 0 !== this.renderRoot && this.isConnected && ((_b2 = t2.hostConnected) == null ? void 0 : _b2.call(t2));
+  }
+  removeController(t2) {
+    var _a3;
+    (_a3 = this._$EO) == null ? void 0 : _a3.delete(t2);
+  }
+  _$E_() {
+    const t2 = /* @__PURE__ */ new Map(), s2 = this.constructor.elementProperties;
+    for (const i3 of s2.keys())
+      this.hasOwnProperty(i3) && (t2.set(i3, this[i3]), delete this[i3]);
+    t2.size > 0 && (this._$Ep = t2);
+  }
+  createRenderRoot() {
+    var _a3;
+    const t2 = (_a3 = this.shadowRoot) != null ? _a3 : this.attachShadow(this.constructor.shadowRootOptions);
+    return S(t2, this.constructor.elementStyles), t2;
+  }
+  connectedCallback() {
+    var _a3, _b2;
+    (_a3 = this.renderRoot) != null ? _a3 : this.renderRoot = this.createRenderRoot(), this.enableUpdating(true), (_b2 = this._$EO) == null ? void 0 : _b2.forEach((t2) => {
+      var _a4;
+      return (_a4 = t2.hostConnected) == null ? void 0 : _a4.call(t2);
+    });
+  }
+  enableUpdating(t2) {
+  }
+  disconnectedCallback() {
+    var _a3;
+    (_a3 = this._$EO) == null ? void 0 : _a3.forEach((t2) => {
+      var _a4;
+      return (_a4 = t2.hostDisconnected) == null ? void 0 : _a4.call(t2);
+    });
+  }
+  attributeChangedCallback(t2, s2, i3) {
+    this._$AK(t2, i3);
+  }
+  _$ET(t2, s2) {
+    var _a3;
+    const i3 = this.constructor.elementProperties.get(t2), e3 = this.constructor._$Eu(t2, i3);
+    if (void 0 !== e3 && true === i3.reflect) {
+      const h2 = (void 0 !== ((_a3 = i3.converter) == null ? void 0 : _a3.toAttribute) ? i3.converter : u).toAttribute(s2, i3.type);
+      this._$Em = t2, null == h2 ? this.removeAttribute(e3) : this.setAttribute(e3, h2), this._$Em = null;
+    }
+  }
+  _$AK(t2, s2) {
+    var _a3, _b2, _c;
+    const i3 = this.constructor, e3 = i3._$Eh.get(t2);
+    if (void 0 !== e3 && this._$Em !== e3) {
+      const t3 = i3.getPropertyOptions(e3), h2 = "function" == typeof t3.converter ? { fromAttribute: t3.converter } : void 0 !== ((_a3 = t3.converter) == null ? void 0 : _a3.fromAttribute) ? t3.converter : u;
+      this._$Em = e3;
+      const r3 = h2.fromAttribute(s2, t3.type);
+      this[e3] = (_c = r3 != null ? r3 : (_b2 = this._$Ej) == null ? void 0 : _b2.get(e3)) != null ? _c : r3, this._$Em = null;
+    }
+  }
+  requestUpdate(t2, s2, i3, e3 = false, h2) {
+    var _a3, _b2;
+    if (void 0 !== t2) {
+      const r3 = this.constructor;
+      if (false === e3 && (h2 = this[t2]), i3 != null ? i3 : i3 = r3.getPropertyOptions(t2), !(((_a3 = i3.hasChanged) != null ? _a3 : f)(h2, s2) || i3.useDefault && i3.reflect && h2 === ((_b2 = this._$Ej) == null ? void 0 : _b2.get(t2)) && !this.hasAttribute(r3._$Eu(t2, i3))))
+        return;
+      this.C(t2, s2, i3);
+    }
+    false === this.isUpdatePending && (this._$ES = this._$EP());
+  }
+  C(t2, s2, { useDefault: i3, reflect: e3, wrapped: h2 }, r3) {
+    var _a3, _b2, _c;
+    i3 && !((_a3 = this._$Ej) != null ? _a3 : this._$Ej = /* @__PURE__ */ new Map()).has(t2) && (this._$Ej.set(t2, (_b2 = r3 != null ? r3 : s2) != null ? _b2 : this[t2]), true !== h2 || void 0 !== r3) || (this._$AL.has(t2) || (this.hasUpdated || i3 || (s2 = void 0), this._$AL.set(t2, s2)), true === e3 && this._$Em !== t2 && ((_c = this._$Eq) != null ? _c : this._$Eq = /* @__PURE__ */ new Set()).add(t2));
+  }
+  async _$EP() {
+    this.isUpdatePending = true;
+    try {
+      await this._$ES;
+    } catch (t3) {
+      Promise.reject(t3);
+    }
+    const t2 = this.scheduleUpdate();
+    return null != t2 && await t2, !this.isUpdatePending;
+  }
+  scheduleUpdate() {
+    return this.performUpdate();
+  }
+  performUpdate() {
+    var _a3, _b2;
+    if (!this.isUpdatePending)
+      return;
+    if (!this.hasUpdated) {
+      if ((_a3 = this.renderRoot) != null ? _a3 : this.renderRoot = this.createRenderRoot(), this._$Ep) {
+        for (const [t4, s3] of this._$Ep)
+          this[t4] = s3;
+        this._$Ep = void 0;
+      }
+      const t3 = this.constructor.elementProperties;
+      if (t3.size > 0)
+        for (const [s3, i3] of t3) {
+          const { wrapped: t4 } = i3, e3 = this[s3];
+          true !== t4 || this._$AL.has(s3) || void 0 === e3 || this.C(s3, void 0, i3, e3);
+        }
+    }
+    let t2 = false;
+    const s2 = this._$AL;
+    try {
+      t2 = this.shouldUpdate(s2), t2 ? (this.willUpdate(s2), (_b2 = this._$EO) == null ? void 0 : _b2.forEach((t3) => {
+        var _a4;
+        return (_a4 = t3.hostUpdate) == null ? void 0 : _a4.call(t3);
+      }), this.update(s2)) : this._$EM();
+    } catch (s3) {
+      throw t2 = false, this._$EM(), s3;
+    }
+    t2 && this._$AE(s2);
+  }
+  willUpdate(t2) {
+  }
+  _$AE(t2) {
+    var _a3;
+    (_a3 = this._$EO) == null ? void 0 : _a3.forEach((t3) => {
+      var _a4;
+      return (_a4 = t3.hostUpdated) == null ? void 0 : _a4.call(t3);
+    }), this.hasUpdated || (this.hasUpdated = true, this.firstUpdated(t2)), this.updated(t2);
+  }
+  _$EM() {
+    this._$AL = /* @__PURE__ */ new Map(), this.isUpdatePending = false;
+  }
+  get updateComplete() {
+    return this.getUpdateComplete();
+  }
+  getUpdateComplete() {
+    return this._$ES;
+  }
+  shouldUpdate(t2) {
+    return true;
+  }
+  update(t2) {
+    this._$Eq && (this._$Eq = this._$Eq.forEach((t3) => this._$ET(t3, this[t3]))), this._$EM();
+  }
+  updated(t2) {
+  }
+  firstUpdated(t2) {
+  }
+};
+var _a2;
+y.elementStyles = [], y.shadowRootOptions = { mode: "open" }, y[d("elementProperties")] = /* @__PURE__ */ new Map(), y[d("finalized")] = /* @__PURE__ */ new Map(), p == null ? void 0 : p({ ReactiveElement: y }), ((_a2 = a.reactiveElementVersions) != null ? _a2 : a.reactiveElementVersions = []).push("2.1.2");
+
+export {
+  i,
+  u,
+  f,
+  y
+};
+/*! 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:
+  (**
+   * @license
+   * Copyright 2017 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+*/