@ds-autonomie/web-components 2.18.0 → 2.19.0

package/dist/chunks/{chunk.EHGHV3EE.js → chunk.B3QEXOQE.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk.CJ6WHQAI.js";
 import {
   DSATable
-} from "./chunk.RFJJRWWT.js";
+} from "./chunk.D5YUY5BG.js";
 import {
   LoadingStateElement
 } from "./chunk.YROTOHU3.js";
@@ -28,6 +28,7 @@ var DSATableBody = class extends LoadingStateElement {
       if (customElements.get("dsa-table")) {
         parent.handleRowExpandable();
         parent.handleRowSelectable();
+        parent.handleRowReorderable();
         parent.handleHeaderCellsCount();
         parent.handleSizeChange();
       } else {

package/dist/chunks/{chunk.ANOLAL4B.js → chunk.BUGXYS34.js}

@@ -75,7 +75,7 @@ var radio_styles_default = css`
   }
 
   /* Error */
-  .radio__label.radio__label--error {
+  .radio__label--error {
     color: var(--dsa-wc-input-label-color-error) !important;
   }
 

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.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.6TDKZD7U.js → chunk.E6D32GY2.js}

@@ -1,12 +1,12 @@
 import {
   DSATableRow
-} from "./chunk.DMQJ4GLL.js";
+} from "./chunk.LH65ZIEN.js";
 import {
   DSATableHeaderCell
 } from "./chunk.TURUUPFG.js";
 import {
   table_header_row_styles_default
-} from "./chunk.WLP7MATK.js";
+} from "./chunk.VO73SGIU.js";
 import {
   DSAVisuallyHidden
 } from "./chunk.JIN6PGAK.js";
@@ -58,6 +58,18 @@ var DSATableHeaderRow = class extends DSATableRow {
       </dsa-table-header-cell>
     `;
   }
+  renderReorderButton() {
+    if (!this.reorderable) {
+      return html``;
+    }
+    return html`
+      <dsa-table-header-cell aria-hidden=${this.loading}>
+        <dsa-visually-hidden>
+          ${this.localize.term("reorderTableRowsHeader")}
+        </dsa-visually-hidden>
+      </dsa-table-header-cell>
+    `;
+  }
 };
 DSATableHeaderRow.styles = table_header_row_styles_default;
 DSATableHeaderRow.dependencies = __spreadProps(__spreadValues({}, DSATableRow.dependencies), {

package/dist/chunks/{chunk.TP5XEQ2O.js → chunk.ELOLGOFM.js}

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

package/dist/chunks/{chunk.M5X6QE4H.js → chunk.ERMNNF77.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk.PWL7QCVG.js";
 import {
   LocalizeController
-} from "./chunk.WHHYA5VY.js";
+} from "./chunk.34HS7ICN.js";
 import {
   DSAIcon
 } from "./chunk.CKJJ4MSU.js";

package/dist/chunks/{chunk.5T4IWZR2.js → chunk.FBY2IM6R.js}

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