@svgrid/grid 3.0.4 → 3.0.5

package/dist/SvGrid.types.d.ts

@@ -1,4 +1,5 @@
 import type { Snippet } from "svelte";
+import type { GridRowModel } from "./row-model.js";
 import type { CellEditorType, ColumnDef, RowData, SvGridApi, TableFeatures } from "./index.js";
 import type { ConditionalFormat } from "./conditional-formatting.js";
 import type { GroupDisplayType } from "./group-display.js";
@@ -1074,8 +1075,256 @@ export type SchedulerConfig<TFeatures extends TableFeatures = TableFeatures, TDa
     searchable?: boolean;
     searchPlaceholder?: string;
 };
+/**
+ * The Gantt axis presets: which unit is a tick and which is the coarser row
+ * grouping them. `week` (day ticks under month majors) is the default.
+ */
+export type GanttZoom = "day" | "week" | "month" | "quarter" | "year";
+/**
+ * The four classic dependency kinds. `FS` (finish-to-start) is the default:
+ * the successor may not start before the predecessor finishes.
+ */
+export type GanttDependencyType = "FS" | "SS" | "FF" | "SF";
+/**
+ * A link from a predecessor task (`from`) to a successor (`to`). Both are row
+ * ids (the grid's `getRowId`). `lag` is in DAYS - negative for a lead, so
+ * `{ type: 'FS', lag: -1 }` lets the successor start a day before the
+ * predecessor finishes.
+ */
+export type GanttDependency = {
+    id: string;
+    from: string;
+    to: string;
+    type?: GanttDependencyType;
+    lag?: number;
+};
+/** Fired when a task bar is dragged to new dates. {@link GanttConfig.onTaskMove}. */
+export type GanttTaskMoveEvent<TData extends RowData = RowData> = {
+    row: TData;
+    start: Date;
+    end: Date;
+    /**
+     * The moved row's descendants, shifted by the same delta - present only when
+     * a summary (parent) bar was dragged. Cascaded successors are NOT here; they
+     * arrive through {@link GanttConfig.onDependenciesChange}.
+     */
+    subtree?: Array<{
+        row: TData;
+        start: Date;
+        end: Date;
+    }>;
+};
+/** Fired when a task bar's edge is dragged. {@link GanttConfig.onTaskResize}. */
+export type GanttTaskResizeEvent<TData extends RowData = RowData> = {
+    row: TData;
+    start: Date;
+    end: Date;
+    /** Which edge the user dragged. */
+    edge: "start" | "end";
+};
+/** Fired when a bar's progress grip is dragged. {@link GanttConfig.onProgressChange}. */
+export type GanttProgressChangeEvent<TData extends RowData = RowData> = {
+    row: TData;
+    /** 0-100, in whole percent. */
+    progress: number;
+};
+/** Fired when the Gantt's detail drawer is saved. {@link GanttConfig.onTaskCommit}. */
+export type GanttTaskCommitEvent<TData extends RowData = RowData> = {
+    row: TData;
+    values: Partial<TData>;
+};
+/**
+ * The Gantt's built-in task drawer. Same shape as the scheduler's - a field
+ * list, a title and a width - so one drawer config type covers both views.
+ */
+export type GanttDrawerConfig<TData extends RowData = RowData> = SchedulerDrawerConfig<TData>;
+/**
+ * Turns the grid into a Gantt chart. Set `gantt` and the grid renders its rows
+ * as a task table beside a time chart: one bar per row positioned by start /
+ * end, nested into a work-breakdown tree by `parentField`, with dependency
+ * arrows between linked tasks.
+ *
+ * Like the Kanban board and the scheduler it is a pure *view of the grid*: it
+ * renders the grid's filtered + sorted rows and writes back only through
+ * callbacks, never mutating your data. Dragging a bar fires
+ * {@link GanttConfig.onTaskMove} where you reassign the dates on your own rows.
+ *
+ * Dates are local calendar days and `end` is EXCLUSIVE, except that a date-only
+ * string (`'2026-09-14'`, no time part) is read as the end OF that day - the
+ * inclusive convention planning tools use. So
+ * `{ start: '2026-09-14', end: '2026-09-16' }` draws a three-day bar.
+ */
+export type GanttConfig<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData> = {
+    /** Field holding each task's start (`Date` | epoch-ms | ISO string). Required. */
+    startField: keyof TData & string;
+    /** Field holding the end. Omit to use `durationField`, else the task is a milestone. */
+    endField?: keyof TData & string;
+    /** Field holding the length in WORKING days, used when `endField` is absent. */
+    durationField?: keyof TData & string;
+    /** Field for the task name. Defaults to the first column's field. */
+    titleField?: keyof TData & string;
+    /** Field holding percent complete (0-100). Drives the bar's inner fill. */
+    progressField?: keyof TData & string;
+    /**
+     * Field holding each row's PARENT task id, nesting the flat rows into a
+     * work-breakdown tree. Parents render a rolled-up summary bar and a collapse
+     * chevron. Rows whose parent is missing become roots rather than vanishing.
+     *
+     * This is the Gantt's own tree - do NOT also set the grid's `treeData` prop.
+     * `treeData` hides collapsed children from the view entirely, which would
+     * drop them out of their phase's summary bar.
+     */
+    parentField?: keyof TData & string;
+    /**
+     * Boolean field marking a task as a milestone (a diamond, no length). A task
+     * whose end equals its start renders as one regardless.
+     */
+    milestoneField?: keyof TData & string;
+    /** Field holding a per-task accent color (any CSS color). Else `color`. */
+    colorField?: keyof TData & string;
+    /** Fallback accent color for every bar. */
+    color?: string;
+    /**
+     * Predecessor -> successor links, drawn as arrows between bars. `from` / `to`
+     * are row ids (your `getRowId`). See {@link GanttDependency}.
+     */
+    dependencies?: ReadonlyArray<GanttDependency>;
+    /**
+     * Per-row field holding that row's links (as `GanttDependency[]` or a plain
+     * list of successor ids). An alternative to the flat `dependencies` array.
+     */
+    dependencyField?: keyof TData & string;
+    /**
+     * Cascade successors forward on move / resize so every link stays legal,
+     * preserving each task's duration. Defaults to `true` when any dependency is
+     * present. Cascading never pulls a task earlier.
+     */
+    autoReschedule?: boolean;
+    /**
+     * Schedule in working time (see `nonWorkingDays` / `holidays`): a moved
+     * or cascaded task lands on a working day and keeps its WORKING length, so
+     * a five-day task dragged over a weekend stays five days of work, and the
+     * critical path measures slack in working days. `false` schedules in
+     * calendar time. Default `true`.
+     */
+    respectWorkingTime?: boolean;
+    /** Fired with the cascaded shifts after a move / resize (never mutates rows). */
+    onDependenciesChange?: (moves: Array<{
+        id: string;
+        start: Date;
+        end: Date;
+    }>) => void;
+    /** Fired when the user draws a new link (drag from one bar's edge to another). */
+    onDependencyAdd?: (dep: GanttDependency) => void;
+    /** Fired when the user removes a link (arrow context menu). */
+    onDependencyRemove?: (id: string) => void;
+    /** The axis preset the chart opens on. Default `'week'`. */
+    zoom?: GanttZoom;
+    /**
+     * The presets the toolbar's zoom stepper offers. Default all five; a single
+     * entry hides the stepper.
+     */
+    zoomLevels?: ReadonlyArray<GanttZoom>;
+    /** Fired when the zoom preset changes (stepper or Ctrl+wheel). */
+    onZoomChange?: (zoom: GanttZoom) => void;
+    /** First day of the week, 0-6 (0 = Sunday). Default 0. */
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /**
+     * Weekday numbers (0 = Sun ... 6 = Sat) that are non-working: shaded in the
+     * chart and skipped by duration + cascade arithmetic. Default `[0, 6]`.
+     */
+    nonWorkingDays?: ReadonlyArray<number>;
+    /** Specific dates that are non-working (holidays, closures). */
+    holidays?: ReadonlyArray<Date | number | string>;
+    /** Shade the non-working columns. Default `true`. */
+    showNonWorking?: boolean;
+    /** Draw the dashed "today" line across the chart. Default `true`. */
+    todayLine?: boolean;
+    /** Earliest date the axis shows and a drag may reach. */
+    minDate?: Date | number | string;
+    /** Latest date the axis shows and a drag may reach. */
+    maxDate?: Date | number | string;
+    /** Calendar days of slack around the first start / last end. Default 7. */
+    rangePaddingDays?: number;
+    /**
+     * Column ids shown in the task table, in order. Defaults to every leaf
+     * column. Two built-ins need no column definition: `'__duration'` (working
+     * days) and `'__progress'` (a small bar).
+     */
+    tableColumns?: ReadonlyArray<string>;
+    /** Width (px) of the task table pane. Default 360; a splitter resizes it. */
+    tableWidth?: number;
+    /** Height (px) of one task row. Default 32. */
+    rowHeight?: number;
+    /** Parents draw a rolled-up summary bar spanning their children. Default `true`. */
+    summaryBars?: boolean;
+    /**
+     * Where a bar's label sits: `'inside'` (default, falling back to the right
+     * when the bar is too narrow), always `'right'`, or `'none'`.
+     */
+    labelPosition?: "inside" | "right" | "none";
+    /**
+     * Controlled collapse: the ids of the parent rows whose children are hidden.
+     * Omit to let the Gantt own its own collapse state.
+     */
+    collapsed?: ReadonlyArray<string>;
+    /** Fired when a chevron (or Expand / Collapse all) changes the collapsed set. */
+    onCollapseChange?: (collapsed: string[]) => void;
+    /**
+     * Enable drag-to-move, edge resize, the progress grip and link drawing.
+     * Without it the chart is read-only.
+     */
+    editable?: boolean;
+    /**
+     * Enable undo / redo of move, resize and progress edits with `Ctrl/Cmd+Z` and
+     * `Ctrl/Cmd+Shift+Z` (or `Ctrl+Y`). The callbacks re-fire with the reversed
+     * values, so your data follows.
+     */
+    history?: boolean;
+    /** Fired when a bar is dragged to new dates. */
+    onTaskMove?: (event: GanttTaskMoveEvent<TData>) => void;
+    /** Fired when a bar's edge is dragged. */
+    onTaskResize?: (event: GanttTaskResizeEvent<TData>) => void;
+    /** Fired when the progress grip is dragged. */
+    onProgressChange?: (event: GanttProgressChangeEvent<TData>) => void;
+    /** Fired when empty chart space is double-clicked - create a task there. */
+    onTaskAdd?: (start: Date, end: Date, parentId?: string) => void;
+    /**
+     * Fired from the bar's Delete action. Setting this shows Delete in the
+     * drawer and the context menu. Remove the row from your data in the handler.
+     */
+    onTaskDelete?: (row: TData) => void;
+    /**
+     * Custom body for a TASK bar. Receives the row. Omit for the built-in label.
+     * A phase's summary bar is a thin spine with no room for a body, so it keeps
+     * its plain label; a milestone has no body at all.
+     */
+    task?: Snippet<[TData]>;
+    /**
+     * Hover tooltip for a bar. A `Snippet<[TData]>` for custom content, or `true`
+     * for the built-in one (title, dates, duration, percent). Omit to disable.
+     */
+    tooltip?: boolean | Snippet<[TData]>;
+    /** Delay (ms) before the hover tooltip opens. Default 400. */
+    tooltipDelay?: number;
+    /** Built-in task drawer: `true` for all fields, or a config object. */
+    drawer?: boolean | GanttDrawerConfig<TData>;
+    /** Fired when the drawer is saved. */
+    onTaskCommit?: (event: GanttTaskCommitEvent<TData>) => void;
+    /** Right-click menu for a bar. Return items or `undefined` to suppress. */
+    taskMenu?: (row: TData) => MenuItem[] | undefined;
+    /** Show the search box (binds to the grid's global filter). Default `true`. */
+    searchable?: boolean;
+    searchPlaceholder?: string;
+};
 export type Props<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData> = {
-    data: ReadonlyArray<TData>;
+    /**
+     * The rows to render.
+     *
+     * Optional only because `rowModel` can supply them instead; a grid with
+     * neither renders empty. When both are present `data` wins.
+     */
+    data?: ReadonlyArray<TData>;
     columns: Array<ColumnDef<TFeatures, TData>>;
     /**
      * Kanban board mode. When set, the grid renders its rows as cards in
@@ -1089,6 +1338,15 @@ export type Props<TFeatures extends TableFeatures = TableFeatures, TData extends
      * {@link SchedulerConfig}.
      */
     scheduler?: SchedulerConfig<TFeatures, TData>;
+    /**
+     * Gantt mode. When set, the grid renders its rows as a task table beside a
+     * time chart: one bar per row by start / end, a work-breakdown tree from
+     * `parentField`, and dependency arrows. See {@link GanttConfig}.
+     *
+     * A view of the grid like the board and scheduler; the renderer ships in
+     * `@svgrid/enterprise` (call `enableGanttView()`).
+     */
+    gantt?: GanttConfig<TFeatures, TData>;
     /**
      * Chart view. When set, the grid renders its FILTERED + SORTED rows as a chart
      * instead of a table (search / filters / sort flow through). Unlike board and
@@ -2078,6 +2336,99 @@ export type Props<TFeatures extends TableFeatures = TableFeatures, TData extends
         scrollHeight: number;
         clientHeight: number;
     }) => void;
+    /**
+     * Fires when the range of rows on screen changes, with the first and last
+     * row INDEX (not pixels). Coalesced to one call per frame, so it is cheap
+     * to wire to something that fetches.
+     *
+     * This is the hook a block-loading data source needs and
+     * `onScrollBottomReached` cannot give it: "the user is looking at rows
+     * 4,000-4,020" answers which block to fetch and which to keep, while
+     * "they hit the bottom" only ever means "append more". Both are free; use
+     * this one with `createServerDataSource({ mode: 'infinite' })`, or let
+     * `rowModel` wire it for you.
+     *
+     * Reports `0, data.length - 1` when virtualization is off, since every row
+     * really is rendered.
+     */
+    onVisibleRangeChange?: (range: {
+        startIndex: number;
+        endIndex: number;
+    }) => void;
+    /**
+     * Marks a row as one whose data has not arrived: `"loading"` draws a
+     * shimmer in every cell, `"failed"` draws a full-width "could not load"
+     * row with a Retry button, and `null` (the default for every row) renders
+     * normally.
+     *
+     * Placeholder rows are inert - not selectable, not editable, and skipped
+     * by cell navigation - because there is nothing there to act on yet.
+     *
+     * `createServerDataSource` in `infinite` mode fills the gaps with rows this
+     * recognises, so the usual wiring is `rowPlaceholder={rowPlaceholderState}`
+     * (or nothing at all, via `rowModel`).
+     */
+    rowPlaceholder?: (row: TData, rowIndex: number) => "loading" | "failed" | null;
+    /** Called by the Retry button on a `"failed"` placeholder row. */
+    onRetryRow?: (row: TData, rowIndex: number) => void;
+    /**
+     * Hand selection over to an external model.
+     *
+     * The grid normally tracks selection as a record of the row ids it has
+     * seen, which is right until the rows it has seen are a window onto a
+     * million on a server: "select all" then means 20 ticked checkboxes rather
+     * than a million, and the header checkbox cannot honestly say `all`. A
+     * model that stores the RULE ("everything except these three") can answer
+     * both, so when this is set the header checkbox, the row checkboxes and
+     * `api.selectAllRows()` all route through it instead.
+     *
+     * `@svgrid/enterprise` ships one for the server-side row model; this is the
+     * seam it plugs into.
+     */
+    /**
+     * Drive the grid from a row model instead of wiring a dozen props.
+     *
+     * `createServerDataSource` returns one, and so does the Enterprise
+     * server-side row model, so server-backed grids become:
+     *
+     * ```svelte
+     * <SvGrid rowModel={ctl} {columns} />
+     * ```
+     *
+     * The model supplies `data`, `loading`, `getRowId`, the external sort
+     * and filter wiring, the visible range, placeholder rows, group
+     * accessors, selection and paging - each one only if it implements that
+     * part. A prop written explicitly on the grid always wins, so you can
+     * adopt it and still override one piece.
+     */
+    rowModel?: GridRowModel<TData>;
+    /**
+     * Columns that REPLACE `columns` while set. The server-side row model
+     * supplies them in pivot mode - one column per pivoted value, grouped
+     * under a header per pivot key - and clears them when pivot mode ends,
+     * so `columns` stays the app's own list. Rarely set by hand.
+     */
+    pivotResultColumns?: Array<ColumnDef<TFeatures, TData>> | null;
+    rowSelectionModel?: {
+        isSelected: (rowId: string, row: TData) => boolean;
+        /** Whether the header checkbox shows empty, indeterminate, or ticked. */
+        headerState: () => "none" | "some" | "all";
+        toggle: (rowId: string, row: TData, next: boolean) => void;
+        /** The header checkbox: select or clear everything, loaded or not. */
+        toggleAll: (next: boolean) => void;
+        /**
+         * How many rows the rule selects, counting the ones the grid never
+         * loaded; `null` when it cannot say. The selection bar shows this
+         * instead of counting ticked rows on screen.
+         */
+        selectedCount?: () => number | null;
+        /**
+         * Apply one patch to every selected row, loaded or not. When present,
+         * the bulk-edit drawer sends its edits here instead of writing the
+         * loaded cells. Resolves with how many rows changed.
+         */
+        bulkUpdate?: (patch: Record<string, unknown>) => Promise<number>;
+    };
     /**
      * Marks a row as an expandable "detail row". When this returns true the
      * grid renders that row as a SINGLE full-width cell (colspan across every
@@ -2101,8 +2452,10 @@ export type Props<TFeatures extends TableFeatures = TableFeatures, TData extends
      * Server-side group / tree keyboard + accessibility, built into the grid. When
      * set, the grid uses the treegrid role and marks matching rows with
      * `aria-level` / `aria-expanded`, and ArrowRight / ArrowLeft expand / collapse
-     * the focused group row (no app-level key handling). Pair with `serverGroupRows`
-     * + `SvGroupCell` for the visual expander. Every accessor receives the row data.
+     * the focused group row (no app-level key handling). Pair with
+     * `serverGroupRows` + `SvGroupCell` from `@svgrid/enterprise` for the visual
+     * expander, or drive it from your own tree state. Every accessor receives the
+     * row data.
      */
     serverGroup?: {
         /** Whether a row is an expandable group / branch. */

package/dist/build-api.js

@@ -691,11 +691,10 @@ export function createGridApi(ctx) {
                 });
             },
             selectAllRows() {
-                const next = {};
-                for (const row of ctx.allRows)
-                    if (!isGroupRow(row))
-                        next[row.id] = true;
-                ctx.grid.setRowSelection(() => next);
+                // One implementation of "select everything", shared with the header
+                // checkbox, so it knows about an external selection model and about
+                // rows whose data has not arrived.
+                ctx.setSelectAllRows(true);
             },
             toggleRowSelected(id) {
                 ctx.toggleRowSelectionById(id);
@@ -703,7 +702,13 @@ export function createGridApi(ctx) {
             // ---- Pagination
             getPageInfo() {
                 const { pageIndex, pageSize } = ctx.paginationState;
-                const total = ctx.allRowsBeforePagination.length;
+                // Under external pagination the grid holds ONE page, so counting the
+                // rows in hand would report a 95-row table as a 20-row one. The
+                // consumer tells us the real total through rowCount, which is what
+                // the footer has always shown.
+                const total = ctx.externalPaginationEnabled
+                    ? (ctx.props.rowCount ?? ctx.allRowsBeforePagination.length)
+                    : ctx.allRowsBeforePagination.length;
                 const pageCount = Math.max(1, Math.ceil(total / Math.max(1, pageSize)));
                 return { pageIndex, pageSize, pageCount, total };
             },

package/dist/cdn/{GridMenus-BL7ZgQvU.js → GridMenus-CID62rlI.js}

@@ -1,4 +1,4 @@
-import { $a as e, Vn as t, eo as n } from "./src-BKhZ6eXd.js";
+import { $a as e, Ln as t, Qa as n } from "./src-Bklofsad.js";
 import { S as r, _ as i, j as a, k as o } from "./editor-registry-BhgE3S84.js";
 import { r as s } from "./dismissable-DAHetSNk.js";
 import * as c from "svelte/internal/client";
@@ -280,11 +280,11 @@ function _e(_e, M) {
 		t?.closest(".sv-listbox") || t?.tagName === "BUTTON" || (e.preventDefault(), c.get(q)());
 	}
 	let Ze = c.derived(() => P().columnMenuFacetOptions), Qe = c.derived(() => P().columnMenuSelectedFacets), $e = c.derived(() => P().setFacetSelection), et = c.derived(() => P().setFilterTokens), Z = c.derived(() => P().inSuggestOptions), tt = c.derived(() => P().openInSuggest), nt = c.derived(() => P().closeInSuggest), rt = c.derived(() => P().isAllFacetsChecked), it = c.derived(() => P().toggleAllFacets), at = 40;
-	function ot(e, t) {
-		c.get(tt)(e, t), P().inSuggestQuery = n(e.value);
+	function ot(t, n) {
+		c.get(tt)(t, n), P().inSuggestQuery = e(t.value);
 	}
-	function st(e, t) {
-		P().inSuggestQuery = n(e.value), P().inSuggestFor !== t && c.get(tt)(e, t);
+	function st(t, n) {
+		P().inSuggestQuery = e(t.value), P().inSuggestFor !== n && c.get(tt)(t, n);
 	}
 	function ct(e) {
 		return e.map((e) => ({
@@ -513,11 +513,11 @@ function _e(_e, M) {
 		c.get(V) && e(At);
 	});
 	var jt = c.sibling(kt, 2), Mt = (r) => {
-		let i = c.derived(() => c.get(Fe)), a = c.derived(() => new Set(e(c.get(Pe)[c.get(i)] ?? "")));
-		var o = fe(), s = c.child(o), l = (e) => {
+		let i = c.derived(() => c.get(Fe)), a = c.derived(() => new Set(n(c.get(Pe)[c.get(i)] ?? "")));
+		var o = fe(), s = c.child(o), l = (n) => {
 			{
 				let r = c.derived(() => c.get(Z).length > 40);
-				t(e, {
+				t(n, {
 					block: !0,
 					checkbox: !0,
 					multiple: !0,
@@ -534,9 +534,9 @@ function _e(_e, M) {
 					get value() {
 						return c.get(a);
 					},
-					onChange: (e) => {
-						let t = new Set(e), r = n(c.get(Pe)[c.get(i)] ?? "");
-						r && t.delete(r), c.get(et)(c.get(i), [...t]), P().inSuggestQuery = "";
+					onChange: (t) => {
+						let n = new Set(t), r = e(c.get(Pe)[c.get(i)] ?? "");
+						r && n.delete(r), c.get(et)(c.get(i), [...n]), P().inSuggestQuery = "";
 					}
 				});
 			}

package/dist/cdn/{GridMenus-7kbpnnBW.js → GridMenus-DLL-qZeu.js}

@@ -1,4 +1,4 @@
-import { $a as e, Vn as t, eo as n } from "./src-V1uu8iE9.js";
+import { $a as e, Ln as t, Qa as n } from "./src-jcFMkBnN.js";
 import { D as r, E as i, F as a, G as o, H as s, I as c, L as l, N as u, Q as d, R as f, U as p, V as m, X as h, Y as g, Z as _, _ as v, at as y, b, d as x, et as S, f as C, ft as w, g as ee, h as T, it as E, j as D, k as O, lt as k, m as te, mt as ne, nt as A, o as re, pt as j, st as M, t as ie, tt as N, u as P, ut as ae, v as F, w as oe } from "./disclose-version-Dr7rEVv-.js";
 import { S as se, _ as ce, j as le, k as ue } from "./editor-registry-BhgE3S84.js";
 import { r as I } from "./dismissable-DAHetSNk.js";
@@ -279,11 +279,11 @@ function H(l, f) {
 		t?.closest(".sv-listbox") || t?.tagName === "BUTTON" || (e.preventDefault(), o(Q)());
 	}
 	let jt = M(() => H().columnMenuFacetOptions), Mt = M(() => H().columnMenuSelectedFacets), Nt = M(() => H().setFacetSelection), Pt = M(() => H().setFilterTokens), Ft = M(() => H().inSuggestOptions), It = M(() => H().openInSuggest), Lt = M(() => H().closeInSuggest), Rt = M(() => H().isAllFacetsChecked), zt = M(() => H().toggleAllFacets), Bt = 40;
-	function Vt(e, t) {
-		o(It)(e, t), H().inSuggestQuery = n(e.value);
+	function Vt(t, n) {
+		o(It)(t, n), H().inSuggestQuery = e(t.value);
 	}
-	function Ht(e, t) {
-		H().inSuggestQuery = n(e.value), H().inSuggestFor !== t && o(It)(e, t);
+	function Ht(t, n) {
+		H().inSuggestQuery = e(t.value), H().inSuggestFor !== n && o(It)(t, n);
 	}
 	function Ut(e) {
 		return e.map((e) => ({
@@ -512,11 +512,11 @@ function H(l, f) {
 		o(Je) && e(pn);
 	});
 	var mn = A(fn, 2), hn = (r) => {
-		let i = M(() => o(ft)), c = M(() => new Set(e(o(dt)[o(i)] ?? "")));
-		var l = Re(), u = S(l), d = (e) => {
+		let i = M(() => o(ft)), c = M(() => new Set(n(o(dt)[o(i)] ?? "")));
+		var l = Re(), u = S(l), d = (n) => {
 			{
 				let r = M(() => o(Ft).length > 40);
-				t(e, {
+				t(n, {
 					block: !0,
 					checkbox: !0,
 					multiple: !0,
@@ -533,9 +533,9 @@ function H(l, f) {
 					get value() {
 						return o(c);
 					},
-					onChange: (e) => {
-						let t = new Set(e), r = n(o(dt)[o(i)] ?? "");
-						r && t.delete(r), o(Pt)(o(i), [...t]), H().inSuggestQuery = "";
+					onChange: (t) => {
+						let n = new Set(t), r = e(o(dt)[o(i)] ?? "");
+						r && n.delete(r), o(Pt)(o(i), [...n]), H().inSuggestQuery = "";
 					}
 				});
 			}