@ds-autonomie/web-components 2.1.0 → 2.2.0

package/dist/chunks/chunk.UDJJFUZ3.js

@@ -0,0 +1,335 @@
+import {
+  input_otp_styles_default
+} from "./chunk.5P2EEOC5.js";
+import {
+  FormControlLayout
+} from "./chunk.I5HR7JYK.js";
+import {
+  defaultValue
+} from "./chunk.CMJ2SRTL.js";
+import {
+  FormControlController
+} from "./chunk.JA7YFGLI.js";
+import {
+  watch
+} from "./chunk.NOMN6DGD.js";
+import {
+  ifDefinedAndNotEmpty
+} from "./chunk.ZQJVCRB2.js";
+import {
+  __decorateClass
+} from "./chunk.S3NI7NKU.js";
+
+// src/components/input-otp/input-otp.ts
+import { html } from "lit";
+import { customElement, property, query, state } from "lit/decorators.js";
+import { classMap } from "lit/directives/class-map.js";
+import { ifDefined } from "lit/directives/if-defined.js";
+import { live } from "lit/directives/live.js";
+var DSAInputOTP = class extends FormControlLayout {
+  constructor() {
+    super(...arguments);
+    this.formControlController = new FormControlController(this, {
+      assumeInteractionOn: ["dsa-blur", "dsa-input"]
+    });
+    this.hasFocus = false;
+    this.currentIndex = 0;
+    this.value = "";
+    this.defaultValue = "";
+    this.length = 6;
+  }
+  /** Gets the validity state object */
+  get validity() {
+    return this.input.validity;
+  }
+  /** Gets the validation message */
+  get validationMessage() {
+    return this.input.validationMessage;
+  }
+  async firstUpdated() {
+    await this.updateComplete;
+    this.formControlController.updateValidity();
+  }
+  handleBlur() {
+    this.hasFocus = false;
+    this.emit("dsa-blur");
+  }
+  handleChange() {
+    this.value = this.input.value;
+    this.emit("dsa-change");
+  }
+  handleFocus() {
+    this.currentIndex = this.value ? -1 : 0;
+    this.hasFocus = true;
+    this.emit("dsa-focus");
+  }
+  handleInput(event) {
+    var _a;
+    if (this.patternRegexp && !this.patternRegexp.test(this.input.value)) {
+      this.input.value = this.value;
+      this.handleCurrentIndexChange();
+      return;
+    }
+    if (this.input.value.length > this.length) {
+      this.input.value = this.input.value.slice(0, this.length);
+    } else {
+      this.value = this.input.value;
+      if (!event.data) {
+        if (this.currentIndex === 0) {
+          this.handleCurrentIndexChange();
+        } else if (this.currentIndex === -1) {
+          this.currentIndex = 0;
+        } else {
+          this.currentIndex -= 1;
+        }
+      } else {
+        if (((_a = event.data) == null ? void 0 : _a.length) === 1) {
+          this.currentIndex = this.currentIndex < this.length ? this.currentIndex + 1 : this.length - 1;
+        } else {
+          this.currentIndex = this.getLastIndex();
+        }
+      }
+      this.formControlController.updateValidity();
+      this.emit("dsa-input");
+    }
+  }
+  handleSelect() {
+    if (this.input.value.length > 1 && this.input.selectionStart === 0 && this.input.selectionEnd === this.input.value.length) {
+      this.currentIndex = -1;
+    }
+  }
+  handleInvalid(event) {
+    this.formControlController.setValidity(false);
+    this.formControlController.emitInvalidEvent(event);
+  }
+  handleKeyDown(event) {
+    const hasModifier = event.metaKey || event.ctrlKey || event.shiftKey || event.altKey;
+    if (event.key === "Enter" && !hasModifier) {
+      setTimeout(() => {
+        if (!event.defaultPrevented && !event.isComposing) {
+          this.formControlController.submit();
+        }
+      });
+    }
+    if (["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(event.key)) {
+      event.preventDefault();
+      switch (event.key) {
+        case "ArrowLeft":
+          this.currentIndex = this.currentIndex > 0 ? this.currentIndex - 1 : 0;
+          break;
+        case "ArrowRight":
+          if (this.currentIndex === -1) {
+            this.currentIndex = this.getLastIndex();
+          } else if (this.currentIndex < this.value.length && this.currentIndex < this.length - 1) {
+            this.currentIndex += 1;
+          }
+          break;
+        case "ArrowUp":
+          this.currentIndex = 0;
+          break;
+        case "ArrowDown":
+          this.currentIndex = this.getLastIndex();
+          break;
+      }
+    }
+  }
+  handleSingleFieldClick(event) {
+    this.focus();
+    if (event.currentTarget instanceof HTMLElement) {
+      const clickedIndex = Number(event.currentTarget.dataset.fieldIndex);
+      this.currentIndex = clickedIndex < this.value.length ? clickedIndex : this.getLastIndex();
+    }
+  }
+  getLastIndex() {
+    return this.value.length > 0 ? Math.min(this.value.length, this.length - 1) : 0;
+  }
+  getDescriptionIds() {
+    const ids = [...this.error ? ["error-text"] : [], "help-text"];
+    return ids.join(" ");
+  }
+  handleCurrentIndexChange() {
+    if (this.currentIndex === -1) {
+      this.input.setSelectionRange(0, this.input.value.length);
+    } else {
+      this.input.setSelectionRange(this.currentIndex, this.currentIndex + 1);
+    }
+  }
+  handleDisabledChange() {
+    this.formControlController.setValidity(this.disabled);
+  }
+  async handleValueChange() {
+    await this.updateComplete;
+    this.formControlController.updateValidity();
+  }
+  handlePatterChange() {
+    this.patternRegexp = new RegExp(this.pattern);
+  }
+  /** Removes focus from the input. */
+  blur() {
+    this.input.blur();
+  }
+  /** Checks for validity but does not show a validation message. Returns `true` when valid and `false` when invalid. */
+  checkValidity() {
+    return this.input.checkValidity();
+  }
+  /** Sets focus on the input. */
+  focus(options) {
+    this.input.focus(options);
+  }
+  /** Gets the associated form, if one exists. */
+  getForm() {
+    return this.formControlController.getForm();
+  }
+  /** Checks for validity and shows the browser's validation message if the control is invalid. */
+  reportValidity() {
+    return this.input.reportValidity();
+  }
+  /** Selects all the text in the input. */
+  select() {
+    if (this.input instanceof HTMLInputElement) {
+      this.input.select();
+    }
+  }
+  /** Sets a custom validation message. Pass an empty string to restore validity. */
+  setCustomValidity(message) {
+    this.input.setCustomValidity(message);
+    this.formControlController.updateValidity();
+  }
+  async getUpdateComplete() {
+    const result = await super.getUpdateComplete();
+    return result;
+  }
+  renderSingleField(index) {
+    const charValue = this.value.split("")[index];
+    const isCurrentField = this.currentIndex === index || this.currentIndex === -1 && charValue;
+    const inputClasses = classMap({
+      "single-field": true,
+      "single-field--active": this.hasFocus && isCurrentField
+    });
+    return html`
+      <div
+        class=${inputClasses}
+        data-field-index=${index}
+        aria-hidden="true"
+        @click=${this.handleSingleFieldClick}
+      >
+        ${charValue || this.hasFocus && isCurrentField ? html`<span class="single-field__value">${charValue}</span>` : html`
+              <span class="single-field__placeholder"
+                >${this.placeholder.charAt(0)}</span
+              >
+            `}
+        ${this.hasFocus && isCurrentField && !charValue ? html` <div class="fake-caret"></div> ` : ""}
+      </div>
+    `;
+  }
+  renderInput() {
+    const hasLabelSlot = this.hasSlotController.test("label");
+    const hasLabel = this.label ? true : !!hasLabelSlot;
+    return html`
+      <div part="base" class="input__wrapper">
+        <div
+          class=${classMap({
+      "visible-input": true,
+      "input--focused": this.hasFocus,
+      // Sizes
+      "input--small": this.size === "small",
+      "input--medium": this.size === "medium",
+      "input--large": this.size === "large",
+      // States
+      "input--error": this.error,
+      "input--on-layer": this.variant === "layer",
+      "input--on-base": this.variant === "base",
+      "input--disabled": this.disabled
+    })}
+        >
+          ${Array.from(Array(this.length)).map(
+      (_, index) => this.renderSingleField(index)
+    )}
+        </div>
+        <input
+          part="input"
+          id="input"
+          class="hidden-input"
+          type="text"
+          name=${ifDefinedAndNotEmpty(this.name)}
+          ?disabled=${this.disabled}
+          ?required=${this.required}
+          minlength=${this.length}
+          maxlength=${this.length}
+          .value=${live(this.value)}
+          autocomplete="one-time-code"
+          ?autofocus=${this.autofocus}
+          pattern=${ifDefined(this.pattern)}
+          enterkeyhint=${ifDefined(this.enterkeyhint)}
+          inputmode=${ifDefined(this.inputmode)}
+          aria-label=${ifDefinedAndNotEmpty(hasLabel ? void 0 : this.title)}
+          aria-describedby=${this.getDescriptionIds()}
+          aria-invalid=${ifDefined(this.error ? "true" : void 0)}
+          @change=${this.handleChange}
+          @input=${this.handleInput}
+          @invalid=${this.handleInvalid}
+          @keydown=${this.handleKeyDown}
+          @focus=${this.handleFocus}
+          @blur=${this.handleBlur}
+          @select=${this.handleSelect}
+        />
+      </div>
+    `;
+  }
+};
+DSAInputOTP.styles = input_otp_styles_default;
+__decorateClass([
+  query("input")
+], DSAInputOTP.prototype, "input", 2);
+__decorateClass([
+  state()
+], DSAInputOTP.prototype, "hasFocus", 2);
+__decorateClass([
+  state()
+], DSAInputOTP.prototype, "currentIndex", 2);
+__decorateClass([
+  state()
+], DSAInputOTP.prototype, "patternRegexp", 2);
+__decorateClass([
+  property()
+], DSAInputOTP.prototype, "value", 2);
+__decorateClass([
+  defaultValue()
+], DSAInputOTP.prototype, "defaultValue", 2);
+__decorateClass([
+  property()
+], DSAInputOTP.prototype, "pattern", 2);
+__decorateClass([
+  property({ type: Number })
+], DSAInputOTP.prototype, "length", 2);
+__decorateClass([
+  property()
+], DSAInputOTP.prototype, "autocapitalize", 2);
+__decorateClass([
+  property({ type: Boolean })
+], DSAInputOTP.prototype, "autofocus", 2);
+__decorateClass([
+  property()
+], DSAInputOTP.prototype, "enterkeyhint", 2);
+__decorateClass([
+  property()
+], DSAInputOTP.prototype, "inputmode", 2);
+__decorateClass([
+  watch("currentIndex", { waitUntilFirstUpdate: true })
+], DSAInputOTP.prototype, "handleCurrentIndexChange", 1);
+__decorateClass([
+  watch("disabled", { waitUntilFirstUpdate: true })
+], DSAInputOTP.prototype, "handleDisabledChange", 1);
+__decorateClass([
+  watch("value", { waitUntilFirstUpdate: true })
+], DSAInputOTP.prototype, "handleValueChange", 1);
+__decorateClass([
+  watch("pattern")
+], DSAInputOTP.prototype, "handlePatterChange", 1);
+DSAInputOTP = __decorateClass([
+  customElement("dsa-input-otp")
+], DSAInputOTP);
+
+export {
+  DSAInputOTP
+};

package/dist/chunks/{chunk.YXXLXJPE.js → chunk.UEWG3G4R.js}

@@ -15,6 +15,12 @@ var DSACheckboxButton = class extends FormToggleButton {
     super(...arguments);
     this.type = "checkbox";
   }
+  connectedCallback() {
+    super.connectedCallback();
+    if (!this.hasAttribute("role")) {
+      this.setAttribute("role", "listitem");
+    }
+  }
   handleClick() {
     this.checked = !this.checked;
   }

package/dist/chunks/{chunk.WWANVBI5.js → chunk.UWGAOHHQ.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk.7OLEA3GQ.js";
 import {
   FormControlLayout
-} from "./chunk.T4BUHP4L.js";
+} from "./chunk.I5HR7JYK.js";
 import {
   defaultValue
 } from "./chunk.CMJ2SRTL.js";

package/dist/chunks/{chunk.EGH3AVD7.js → chunk.VBW5RZBM.js}

@@ -81,7 +81,7 @@ var DSATab = class extends ShoelaceElement {
                 part="close-button"
                 exportparts="base:close-button__base"
                 name="close"
-                label=${this.closeButtonLabel !== "" ? this.closeButtonLabel : this.localize.term("close")}
+                label=${this.closeButtonLabel && this.closeButtonLabel !== "" ? this.closeButtonLabel : this.localize.term("close")}
                 class="tab__close-button"
                 @click=${this.handleCloseClick}
                 library="system"

package/dist/chunks/{chunk.XXHMFUD7.js → chunk.WRPRKCVY.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk.OOZC4AR2.js";
 import {
   DSAInput
-} from "./chunk.D3SHMAJT.js";
+} from "./chunk.H3FSR35C.js";
 import {
   FilterBase
 } from "./chunk.FQB6S2KS.js";

package/dist/chunks/{chunk.G422H4DZ.js → chunk.WUOMKASN.js}

@@ -1,3 +1,6 @@
+import {
+  DSACheckboxGroup
+} from "./chunk.XJMGXWLM.js";
 import {
   defaultValue
 } from "./chunk.CMJ2SRTL.js";
@@ -63,6 +66,13 @@ var DSACheckbox = class extends ShoelaceElement {
   get validationMessage() {
     return this.input.validationMessage;
   }
+  connectedCallback() {
+    super.connectedCallback();
+    const parent = this.parentElement;
+    if (!this.hasAttribute("role") && parent instanceof DSACheckboxGroup) {
+      this.setAttribute("role", "listitem");
+    }
+  }
   firstUpdated() {
     this.formControlController.updateValidity();
   }

package/dist/chunks/{chunk.ZYTDWH4E.js → chunk.XJMGXWLM.js}

@@ -1,6 +1,9 @@
 import {
   checkbox_group_styles_default
-} from "./chunk.VOOE2BQV.js";
+} from "./chunk.6HR34L7E.js";
+import {
+  a11yWarning
+} from "./chunk.PWL7QCVG.js";
 import {
   renderFormElementErrors
 } from "./chunk.IZBHR7GP.js";
@@ -39,7 +42,6 @@ var DSACheckboxGroup = class extends ShoelaceElement {
     this.customValidityMessage = "";
     this.hasCheckboxButtons = false;
     this.defaultValue = [];
-    this.allCheckboxes = [];
     this.label = "";
     this.helpText = "";
     this.name = "option";
@@ -81,45 +83,9 @@ var DSACheckboxGroup = class extends ShoelaceElement {
   }
   firstUpdated() {
     this.formControlController.updateValidity();
-    this.allCheckboxes = this.getAllCheckboxes();
-    this.observeSlottedElements();
-  }
-  // A change of attributes on the slotted elements does not trigger the "slotchange" event, so we add an observer
-  observeSlottedElements() {
-    this.slottedElementsObserver = new MutationObserver((mutationsList) => {
-      let needsUpdate = false;
-      mutationsList.forEach((mutation) => {
-        if (mutation.type === "attributes" || mutation.type === "childList") {
-          needsUpdate = true;
-        }
-      });
-      if (needsUpdate) {
-        this.handleSlottedElementChange();
-      }
-    });
-    [...this.defaultSlot.assignedElements({ flatten: true })].forEach(
-      (element) => {
-        this.slottedElementsObserver.observe(element, {
-          attributes: true,
-          childList: true
-        });
-      }
-    );
   }
   getAllCheckboxes() {
-    const checboxNodeList = this.querySelectorAll("dsa-checkbox, dsa-checkbox-button");
-    const allCheckboxes = [];
-    checboxNodeList.forEach((checkbox) => {
-      const clonedCheckbox = checkbox.cloneNode(true);
-      if (this.disabled) {
-        clonedCheckbox.disabled = true;
-      }
-      if (this.readonly) {
-        clonedCheckbox.readonly = true;
-      }
-      allCheckboxes.push(clonedCheckbox);
-    });
-    return allCheckboxes;
+    return [...this.defaultSlot.assignedElements({ flatten: true })];
   }
   handleCheckboxClick(event) {
     if (event.target.tagName.toLowerCase() === "a") {
@@ -142,11 +108,11 @@ var DSACheckboxGroup = class extends ShoelaceElement {
         (checkboxValue) => checkboxValue !== target.value
       );
     }
-    this.allCheckboxes.forEach((checkbox) => {
+    this.getAllCheckboxes().forEach((checkbox) => {
       checkbox.checked = this.value.includes(checkbox.value);
     });
-    this.emit("dsa-input");
     this.emit("dsa-change");
+    this.emit("dsa-input");
   }
   handleKeyDown(event) {
     if (event.target.tagName.toLowerCase() === "a") {
@@ -159,7 +125,7 @@ var DSACheckboxGroup = class extends ShoelaceElement {
         return;
       }
       target.checked = !target.checked;
-      const checkedCheckboxes = this.allCheckboxes.filter(
+      const checkedCheckboxes = this.getAllCheckboxes().filter(
         (checkbox) => checkbox.checked
       );
       this.value = checkedCheckboxes.map((checkbox) => checkbox.value);
@@ -168,7 +134,7 @@ var DSACheckboxGroup = class extends ShoelaceElement {
     }
   }
   handleLabelClick() {
-    const availableCheckboxes = this.allCheckboxes.filter(
+    const availableCheckboxes = this.getAllCheckboxes().filter(
       (checkbox) => !checkbox.disabled && !checkbox.readonly
     );
     const checkboxToFocus = availableCheckboxes.find((checkbox) => checkbox.checked) || availableCheckboxes[0];
@@ -177,9 +143,8 @@ var DSACheckboxGroup = class extends ShoelaceElement {
     }
   }
   handleSlottedElementChange() {
-    var _a;
-    this.allCheckboxes = this.getAllCheckboxes();
-    this.allCheckboxes.forEach((checkbox) => {
+    const allCheckboxes = this.getAllCheckboxes();
+    allCheckboxes.forEach((checkbox) => {
       if (this.disabled) {
         checkbox.disabled = true;
       }
@@ -188,22 +153,13 @@ var DSACheckboxGroup = class extends ShoelaceElement {
       }
       checkbox.checked = this.value.includes(checkbox.value);
     });
-    this.hasCheckboxButtons = this.allCheckboxes.some(
+    this.hasCheckboxButtons = allCheckboxes.some(
       (checkbox) => checkbox.tagName.toLowerCase() === "dsa-checkbox-button"
     );
-    if (this.hasCheckboxButtons) {
-      const buttonGroup = (_a = this.shadowRoot) == null ? void 0 : _a.querySelector(
-        "dsa-internal-button-group"
-      );
-      if (buttonGroup) {
-        buttonGroup.disableRole = true;
-      }
-    }
   }
   handleSlotChange() {
     if (customElements.get("dsa-checkbox") || customElements.get("dsa-checkbox-button")) {
       this.handleSlottedElementChange();
-      this.observeSlottedElements();
     } else {
       customElements.whenDefined("dsa-checkbox").then(() => this.handleSlotChange());
       customElements.whenDefined("dsa-checkbox-button").then(() => this.handleSlotChange());
@@ -213,17 +169,12 @@ var DSACheckboxGroup = class extends ShoelaceElement {
     this.formControlController.setValidity(false);
     this.formControlController.emitInvalidEvent(event);
   }
-  updateCheckedCheckbox() {
-    this.allCheckboxes.forEach(
+  handleValueChange() {
+    this.getAllCheckboxes().forEach(
       (checkbox) => checkbox.checked = this.value.includes(checkbox.value)
     );
     this.formControlController.setValidity(this.validity.valid);
   }
-  handleValueChange() {
-    if (this.hasUpdated) {
-      this.updateCheckedCheckbox();
-    }
-  }
   handleErrorChange() {
     if (this.error) {
       this.setAttribute("aria-invalid", "true");
@@ -273,8 +224,8 @@ var DSACheckboxGroup = class extends ShoelaceElement {
     const hasLabel = this.label ? true : !!hasLabelSlot;
     const hasHelpText = this.helpText ? true : !!hasHelpTextSlot;
     if (!hasLabel) {
-      console.warn(
-        "(a11y) <dsa-checkbox-group> requires a label attribute or a label slot for accessibility"
+      a11yWarning(
+        "<dsa-checkbox-group> requires a label attribute or a label slot for accessibility"
       );
     }
     return html`
@@ -315,7 +266,7 @@ var DSACheckboxGroup = class extends ShoelaceElement {
           part="form-control-input"
           class="form-control-input form-control__field"
         >
-          <div class="visually-hidden">
+          <dsa-visually-hidden>
             <label class="checkbox-group__validation">
               <input
                 class="checkbox-group__validation-input"
@@ -326,7 +277,7 @@ var DSACheckboxGroup = class extends ShoelaceElement {
                 @invalid=${this.handleInvalid}
               />
             </label>
-          </div>
+          </dsa-visually-hidden>
 
           <div class="checkbox-group__list-container">
             <div
@@ -338,22 +289,9 @@ var DSACheckboxGroup = class extends ShoelaceElement {
               @click=${this.handleCheckboxClick}
               @keydown=${this.handleKeyDown}
             >
-              ${this.allCheckboxes.map(
-      (checkbox) => html` <div
-                  part="form-control-options"
-                  class="checkbox-group__listitem"
-                  role="listitem"
-                >
-                  ${checkbox}
-                </div>`
-    )}
+              <slot @slotchange=${this.handleSlotChange}></slot>
             </div>
           </div>
-          <slot
-            @click=${this.handleCheckboxClick}
-            @slotchange=${this.handleSlotChange}
-            class="checkbox-group__default-slot"
-          ></slot>
         </div>
         <slot
           name="help-text"
@@ -383,9 +321,6 @@ __decorateClass([
 __decorateClass([
   state()
 ], DSACheckboxGroup.prototype, "defaultValue", 2);
-__decorateClass([
-  state()
-], DSACheckboxGroup.prototype, "allCheckboxes", 2);
 __decorateClass([
   property()
 ], DSACheckboxGroup.prototype, "label", 2);
@@ -446,7 +381,7 @@ __decorateClass([
   property({ type: Boolean, attribute: "hide-label" })
 ], DSACheckboxGroup.prototype, "hideLabel", 2);
 __decorateClass([
-  watch("value")
+  watch("value", { waitUntilFirstUpdate: true })
 ], DSACheckboxGroup.prototype, "handleValueChange", 1);
 __decorateClass([
   watch("error")

package/dist/chunks/{chunk.6GN2WDDT.js → chunk.Y52TCF24.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk.VT3IWNRD.js";
 import {
   FormControlLayout
-} from "./chunk.T4BUHP4L.js";
+} from "./chunk.I5HR7JYK.js";
 import {
   scrollIntoView
 } from "./chunk.EMIT7S33.js";

package/dist/components/checkbox/checkbox.d.ts

@@ -67,6 +67,7 @@ export default class DSACheckbox extends ShoelaceElement implements ShoelaceForm
     get validity(): ValidityState;
     /** Gets the validation message */
     get validationMessage(): string;
+    connectedCallback(): void;
     firstUpdated(): void;
     private handleClick;
     private handleBlur;

package/dist/components/checkbox/checkbox.js

@@ -1,7 +1,12 @@
 import {
   DSACheckbox
-} from "../../chunks/chunk.G422H4DZ.js";
+} from "../../chunks/chunk.WUOMKASN.js";
+import "../../chunks/chunk.XJMGXWLM.js";
+import "../../chunks/chunk.DCHXTN27.js";
+import "../../chunks/chunk.IOFPPNUO.js";
+import "../../chunks/chunk.6HR34L7E.js";
 import "../../chunks/chunk.CMJ2SRTL.js";
+import "../../chunks/chunk.PWL7QCVG.js";
 import "../../chunks/chunk.KFXWL3NW.js";
 import "../../chunks/chunk.EYZGEU3G.js";
 import "../../chunks/chunk.IZBHR7GP.js";

package/dist/components/checkbox-button/checkbox-button.d.ts

@@ -12,6 +12,7 @@ import { FormToggleButton } from '../../internal/components/form-toggle-button/f
  */
 export default class DSACheckboxButton extends FormToggleButton {
     protected type: "checkbox";
+    connectedCallback(): void;
     protected handleClick(): void;
     handleErrorChange(): void;
 }

package/dist/components/checkbox-button/checkbox-button.js

@@ -1,6 +1,6 @@
 import {
   DSACheckboxButton
-} from "../../chunks/chunk.YXXLXJPE.js";
+} from "../../chunks/chunk.UEWG3G4R.js";
 import "../../chunks/chunk.GGXJ2MP3.js";
 import "../../chunks/chunk.2JIPPL3I.js";
 import "../../chunks/chunk.FKXOTDTY.js";