@svgrid/enterprise 3.1.0 → 3.1.2

package/dist/studio/scaffold-app.js

@@ -14,12 +14,13 @@ import { scaffold, MANAGED_START, MANAGED_END } from './scaffold.js';
 import { themeTokenCss } from './themes.js';
 const MANAGED_NOTE = '// Regenerated by SvGrid Studio. Edits inside these markers are overwritten.';
 const managed = (body) => `${MANAGED_START}\n${MANAGED_NOTE}\n${body}\n${MANAGED_END}`;
-function layoutFile(nav, appTitle, theme) {
+function layoutFile(nav, appTitle, theme, stylesheets) {
+    const imports = stylesheets.map((css) => `  import '../${css}'\n`).join('');
     return {
         path: 'src/routes/+layout.svelte',
         description: 'App shell: a collapsible nav sidebar linking every entity screen (an off-canvas drawer on tablet/phone), with the routed page in the main area.',
         contents: `<script lang="ts">
-${managed(`  let { children } = $props()
+${managed(`${imports}  let { children } = $props()
   const appTitle = ${JSON.stringify(appTitle)}
   const nav = ${JSON.stringify(nav)}
 
@@ -143,6 +144,7 @@ export function scaffoldApp(schemas, options = {}) {
         files.push(...scaffold(schema, { dataSource: options.dataSource }).files);
     }
     const nav = linked.map((s) => ({ href: `/${s.name}`, label: s.label ?? titleCase(s.name) }));
-    files.push(layoutFile(nav, appTitle, { preset: options.theme, mode: options.dark ? 'dark' : 'light' }), homeFile(nav, appTitle));
+    const theme = { preset: options.theme, mode: options.dark ? 'dark' : 'light' };
+    files.push(layoutFile(nav, appTitle, theme, options.stylesheets ?? []), homeFile(nav, appTitle));
     return { files };
 }

package/dist/studio/scaffold.js

@@ -213,7 +213,8 @@ ${managed(serverBody)}
     const pageBody = `  const source = createKitDataSource<${rowType}>({ endpoint: '${apiRoute}' })
   const columns = schemaToColumns(${constName})${lookupsSection}
 
-  let state = $state<ServerState<${rowType}>>({
+  // Not "state": a local of that name makes svelte-check read $state as a store of it.
+  let view = $state<ServerState<${rowType}>>({
     rows: [], total: 0, loading: false, saving: false, error: null,
     pageIndex: 0, pageSize: 25, pageCount: 1, sortModel: [], filterModel: {},
   })
@@ -221,7 +222,7 @@ ${managed(serverBody)}
     pageSize: 25,
     optimistic: true,
     getRowId: (r) => String(r.${idField}),
-    onChange: (s) => (state = s),
+    onChange: (s) => (view = s),
   })
   controller.refresh()
 
@@ -231,7 +232,7 @@ ${managed(serverBody)}
   async function save({ mode, id, values }: { mode: 'create' | 'edit'; id: string | null; values: Partial<${rowType}> }) {
     if (mode === 'create') {
       await controller.createRow(values)
-      controller.setPage(state.pageCount - 1) // jump to the new row (appended at the end)
+      controller.setPage(view.pageCount - 1) // jump to the new row (appended at the end)
     } else if (id) {
       await controller.updateRow(id, values)
     }
@@ -246,12 +247,11 @@ ${managed(serverBody)}
         path: `src/routes/${route}/+page.svelte`,
         description: 'The data screen: sort, filter, search, paging, multi-select delete, and create/edit - wired to the API route.',
         contents: `<script lang="ts">
-  import { SvGrid, createServerDataSource } from '@svgrid/grid'
+  import { SvGrid, createServerDataSource, type ServerState } from '@svgrid/grid'
   import {
     SvGridEditPanel,
     createKitDataSource,${hasLookups ? '\n    createRelationLookup,' : ''}
     schemaToColumns,
-    type ServerState,
   } from '@svgrid/enterprise'
   import { ${constName}, type ${rowType} } from '${schemaImport}'
 
@@ -273,12 +273,12 @@ ${themeTokenCss({ preset: options.theme, mode: options.dark ? 'dark' : 'light' }
     </div>
   </header>
 
-  {#if state.error}<p class="page__error" role="alert">{state.error}</p>{/if}
+  {#if view.error}<p class="page__error" role="alert">{view.error}</p>{/if}
 
   <SvGrid
-    data={state.rows}
+    data={view.rows}
     {columns}
-    loading={state.loading}
+    loading={view.loading}
     loadingOverlay
     fitColumns
     enableRowSummaries={false}
@@ -301,11 +301,11 @@ ${themeTokenCss({ preset: options.theme, mode: options.dark ? 'dark' : 'light' }
     onRowSelectionChange={(_sel, rows) => (selected = rows)}
     showPagination
     externalPagination
-    rowCount={state.total}
-    pageIndex={state.pageIndex}
-    pageSize={state.pageSize}
+    rowCount={view.total}
+    pageIndex={view.pageIndex}
+    pageSize={view.pageSize}
     onPaginationChange={({ pageIndex, pageSize }) => {
-      if (pageSize !== state.pageSize) controller.setPageSize(pageSize)
+      if (pageSize !== view.pageSize) controller.setPageSize(pageSize)
       else controller.setPage(pageIndex)
     }}
     emptyMessage="No ${label} yet"
@@ -338,6 +338,7 @@ ${themeTokenCss({ preset: options.theme, mode: options.dark ? 'dark' : 'light' }
 export function mergeManaged(existing, generated) {
     if (!existing)
         return generated;
+    existing = migrateStateLocal(existing);
     const startIdx = existing.indexOf(MANAGED_START);
     const endIdx = existing.indexOf(MANAGED_END);
     if (startIdx === -1 || endIdx === -1 || endIdx < startIdx)
@@ -349,3 +350,19 @@ export function mergeManaged(existing, generated) {
     const newRegion = generated.slice(genStart, genEnd + MANAGED_END.length);
     return (existing.slice(0, startIdx) + newRegion + existing.slice(endIdx + MANAGED_END.length));
 }
+/** The managed line pages scaffolded before the rename carried. */
+const OLD_STATE_LOCAL = /\blet state = \$state<ServerState</;
+/**
+ * Pages scaffolded before the rename kept their server state in a local named
+ * `state`, which svelte-check reads as a store subscription whenever `$state`
+ * appears. The managed region now calls it `view`, but the markup below the
+ * region is the user's and still says `state.rows`; a plain merge would leave it
+ * pointing at nothing. Rename the references too. Nothing else in such a page
+ * could be called `state` (the old local would have clashed), and member reads
+ * like `page.state` are skipped.
+ */
+function migrateStateLocal(existing) {
+    if (!OLD_STATE_LOCAL.test(existing))
+        return existing;
+    return existing.replace(/(?<![.\w$])state(?=\s*[.?[]|\s*=[^=>])/g, 'view');
+}

package/dist/sveltekit/in-memory.d.ts

@@ -7,8 +7,28 @@
  */
 import type { RowData, ServerDataSource } from '@svgrid/grid';
 import { type EntitySchema } from '../schema.js';
+import { type PlanPredicate, type QueryPlan } from './query-plan.js';
 import type { WritableDataSource } from './types.js';
 import { type AggregateSource } from '../sources/aggregate.js';
-export declare function createInMemoryDataSource<TData extends RowData>(initial: ReadonlyArray<TData>, schema: EntitySchema<TData>): WritableDataSource<TData> & Required<Pick<ServerDataSource<TData>, 'updateWhere'>> & AggregateSource & {
+export declare function asString(v: unknown): string;
+export declare function matchesPredicate(row: RowData, p: PlanPredicate): boolean;
+export declare function sortRows<T extends RowData>(rows: T[], orderBy: QueryPlan['orderBy']): T[];
+export type InMemoryDataSourceOptions = {
+    /**
+     * Keep the last few filtered, sorted (and grouped) results and answer a
+     * request that differs only in its row range by slicing one, instead of
+     * filtering and sorting the whole array again. Scrolling a block-loading
+     * row model asks for the same query once per block, so on a large array
+     * this is the difference between one sort and one sort per block.
+     *
+     * Off by default because a cached result does not see a row object that
+     * was changed in place, only changes made through this source's own
+     * `createRow` / `updateRow` / `deleteRow` / `updateWhere`, which drop the
+     * cache. `createWorkerDataSource` turns it on: there the rows live in the
+     * worker and nothing else can reach them.
+     */
+    cacheResults?: boolean;
+};
+export declare function createInMemoryDataSource<TData extends RowData>(initial: ReadonlyArray<TData>, schema: EntitySchema<TData>, options?: InMemoryDataSourceOptions): WritableDataSource<TData> & Required<Pick<ServerDataSource<TData>, 'updateWhere'>> & AggregateSource & {
     rows(): ReadonlyArray<TData>;
 };

package/dist/sveltekit/in-memory.js

@@ -2,13 +2,16 @@ import { resolveIdField } from '../schema.js';
 import { planQuery } from './query-plan.js';
 import { compilePredicate } from '../expressions/compile.js';
 import { aggregateRows } from '../sources/aggregate.js';
-function asString(v) {
+// asString, matchesPredicate and sortRows are exported for the columnar
+// engine behind the worker data source, which must answer exactly as this
+// reference does. They are not part of the package API.
+export function asString(v) {
     return v == null ? '' : String(v);
 }
 function num(v) {
     return typeof v === 'number' ? v : Number(v);
 }
-function matchesPredicate(row, p) {
+export function matchesPredicate(row, p) {
     const cell = row[p.field];
     switch (p.op) {
         case 'eq':
@@ -103,28 +106,42 @@ function grandTotalOf(all, plan, expression) {
 function aggregate(rows, field, fn) {
     if (fn === 'count')
         return rows.length;
-    const nums = [];
+    // One pass, no spread: `Math.min(...nums)` throws a RangeError once a
+    // group holds more than about 150,000 values (V8's argument limit).
+    let count = 0;
+    let sum = 0;
+    let min = Infinity;
+    let max = -Infinity;
     for (const row of rows) {
         const n = Number(row[field]);
-        if (Number.isFinite(n))
-            nums.push(n);
+        if (!Number.isFinite(n))
+            continue;
+        count += 1;
+        sum += n;
+        if (n < min)
+            min = n;
+        if (n > max)
+            max = n;
     }
-    if (nums.length === 0)
+    if (count === 0)
         return null;
     switch (fn) {
         case 'sum':
-            return nums.reduce((s, n) => s + n, 0);
+            return sum;
         case 'avg':
-            return nums.reduce((s, n) => s + n, 0) / nums.length;
+            return sum / count;
         case 'min':
-            return Math.min(...nums);
+            return min;
         case 'max':
-            return Math.max(...nums);
+            return max;
         default:
             return null;
     }
 }
-function sortRows(rows, orderBy) {
+// What `localeCompare` with no arguments does, without building a collator
+// per comparison - which is most of the cost of sorting a large array.
+const collator = new Intl.Collator();
+export function sortRows(rows, orderBy) {
     if (orderBy.length === 0)
         return rows;
     // Stable multi-key sort: decorate with index, compare keys in order, fall back to index.
@@ -138,7 +155,7 @@ function sortRows(rows, orderBy) {
             if (typeof av === 'number' && typeof bv === 'number')
                 cmp = av - bv;
             else
-                cmp = asString(av).localeCompare(asString(bv));
+                cmp = collator.compare(asString(av), asString(bv));
             if (cmp !== 0)
                 return desc ? -cmp : cmp;
         }
@@ -146,106 +163,137 @@ function sortRows(rows, orderBy) {
     })
         .map((d) => d.row);
 }
-export function createInMemoryDataSource(initial, schema) {
+/** Results kept by `cacheResults`: a handful of sort / filter / group states. */
+const RESULT_CACHE_SIZE = 8;
+export function createInMemoryDataSource(initial, schema, options = {}) {
     let store = [...initial];
     const idField = resolveIdField(schema);
-    return {
-        async getRows(request) {
-            const plan = planQuery(schema, request);
-            let filtered = store.filter((r) => matches(r, plan));
-            // Advanced filter. `planQuery` only admits an expression whose columns
-            // are all on the schema, so reaching here means it is safe to run. If it
-            // was rejected, or fails to compile, we must NOT acknowledge it - the
-            // grid then tells the user the filter did not run rather than showing a
-            // superset that looks filtered.
-            let appliedExpression = false;
-            let expressionPredicate = null;
-            if (plan.expression) {
-                const predicate = compilePredicate(plan.expression, {
-                    getValue: (row, columnId) => row[columnId],
-                    rows: filtered,
-                });
-                if (predicate) {
-                    filtered = filtered.filter(predicate);
-                    expressionPredicate = predicate;
-                    appliedExpression = true;
-                }
+    // Every write reassigns `store`, so a cache filled from an older array is
+    // stale by identity alone.
+    const cache = new Map();
+    let cacheStore = null;
+    function prepare(plan) {
+        if (!options.cacheResults)
+            return run(plan);
+        if (cacheStore !== store) {
+            cache.clear();
+            cacheStore = store;
+        }
+        // The range is the only part of a plan that does not change the result.
+        const key = JSON.stringify({ ...plan, limit: 0, offset: 0 });
+        const hit = cache.get(key);
+        if (hit) {
+            // Re-insert so the Map's order is least-recently used first.
+            cache.delete(key);
+            cache.set(key, hit);
+            return hit;
+        }
+        const prepared = run(plan);
+        cache.set(key, prepared);
+        if (cache.size > RESULT_CACHE_SIZE)
+            cache.delete(cache.keys().next().value);
+        return prepared;
+    }
+    function run(plan) {
+        let filtered = store.filter((r) => matches(r, plan));
+        // Advanced filter. `planQuery` only admits an expression whose columns
+        // are all on the schema, so reaching here means it is safe to run. If it
+        // was rejected, or fails to compile, we must NOT acknowledge it - the
+        // grid then tells the user the filter did not run rather than showing a
+        // superset that looks filtered.
+        let appliedExpression = false;
+        let expressionPredicate = null;
+        if (plan.expression) {
+            const predicate = compilePredicate(plan.expression, {
+                getValue: (row, columnId) => row[columnId],
+                rows: filtered,
+            });
+            if (predicate) {
+                filtered = filtered.filter(predicate);
+                expressionPredicate = predicate;
+                appliedExpression = true;
             }
-            // The grand total spans everything the FILTERS admit - the whole
-            // store minus the filters and the expression, but NOT minus the group
-            // path, which only scopes this request.
-            const grandTotal = plan.grandTotal
-                ? { grandTotal: grandTotalOf(store, plan, expressionPredicate) }
-                : {};
-            // Grouped request: return one row per distinct key at this level, each
-            // carrying the requested aggregates. The chosen path is already in
-            // `plan.where`, so `filtered` is exactly this group's slice of the data.
-            // Reference behaviour for what a SQL backend does with `planToSql`'s
-            // `select` / `groupByText` / `countText`.
-            if (plan.groupBy) {
-                const groupField = plan.groupBy;
-                const buckets = new Map();
-                for (const row of filtered) {
-                    const key = asString(row[groupField]);
-                    const bucket = buckets.get(key);
-                    if (bucket)
-                        bucket.push(row);
-                    else
-                        buckets.set(key, [row]);
-                }
-                // Pivoting: every aggregate is computed once per distinct pivot key
-                // path inside the group, under a field named from the path, and the
-                // field list goes back so the grid can build the columns.
-                const pivotPaths = new Set();
-                const groups = [...buckets.entries()].map(([key, rows]) => {
-                    const out = { [groupField]: key };
-                    aggregateInto(out, rows, plan, pivotPaths);
-                    // What opening this group would show: distinct keys of the next
-                    // level, or the rows themselves at the innermost group level.
-                    out.childCount = plan.childGroupBy
-                        ? new Set(rows.map((r) => asString(r[plan.childGroupBy]))).size
-                        : rows.length;
-                    return out;
-                });
-                // The pivoted fields in a fixed order - key paths in plain string
-                // order, aggregations as requested under each - so the grid builds
-                // the same columns whatever order the groups came in. Every group
-                // row carries every field; a cell with no rows under it is null, the
-                // way a conditional aggregate answers in SQL.
-                const pivotFields = [...pivotPaths]
-                    .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
-                    .flatMap((path) => (plan.aggregations ?? []).map((agg) => `${path}_${agg.field}`));
-                for (const g of groups) {
-                    for (const f of pivotFields)
-                        if (!(f in g))
-                            g[f] = null;
-                }
-                // Sort by the group key unless the request sorted on a column we
-                // actually produced (the key or an aggregate).
-                const produced = new Set([
-                    groupField,
-                    ...(plan.pivotBy?.length ? [] : (plan.aggregations ?? []).map((a) => a.field)),
-                ]);
-                const groupOrder = plan.orderBy.filter((o) => produced.has(o.field));
-                const sorted = groupOrder.length
-                    ? sortRows(groups, groupOrder)
-                    : sortRows(groups, [{ field: groupField, desc: false }]);
-                return {
-                    rows: sorted.slice(plan.offset, plan.offset + plan.limit),
-                    // The count is DISTINCT GROUPS, not underlying rows - the grid sizes
-                    // its scrollbar and paging from this.
-                    rowCount: sorted.length,
-                    appliedExpression,
-                    ...grandTotal,
-                    ...(plan.pivotBy?.length ? { pivotResultFields: pivotFields } : {}),
-                };
+        }
+        // The grand total spans everything the FILTERS admit - the whole
+        // store minus the filters and the expression, but NOT minus the group
+        // path, which only scopes this request.
+        const grandTotal = plan.grandTotal
+            ? { grandTotal: grandTotalOf(store, plan, expressionPredicate) }
+            : {};
+        // Grouped request: return one row per distinct key at this level, each
+        // carrying the requested aggregates. The chosen path is already in
+        // `plan.where`, so `filtered` is exactly this group's slice of the data.
+        // Reference behaviour for what a SQL backend does with `planToSql`'s
+        // `select` / `groupByText` / `countText`.
+        if (plan.groupBy) {
+            const groupField = plan.groupBy;
+            const buckets = new Map();
+            for (const row of filtered) {
+                const key = asString(row[groupField]);
+                const bucket = buckets.get(key);
+                if (bucket)
+                    bucket.push(row);
+                else
+                    buckets.set(key, [row]);
+            }
+            // Pivoting: every aggregate is computed once per distinct pivot key
+            // path inside the group, under a field named from the path, and the
+            // field list goes back so the grid can build the columns.
+            const pivotPaths = new Set();
+            const groups = [...buckets.entries()].map(([key, rows]) => {
+                const out = { [groupField]: key };
+                aggregateInto(out, rows, plan, pivotPaths);
+                // What opening this group would show: distinct keys of the next
+                // level, or the rows themselves at the innermost group level.
+                out.childCount = plan.childGroupBy
+                    ? new Set(rows.map((r) => asString(r[plan.childGroupBy]))).size
+                    : rows.length;
+                return out;
+            });
+            // The pivoted fields in a fixed order - key paths in plain string
+            // order, aggregations as requested under each - so the grid builds
+            // the same columns whatever order the groups came in. Every group
+            // row carries every field; a cell with no rows under it is null, the
+            // way a conditional aggregate answers in SQL.
+            const pivotFields = [...pivotPaths]
+                .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
+                .flatMap((path) => (plan.aggregations ?? []).map((agg) => `${path}_${agg.field}`));
+            for (const g of groups) {
+                for (const f of pivotFields)
+                    if (!(f in g))
+                        g[f] = null;
             }
-            const sortedLeaves = sortRows(filtered, plan.orderBy);
+            // Sort by the group key unless the request sorted on a column we
+            // actually produced (the key or an aggregate).
+            const produced = new Set([
+                groupField,
+                ...(plan.pivotBy?.length ? [] : (plan.aggregations ?? []).map((a) => a.field)),
+            ]);
+            const groupOrder = plan.orderBy.filter((o) => produced.has(o.field));
+            const sorted = groupOrder.length
+                ? sortRows(groups, groupOrder)
+                : sortRows(groups, [{ field: groupField, desc: false }]);
             return {
-                rows: sortedLeaves.slice(plan.offset, plan.offset + plan.limit),
-                rowCount: sortedLeaves.length,
+                rows: sorted,
                 appliedExpression,
                 ...grandTotal,
+                ...(plan.pivotBy?.length ? { pivotFields } : {}),
+            };
+        }
+        return { rows: sortRows(filtered, plan.orderBy), appliedExpression, ...grandTotal };
+    }
+    return {
+        async getRows(request) {
+            const plan = planQuery(schema, request);
+            const prepared = prepare(plan);
+            return {
+                rows: prepared.rows.slice(plan.offset, plan.offset + plan.limit),
+                // On a grouped request the count is DISTINCT GROUPS, not underlying
+                // rows - the grid sizes its scrollbar and paging from this.
+                rowCount: prepared.rows.length,
+                appliedExpression: prepared.appliedExpression,
+                ...(prepared.grandTotal !== undefined ? { grandTotal: prepared.grandTotal } : {}),
+                ...(prepared.pivotFields ? { pivotResultFields: prepared.pivotFields } : {}),
             };
         },
         async createRow(input) {

package/dist/sveltekit/index.d.ts

@@ -1,5 +1,5 @@
 export { planQuery, coerce, BUILTIN_AGGREGATORS, type QueryPlan, type PlanPredicate, type PlanOp, type PlanAggregate, type PlanOptions, } from './query-plan.js';
-export { createInMemoryDataSource } from './in-memory.js';
+export { createInMemoryDataSource, type InMemoryDataSourceOptions } from './in-memory.js';
 export { createKitDataSource, createKitHandlers, type KitDataSourceOptions, type KitHandlerOptions, type KitScope, type KitHandlers, type KitMessage, } from './transport.js';
 export { planToSql, type SqlDialect, type SqlPlan } from './sql.js';
 export { createSqlDataSource, type SqlExecutor, type SqlDataSourceConfig, } from './sql-source.js';

package/dist/version.d.ts

@@ -10,4 +10,17 @@
  *
  * `version.test.ts` asserts this matches `package.json`, so the two cannot drift.
  */
-export declare const SVGRID_VERSION = "3.1.0";
+export declare const SVGRID_VERSION = "3.1.2";
+/**
+ * The version of `@svgrid/grid`, which releases on its own line: enterprise is
+ * on 3.1.x while the grid is on 3.0.x.
+ *
+ * A scaffolded app depends on BOTH packages, and pinning the grid to this
+ * package's version asked npm for `@svgrid/grid@^3.1.1`, which has never been
+ * published. Every `svgrid-studio init` therefore produced an app whose very
+ * next step, `npm install`, failed with ERESOLVE. Found 2026-10-05 by
+ * scaffolding one and running the install.
+ *
+ * `version.test.ts` asserts this matches packages/grid/package.json.
+ */
+export declare const GRID_VERSION = "3.0.8";

package/dist/version.js

@@ -10,4 +10,17 @@
  *
  * `version.test.ts` asserts this matches `package.json`, so the two cannot drift.
  */
-export const SVGRID_VERSION = '3.1.0';
+export const SVGRID_VERSION = '3.1.2';
+/**
+ * The version of `@svgrid/grid`, which releases on its own line: enterprise is
+ * on 3.1.x while the grid is on 3.0.x.
+ *
+ * A scaffolded app depends on BOTH packages, and pinning the grid to this
+ * package's version asked npm for `@svgrid/grid@^3.1.1`, which has never been
+ * published. Every `svgrid-studio init` therefore produced an app whose very
+ * next step, `npm install`, failed with ERESOLVE. Found 2026-10-05 by
+ * scaffolding one and running the install.
+ *
+ * `version.test.ts` asserts this matches packages/grid/package.json.
+ */
+export const GRID_VERSION = '3.0.8';

package/dist/wc/{GridMenus-By9vPuq0.js → GridMenus-6_fF5jIm.js}

@@ -1,6 +1,6 @@
 import { $ as e, D as t, G as n, H as r, I as i, L as a, M as o, O as s, P as c, Q as l, R as u, S as d, T as f, U as p, W as m, X as h, Y as g, Z as _, _ as v, a as y, at as b, b as x, d as S, dt as C, et as w, f as T, h as E, ht as D, it as O, j as k, k as A, l as ee, m as j, mt as M, n as N, nt as P, o as F, p as te, pt as I, q as L, st as R, tt as z, u as ne, ut as B, w as re, x as V, y as H, z as U } from "./client-DQIzjDBG.js";
-import { c as W, s as ie, t as ae } from "./svelte-virtualizer.svelte-CXtQy2TQ.js";
-import { S as oe, h as se, u as ce, w as le } from "./SvGrid.helpers-BdVDtjUm.js";
+import { c as W, s as ie, t as ae } from "./svelte-virtualizer.svelte-Du4tjrIP.js";
+import { S as oe, h as se, u as ce, w as le } from "./SvGrid.helpers-zBkDTryR.js";
 import { i as ue, t as G } from "./editor-contract-peBDxir_.js";
 import { t as K } from "./SvField-B_kurx_P.js";
 import { n as de } from "./dismissable-CQ6XFXsk.js";