@ds-autonomie/web-components 2.18.0 → 2.20.0

package/dist/chunks/chunk.D5YUY5BG.js

@@ -0,0 +1,608 @@
+import {
+  table_styles_default
+} from "./chunk.PHSUFADX.js";
+import {
+  removeAttributeIfPresent,
+  setAttributeIfDifferent
+} from "./chunk.PSYTLBRK.js";
+import {
+  watch
+} from "./chunk.QB2NJE2Y.js";
+import {
+  ShoelaceElement
+} from "./chunk.SVWU6JW4.js";
+import {
+  __decorateClass
+} from "./chunk.N3L4GIUO.js";
+
+// src/components/table/table.ts
+import { html } from "lit";
+import { customElement, property } from "lit/decorators.js";
+var DSATable = class extends ShoelaceElement {
+  constructor() {
+    super(...arguments);
+    this.suppressHoverClass = "reordering-no-hover";
+    this.draggingRow = null;
+    this.dropTargetRow = null;
+    this.rearrangingRow = null;
+    this.role = "table";
+    this.size = "medium";
+    this.alignment = "left";
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.handleRowSelect = this.handleRowSelect.bind(this);
+    this.handleAllRowsSelect = this.handleAllRowsSelect.bind(this);
+    this.handleRowReorderToggle = this.handleRowReorderToggle.bind(this);
+    this.handleRowReorderMove = this.handleRowReorderMove.bind(this);
+    this.handleRowReorderDragStart = this.handleRowReorderDragStart.bind(this);
+    this.handleRowReorderDragEnd = this.handleRowReorderDragEnd.bind(this);
+    this.handleDragOver = this.handleDragOver.bind(this);
+    this.handleWindowDragOver = this.handleWindowDragOver.bind(this);
+    this.handleDrop = this.handleDrop.bind(this);
+    this.handleMouseMoveAfterReorder = this.handleMouseMoveAfterReorder.bind(this);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.removeRowSelectionListeners();
+    this.removeRowReorderListeners();
+    this.enableRowHover();
+    this.clearReorderState();
+  }
+  async firstUpdated() {
+    if (!this.selectable) {
+      return;
+    }
+    const headerRow = this.querySelector(
+      this.selectorHeaderRow
+    );
+    if (headerRow) {
+      await headerRow.updateComplete;
+      const allRows = [
+        ...this.querySelectorAll(this.selectorAllRows)
+      ];
+      if (headerRow == null ? void 0 : headerRow.selected) {
+        allRows.forEach((row) => row.selected = headerRow.selected);
+      } else {
+        const selectedRows = allRows.filter((row) => row.selected);
+        const selectedRowsCount = selectedRows.length;
+        const allRowsSelected = selectedRowsCount === allRows.length;
+        headerRow.checkbox.checked = selectedRowsCount > 0 && allRowsSelected;
+        headerRow.checkbox.indeterminate = selectedRowsCount > 0 && !allRowsSelected;
+      }
+    }
+  }
+  // Listeners
+  addRowSelectionListeners() {
+    this.addEventListener(
+      "dsa-table-row-change-selection",
+      this.handleRowSelect
+    );
+    this.addEventListener(
+      "dsa-table-row-all-change-selection",
+      this.handleAllRowsSelect
+    );
+  }
+  removeRowSelectionListeners() {
+    this.removeEventListener(
+      "dsa-table-row-change-selection",
+      this.handleRowSelect
+    );
+    this.removeEventListener(
+      "dsa-table-row-all-change-selection",
+      this.handleAllRowsSelect
+    );
+  }
+  addRowReorderListeners() {
+    this.addEventListener(
+      "dsa-table-row-reorder-toggle",
+      this.handleRowReorderToggle
+    );
+    this.addEventListener(
+      "dsa-table-row-reorder-move",
+      this.handleRowReorderMove
+    );
+    this.addEventListener(
+      "dsa-table-row-reorder-drag-start",
+      this.handleRowReorderDragStart
+    );
+    this.addEventListener(
+      "dsa-table-row-reorder-drag-end",
+      this.handleRowReorderDragEnd
+    );
+    this.addEventListener("dragover", this.handleDragOver);
+    this.addEventListener("drop", this.handleDrop);
+    window.addEventListener("dragover", this.handleWindowDragOver, true);
+  }
+  removeRowReorderListeners() {
+    this.removeEventListener(
+      "dsa-table-row-reorder-toggle",
+      this.handleRowReorderToggle
+    );
+    this.removeEventListener(
+      "dsa-table-row-reorder-move",
+      this.handleRowReorderMove
+    );
+    this.removeEventListener(
+      "dsa-table-row-reorder-drag-start",
+      this.handleRowReorderDragStart
+    );
+    this.removeEventListener(
+      "dsa-table-row-reorder-drag-end",
+      this.handleRowReorderDragEnd
+    );
+    this.removeEventListener("dragover", this.handleDragOver);
+    this.removeEventListener("drop", this.handleDrop);
+    window.removeEventListener("dragover", this.handleWindowDragOver, true);
+  }
+  clearDropTarget() {
+    if (this.dropTargetRow) {
+      removeAttributeIfPresent(this.dropTargetRow, "drop-target");
+      removeAttributeIfPresent(this.dropTargetRow, "drop-target-position");
+      this.dropTargetRow = null;
+    }
+  }
+  clearReorderState() {
+    if (this.rearrangingRow) {
+      this.rearrangingRow.rearranging = false;
+      this.rearrangingRow = null;
+    }
+    if (this.draggingRow) {
+      removeAttributeIfPresent(this.draggingRow, "dragging");
+      this.draggingRow = null;
+    }
+    if (this.dropTargetRow) {
+      this.clearDropTarget();
+    }
+  }
+  handleWindowDragOver(event) {
+    if (!this.reorderable || !this.draggingRow) {
+      return;
+    }
+    if (!event.composedPath().includes(this)) {
+      this.clearDropTarget();
+    }
+  }
+  getRows() {
+    return [...this.querySelectorAll(this.selectorAllRows)];
+  }
+  getRowBlock(row) {
+    const nextSibling = row.nextElementSibling;
+    const expandedRow = (nextSibling == null ? void 0 : nextSibling.matches(this.selectorAllExpandedRows)) ? nextSibling : null;
+    return { row, expandedRow };
+  }
+  getNodeAfterRowBlock(row) {
+    var _a;
+    const { expandedRow } = this.getRowBlock(row);
+    return (_a = expandedRow == null ? void 0 : expandedRow.nextSibling) != null ? _a : row.nextSibling;
+  }
+  moveRowToIndex(row, requestedIndex, source) {
+    var _a, _b;
+    const rows = this.getRows();
+    const oldIndex = rows.indexOf(row);
+    if (oldIndex < 0) {
+      return;
+    }
+    const maxIndex = rows.length - 1;
+    const targetIndex = Math.max(0, Math.min(requestedIndex, maxIndex));
+    if (targetIndex === oldIndex) {
+      return;
+    }
+    const targetRow = rows[targetIndex];
+    const { expandedRow } = this.getRowBlock(row);
+    const referenceNode = oldIndex < targetIndex ? this.getNodeAfterRowBlock(targetRow) : targetRow;
+    (_a = row.parentNode) == null ? void 0 : _a.insertBefore(row, referenceNode);
+    if (expandedRow) {
+      (_b = row.parentNode) == null ? void 0 : _b.insertBefore(expandedRow, row.nextSibling);
+    }
+    const reorderedRows = this.getRows();
+    const newIndex = reorderedRows.indexOf(row);
+    this.disableRowHoverUntilMouseMove();
+    this.emit("dsa-table-row-reordered", {
+      detail: {
+        movedRow: row,
+        oldIndex,
+        newIndex,
+        rows: reorderedRows,
+        source
+      }
+    });
+  }
+  handleMouseMoveAfterReorder() {
+    this.enableRowHover();
+  }
+  disableRowHoverUntilMouseMove() {
+    this.getRows().forEach((row) => {
+      if (!row.classList.contains(this.suppressHoverClass)) {
+        row.classList.add(this.suppressHoverClass);
+      }
+    });
+    window.removeEventListener("mousemove", this.handleMouseMoveAfterReorder);
+    window.addEventListener("mousemove", this.handleMouseMoveAfterReorder, {
+      once: true
+    });
+  }
+  enableRowHover() {
+    this.getRows().forEach((row) => {
+      if (row.classList.contains(this.suppressHoverClass)) {
+        row.classList.remove(this.suppressHoverClass);
+      }
+    });
+    window.removeEventListener("mousemove", this.handleMouseMoveAfterReorder);
+  }
+  findRowFromEvent(event) {
+    const row = event.composedPath().find(
+      (node) => {
+        var _a;
+        return node instanceof HTMLElement && ((_a = node.matches) == null ? void 0 : _a.call(node, this.selectorAllRows));
+      }
+    );
+    return row != null ? row : null;
+  }
+  handleRowReorderToggle(event) {
+    var _a;
+    if (!this.reorderable) {
+      return;
+    }
+    const { row } = event.detail;
+    event.stopPropagation();
+    const shouldActivate = this.rearrangingRow !== row;
+    if (this.rearrangingRow) {
+      this.rearrangingRow.rearranging = false;
+    }
+    this.rearrangingRow = shouldActivate ? row : null;
+    row.rearranging = shouldActivate;
+    (_a = row.reorderButton) == null ? void 0 : _a.focus();
+  }
+  handleRowReorderMove(event) {
+    var _a;
+    if (!this.reorderable) {
+      return;
+    }
+    const { row, direction } = event.detail;
+    event.stopPropagation();
+    if (this.rearrangingRow !== row) {
+      return;
+    }
+    const rows = this.getRows();
+    const rowIndex = rows.indexOf(row);
+    if (rowIndex < 0) {
+      return;
+    }
+    const targetIndex = direction === "up" ? Math.max(0, rowIndex - 1) : Math.min(rows.length - 1, rowIndex + 1);
+    this.moveRowToIndex(row, targetIndex, "keyboard");
+    (_a = row.reorderButton) == null ? void 0 : _a.focus();
+  }
+  handleRowReorderDragStart(event) {
+    if (!this.reorderable) {
+      return;
+    }
+    const { row } = event.detail;
+    event.stopPropagation();
+    this.draggingRow = row;
+    setAttributeIfDifferent(row, "dragging", "true");
+    if (this.rearrangingRow && this.rearrangingRow !== row) {
+      this.rearrangingRow.rearranging = false;
+    }
+    this.rearrangingRow = row;
+  }
+  handleRowReorderDragEnd() {
+    this.clearReorderState();
+  }
+  handleDragOver(event) {
+    if (!this.reorderable || !this.draggingRow) {
+      return;
+    }
+    const targetRow = this.findRowFromEvent(event);
+    if (!targetRow || targetRow === this.draggingRow) {
+      this.clearDropTarget();
+      return;
+    }
+    event.preventDefault();
+    if (event.dataTransfer) {
+      event.dataTransfer.dropEffect = "move";
+    }
+    if (this.dropTargetRow && this.dropTargetRow !== targetRow) {
+      removeAttributeIfPresent(this.dropTargetRow, "drop-target");
+      removeAttributeIfPresent(this.dropTargetRow, "drop-target-position");
+    }
+    if (this.dropTargetRow !== targetRow) {
+      this.dropTargetRow = targetRow;
+      setAttributeIfDifferent(targetRow, "drop-target", "true");
+    }
+    const rect = targetRow.getBoundingClientRect();
+    const isAfterTarget = event.clientY > rect.top + rect.height / 2;
+    const nextDropTargetPosition = isAfterTarget ? "after" : "before";
+    if (targetRow.getAttribute("drop-target-position") !== nextDropTargetPosition) {
+      setAttributeIfDifferent(
+        targetRow,
+        "drop-target-position",
+        nextDropTargetPosition
+      );
+    }
+  }
+  handleDrop(event) {
+    var _a;
+    if (!this.reorderable || !this.draggingRow) {
+      return;
+    }
+    const targetRow = this.findRowFromEvent(event);
+    event.preventDefault();
+    if (!targetRow || targetRow === this.draggingRow) {
+      this.clearReorderState();
+      return;
+    }
+    const rows = this.getRows();
+    const oldIndex = rows.indexOf(this.draggingRow);
+    const targetIndex = rows.indexOf(targetRow);
+    if (oldIndex < 0 || targetIndex < 0) {
+      this.clearReorderState();
+      return;
+    }
+    const rect = targetRow.getBoundingClientRect();
+    const isAfterTarget = event.clientY > rect.top + rect.height / 2;
+    let requestedIndex = targetIndex + (isAfterTarget ? 1 : 0);
+    if (oldIndex < requestedIndex) {
+      requestedIndex -= 1;
+    }
+    this.moveRowToIndex(this.draggingRow, requestedIndex, "pointer");
+    (_a = this.draggingRow.reorderButton) == null ? void 0 : _a.focus();
+    this.clearReorderState();
+  }
+  handleAllRowsSelect() {
+    const headerRow = this.querySelector(
+      this.selectorHeaderRow
+    );
+    if (headerRow === null) {
+      return;
+    }
+    const allRows = [
+      ...this.querySelectorAll(this.selectorAllRows)
+    ];
+    allRows.forEach((row) => row.selected = headerRow.selected);
+    const selectedRows = allRows.filter((row) => row.selected);
+    this.emit("dsa-table-row-all-selected", {
+      detail: { selectedRows }
+    });
+  }
+  handleRowSelect(event) {
+    const { target } = event;
+    const allRows = [
+      ...this.querySelectorAll(this.selectorAllRows)
+    ];
+    const selectedRows = allRows.filter((row) => row.selected);
+    const selectedRowsCount = selectedRows.length;
+    const headerRow = this.querySelector(
+      this.selectorHeaderRow
+    );
+    const allRowsSelected = selectedRowsCount === allRows.length;
+    if (headerRow !== null) {
+      headerRow.checkbox.checked = selectedRowsCount > 0 && allRowsSelected;
+      headerRow.checkbox.indeterminate = selectedRowsCount > 0 && !allRowsSelected;
+    }
+    this.emit("dsa-table-row-selected", {
+      detail: {
+        selectedRow: target,
+        selectedRows
+      }
+    });
+  }
+  handleRowExpandable() {
+    const allRows = [
+      ...this.querySelectorAll(this.selectorAllRows)
+    ];
+    allRows.forEach((row) => {
+      if (this.expandable) {
+        setAttributeIfDifferent(row, "expandable", "true");
+      } else {
+        removeAttributeIfPresent(row, "expandable");
+      }
+    });
+  }
+  handleHeaderRowExpandable() {
+    const headerRow = this.querySelector(
+      this.selectorHeaderRow
+    );
+    if (headerRow === null) {
+      return;
+    }
+    if (this.expandable) {
+      setAttributeIfDifferent(headerRow, "expandable", "true");
+    } else {
+      removeAttributeIfPresent(headerRow, "expandable");
+    }
+  }
+  handleRowReorderable() {
+    const allRows = [
+      ...this.querySelectorAll(this.selectorAllRows)
+    ];
+    allRows.forEach((row) => {
+      if (this.reorderable) {
+        setAttributeIfDifferent(row, "reorderable", "true");
+        setAttributeIfDifferent(row, "draggable", "true");
+      } else {
+        removeAttributeIfPresent(row, "reorderable");
+        removeAttributeIfPresent(row, "draggable");
+        row.rearranging = false;
+      }
+    });
+  }
+  handleHeaderRowReorderable() {
+    const headerRow = this.querySelector(
+      this.selectorHeaderRow
+    );
+    if (headerRow) {
+      if (this.reorderable) {
+        setAttributeIfDifferent(headerRow, "reorderable", "true");
+      } else {
+        removeAttributeIfPresent(headerRow, "reorderable");
+      }
+    }
+  }
+  handleRowSelectable() {
+    const allRows = [
+      ...this.querySelectorAll(this.selectorAllRows)
+    ];
+    allRows.forEach((row, index) => {
+      if (this.selectable === true && row.getAttribute("selection-name") === "") {
+        setAttributeIfDifferent(row, "selection-name", `row-${index}`);
+      } else if (!this.selectable) {
+        setAttributeIfDifferent(row, "selection-name", "");
+      }
+    });
+  }
+  handleHeaderRowSelectable() {
+    const headerRow = this.querySelector(
+      this.selectorHeaderRow
+    );
+    if (headerRow) {
+      setAttributeIfDifferent(
+        headerRow,
+        "selection-name",
+        this.selectable ? "header" : ""
+      );
+    }
+  }
+  handleSizeChange() {
+    const allRows = [
+      ...this.querySelectorAll(this.selectorAllRows),
+      ...this.querySelectorAll(this.selectorHeaderRow)
+    ];
+    allRows.forEach((row) => {
+      setAttributeIfDifferent(row, "size", this.size);
+    });
+  }
+  handleExpandableChange() {
+    this.handleRowExpandable();
+    this.handleHeaderRowExpandable();
+  }
+  handleHeaderCellsCount() {
+    const headerCells = [
+      ...this.querySelectorAll(this.selectorHeaderCell)
+    ];
+    const headerCellsCount = headerCells.length + Number(!!this.expandable) + Number(!!this.selectable) + Number(!!this.reorderable);
+    const allExpandedRows = [
+      ...this.querySelectorAll(
+        this.selectorAllExpandedRows
+      )
+    ];
+    allExpandedRows.forEach((row) => {
+      setAttributeIfDifferent(row, "colspan", String(headerCellsCount));
+    });
+    const allSingleCellRows = [
+      ...this.querySelectorAll(
+        this.selectorAllSingleCellRows
+      )
+    ];
+    allSingleCellRows.forEach((row) => {
+      setAttributeIfDifferent(row, "colspan", String(headerCellsCount));
+    });
+  }
+  handleSortableChange() {
+    const headerCells = this.querySelectorAll(
+      this.selectorHeaderCell
+    );
+    headerCells.forEach((cell) => {
+      if (this.sortable) {
+        setAttributeIfDifferent(cell, "sortable", "true");
+      } else {
+        removeAttributeIfPresent(cell, "sortable");
+      }
+    });
+  }
+  handleSelectableChange() {
+    if (this.selectable) {
+      this.addRowSelectionListeners();
+    } else {
+      this.removeRowSelectionListeners();
+    }
+    this.handleRowSelectable();
+    this.handleHeaderRowSelectable();
+  }
+  handleReorderableChange() {
+    if (this.reorderable) {
+      this.addRowReorderListeners();
+    } else {
+      this.removeRowReorderListeners();
+      this.clearReorderState();
+    }
+    this.handleRowReorderable();
+    this.handleHeaderRowReorderable();
+  }
+  handleAlignmentChange() {
+    const headerCells = this.querySelectorAll(
+      this.selectorHeaderCell
+    );
+    headerCells.forEach((cell) => {
+      setAttributeIfDifferent(cell, "alignment", this.alignment);
+    });
+  }
+  render() {
+    return html` <slot></slot> `;
+  }
+  get selectorHeaderCell() {
+    return "dsa-table-header-cell";
+  }
+  get selectorHeaderRow() {
+    return "dsa-table-header-row";
+  }
+  get selectorAllRows() {
+    return "dsa-table-row";
+  }
+  get selectorAllExpandedRows() {
+    return "dsa-table-expanded-row";
+  }
+  get selectorAllSingleCellRows() {
+    return "dsa-table-single-cell-row";
+  }
+};
+DSATable.styles = table_styles_default;
+__decorateClass([
+  property({ reflect: true })
+], DSATable.prototype, "role", 2);
+__decorateClass([
+  property({ reflect: true })
+], DSATable.prototype, "size", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], DSATable.prototype, "sortable", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], DSATable.prototype, "selectable", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], DSATable.prototype, "expandable", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], DSATable.prototype, "reorderable", 2);
+__decorateClass([
+  property()
+], DSATable.prototype, "alignment", 2);
+__decorateClass([
+  watch("size", { waitUntilFirstUpdate: true })
+], DSATable.prototype, "handleSizeChange", 1);
+__decorateClass([
+  watch("expandable")
+], DSATable.prototype, "handleExpandableChange", 1);
+__decorateClass([
+  watch(["expandable", "selectable", "reorderable"])
+], DSATable.prototype, "handleHeaderCellsCount", 1);
+__decorateClass([
+  watch("sortable")
+], DSATable.prototype, "handleSortableChange", 1);
+__decorateClass([
+  watch("selectable")
+], DSATable.prototype, "handleSelectableChange", 1);
+__decorateClass([
+  watch("reorderable")
+], DSATable.prototype, "handleReorderableChange", 1);
+__decorateClass([
+  watch("alignment", { waitUntilFirstUpdate: true })
+], DSATable.prototype, "handleAlignmentChange", 1);
+DSATable = __decorateClass([
+  customElement("dsa-table")
+], DSATable);
+
+export {
+  DSATable
+};

package/dist/chunks/{chunk.WMFEJDPX.js → chunk.DE3HY2DW.js}

@@ -1,9 +1,9 @@
 import {
   DSASuccessText
-} from "./chunk.6Q5DARJM.js";
+} from "./chunk.L5HLKFQW.js";
 import {
   FormControlLayout
-} from "./chunk.RVUUZ3KA.js";
+} from "./chunk.CY25FZDP.js";
 import {
   defaultValue
 } from "./chunk.CMJ2SRTL.js";

package/dist/chunks/{chunk.TF4MJ3XV.js → chunk.DM5A44VN.js}

@@ -3,28 +3,28 @@ import {
 } from "./chunk.UKOZXT7U.js";
 import {
   DSARangeSlider
-} from "./chunk.WFACPRM5.js";
+} from "./chunk.K64V2XZO.js";
 import {
   filter_range_styles_default
 } from "./chunk.VGW52PNG.js";
 import {
   DSAInput
-} from "./chunk.T3CLPVPE.js";
+} from "./chunk.IRBKALXJ.js";
 import {
   FilterBase
-} from "./chunk.X6SEIMM4.js";
+} from "./chunk.IRPNCLE5.js";
 import {
   DSADivider
 } from "./chunk.QGI766JC.js";
 import {
   DSAButton
-} from "./chunk.UNDVQ2N3.js";
+} from "./chunk.B6XSS23Y.js";
 import {
   ifDefinedAndNotEmpty
 } from "./chunk.ZQJVCRB2.js";
 import {
   DSAIcon
-} from "./chunk.CKJJ4MSU.js";
+} from "./chunk.NJQ6BFQQ.js";
 import {
   watch
 } from "./chunk.QB2NJE2Y.js";

package/dist/chunks/{chunk.5A6XLOZY.js → chunk.DN3K2GHZ.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk.LJ2VCS7Q.js";
 import {
   LocalizeController
-} from "./chunk.WHHYA5VY.js";
+} from "./chunk.34HS7ICN.js";
 import {
   watch
 } from "./chunk.QB2NJE2Y.js";

package/dist/chunks/{chunk.6QE4MIXY.js → chunk.E6D26DI7.js}

@@ -47,11 +47,8 @@ var DSAResizeObserver = class extends ShoelaceElement {
         flatten: true
       });
       this.observedElements.forEach((el) => this.resizeObserver.unobserve(el));
-      this.observedElements = [];
-      elements.forEach((el) => {
-        this.resizeObserver.observe(el);
-        this.observedElements.push(el);
-      });
+      this.observedElements = elements;
+      elements.forEach((el) => this.resizeObserver.observe(el));
     }
   }
   stopObserver() {

package/dist/chunks/{chunk.TURUUPFG.js → chunk.EDEPWRFC.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk.BASV2VAI.js";
 import {
   DSAIcon
-} from "./chunk.CKJJ4MSU.js";
+} from "./chunk.NJQ6BFQQ.js";
 import {
   watch
 } from "./chunk.QB2NJE2Y.js";

package/dist/chunks/{chunk.A6WS4GML.js → chunk.EE3XCTKZ.js}

@@ -6,16 +6,16 @@ import {
 } from "./chunk.UYPZGXIY.js";
 import {
   DSATooltip
-} from "./chunk.TP5XEQ2O.js";
+} from "./chunk.ELOLGOFM.js";
 import {
   DSAVisuallyHidden
 } from "./chunk.JIN6PGAK.js";
 import {
   DSAIconButton
-} from "./chunk.WNESPUKK.js";
+} from "./chunk.MWPOWC6N.js";
 import {
   LocalizeController
-} from "./chunk.WHHYA5VY.js";
+} from "./chunk.34HS7ICN.js";
 import {
   watch
 } from "./chunk.QB2NJE2Y.js";