@pascal-app/core 1.0.6 → 1.1.0

package/dist/hooks/spatial-grid/spatial-grid-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spatial-grid-sync.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/spatial-grid-sync.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAY,QAAQ,EAAY,MAAM,cAAc,CAAA;AAY/F,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACvB,cAAc,GACf,MAAM,yBAAyB,CAAA;AAKhC,wBAAgB,mBAAmB,IAAI,MAAM,IAAI,CA0PhD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAA;AAE5C,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,MAAM,CAoBR;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAiBnC;AAOD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAcnC;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAOnC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,EAClC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAQ,QA6BtB;AAwBD,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAuGnC;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAUnC"}
+{"version":3,"file":"spatial-grid-sync.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/spatial-grid-sync.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAY,QAAQ,EAAY,MAAM,cAAc,CAAA;AAY/F,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACvB,cAAc,GACf,MAAM,yBAAyB,CAAA;AAKhC,wBAAgB,mBAAmB,IAAI,MAAM,IAAI,CAiRhD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAA;AAE5C,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,MAAM,CAoBR;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAiBnC;AAOD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAcnC;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAOnC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,EAClC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAQ,QA8BtB;AAwBD,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QA4GnC;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,QAUnC"}

package/dist/hooks/spatial-grid/spatial-grid-sync.js

@@ -1,3 +1,4 @@
+import { isDeckSlab } from '../../lib/deck-framing.js';
 import { resolveLevelId } from '../../lib/node-ancestry.js';
 import { isFloorPlate } from '../../lib/plate-surface.js';
 import { subtractPolygonsFromPolygon } from '../../lib/polygon-union.js';
@@ -110,6 +111,8 @@ export function initSpatialGridSync() {
                     markNodesOverlappingSlab(node, state.nodes, markDirty);
                     markCoveringDependentsBelow(levelId, state.nodes, markDirty);
                 }
+                if (node.type === 'zone' && node.floor?.script)
+                    markNodesOverlappingPolygon(levelId, node.polygon, state.nodes, markDirty);
                 // A site arriving with terrain already on it (scene load, paste,
                 // imported elevation data) is the same event as a stroke: ground exists
                 // where flat ground was assumed.
@@ -128,6 +131,8 @@ export function initSpatialGridSync() {
                     markNodesOverlappingSlab(node, state.nodes, markDirty, prevState.nodes);
                     markCoveringDependentsBelow(levelId, state.nodes, markDirty);
                 }
+                if (node.type === 'zone' && node.floor?.script)
+                    markNodesOverlappingPolygon(levelId, node.polygon, state.nodes, markDirty);
                 // Deleting a sculpted site drops the ground back to the datum, so its
                 // contents have to come down with it.
                 if (node.type === 'site' && node.terrain) {
@@ -166,6 +171,18 @@ export function initSpatialGridSync() {
                     markSlabChangeDependents(prev, node, state.nodes, markDirty, prevState.nodes);
                 }
             }
+            else if (node.type === 'zone' && prev.type === 'zone') {
+                // A room's floor script is the surface what stands on the room rests on.
+                if ((node.floor?.script || prev.floor?.script) &&
+                    (node.floor?.script !== prev.floor?.script ||
+                        node.polygon !== prev.polygon ||
+                        node.holes !== prev.holes)) {
+                    const levelId = resolveLevelId(node, state.nodes);
+                    markNodesOverlappingPolygon(levelId, prev.polygon, state.nodes, markDirty);
+                    if (node.polygon !== prev.polygon)
+                        markNodesOverlappingPolygon(levelId, node.polygon, state.nodes, markDirty);
+                }
+            }
             else if (node.type === 'level' && prev.type === 'level') {
                 if (node.height !== prev.height) {
                     markLevelHeightDependents(node, state.nodes, markDirty);
@@ -185,10 +202,14 @@ export function initSpatialGridSync() {
                     node.end !== prev.end ||
                     node.curveOffset !== prev.curveOffset ||
                     node.thickness !== prev.thickness ||
-                    node.justification !== prev.justification) {
-                    // Rendered slab polygons adopt wall bands, so a wall reshape
-                    // must reach the manager to refresh its wall map and drop the
-                    // level's rendered-polygon cache.
+                    node.justification !== prev.justification ||
+                    node.height !== prev.height ||
+                    node.endHeightOffset !== prev.endHeightOffset ||
+                    node.supportSlabId !== prev.supportSlabId ||
+                    node.supportOffset !== prev.supportOffset) {
+                    // Rendered slab polygons adopt wall bands, and wall height/slope
+                    // queries must see the latest node state — reach the manager to
+                    // refresh its wall map and drop the level's rendered-polygon cache.
                     spatialGridManager.handleNodeUpdated(node, resolveLevelId(node, state.nodes));
                 }
             }
@@ -343,7 +364,8 @@ export function markSlabChangeDependents(previous, next, nodes, markDirty, previ
         next.polygon !== previous.polygon ||
         next.elevation !== previous.elevation ||
         next.holes !== previous.holes;
-    if (supportChanged) {
+    // A slab's surface script is the surface what stands on the slab rests on.
+    if (supportChanged || next.surfaceScript !== previous.surfaceScript) {
         markNodesOverlappingSlab(previous, nodes, markDirty, previousNodes);
         markNodesOverlappingSlab(next, nodes, markDirty);
     }
@@ -419,6 +441,11 @@ export function markTerrainSupportDependents(nodes, markDirty) {
     };
     for (const node of Object.values(nodes)) {
         if (node.type === 'slab') {
+            // A deck's posts run down to the ground under each, on whatever storey it stands.
+            if (isDeckSlab(node, (id) => nodes[id])) {
+                markDirty(node.id);
+                continue;
+            }
             const level = nodes[resolveLevelId(node, nodes)];
             if (node.plateRole === 'base' &&
                 node.foundation?.type === 'solid' &&

package/dist/hooks/spatial-grid/support-host-patch.js

@@ -3,7 +3,7 @@ import { nodeRegistry } from '../../registry/index.js';
 import { DEFAULT_LEVEL_HEIGHT } from '../../services/level-height.js';
 import { getWallCurveFrameAt, isCurvedWall } from '../../systems/wall/wall-curve.js';
 import { GROUND_SUPPORT_ID, getFloorPlacedElevation, getFloorPlacedFootprints, } from './floor-placed-elevation.js';
-import { SUPPORT_ELEVATION_EPSILON, spatialGridManager } from './spatial-grid-manager.js';
+import { activeSpatialGrid, SUPPORT_ELEVATION_EPSILON } from './spatial-grid-manager.js';
 export function resolveSupportSlabPatch(node, nodes, options) {
     const floorPlaced = nodeRegistry.get(node.type)?.capabilities?.floorPlaced;
     if (!floorPlaced || (floorPlaced.applies && !floorPlaced.applies(node))) {
@@ -23,7 +23,7 @@ export function resolveSupportSlabPatch(node, nodes, options) {
             const position = footprint.position ?? node.position;
             if (!Array.isArray(position) || position.length !== 3)
                 continue;
-            const elevation = spatialGridManager.getHostSlabElevationForFootprint(parent.id, options.preferredSlabId, position, footprint.dimensions, footprint.rotation);
+            const elevation = activeSpatialGrid().getHostSlabElevationForFootprint(parent.id, options.preferredSlabId, position, footprint.dimensions, footprint.rotation);
             if (elevation !== null &&
                 (maxElevation == null || elevation <= maxElevation + SUPPORT_ELEVATION_EPSILON)) {
                 return { supportSlabId: options.preferredSlabId };
@@ -37,10 +37,10 @@ export function resolveSupportSlabPatch(node, nodes, options) {
         const position = footprint.position ?? node.position;
         if (!Array.isArray(position) || position.length !== 3)
             continue;
-        const candidates = spatialGridManager.getSupportCandidatesForFootprint(parent.id, position, footprint.dimensions, footprint.rotation);
+        const candidates = activeSpatialGrid().getSupportCandidatesForFootprint(parent.id, position, footprint.dimensions, footprint.rotation);
         for (const candidate of candidates)
             candidateElevations.add(candidate.elevation);
-        const support = spatialGridManager.getSlabSupportForItem(parent.id, position, footprint.dimensions, footprint.rotation, maxElevation);
+        const support = activeSpatialGrid().getSlabSupportForItem(parent.id, position, footprint.dimensions, footprint.rotation, maxElevation);
         if (support.slabId && (!winner || support.elevation > winner.elevation)) {
             winner = { slabId: support.slabId, elevation: support.elevation };
         }
@@ -108,13 +108,13 @@ export function resolveWallSupportSlabPatch(wall, nodes, options) {
     // Winner under the pointer cap (when given): a deck hanging above the
     // aimed-at surface can't capture the elected base, so a wall drawn at the
     // floor underneath it persists the floor slab the user actually targeted.
-    const support = spatialGridManager.getSlabSupportForWall(parent.id, wall.start, wall.end, wall.curveOffset, wall.thickness, options?.preferredSlabId, options?.maxElevation, undefined, wall.justification);
+    const support = activeSpatialGrid().getSlabSupportForWall(parent.id, wall.start, wall.end, wall.curveOffset, wall.thickness, options?.preferredSlabId, options?.maxElevation, undefined, wall.justification);
     const candidateElevations = new Set();
     for (const node of Object.values(nodes)) {
         if (node.type !== 'slab' || node.parentId !== parent.id)
             continue;
         const candidate = node;
-        const preferred = spatialGridManager.getSlabSupportForWall(parent.id, wall.start, wall.end, wall.curveOffset, wall.thickness, candidate.id, undefined, undefined, wall.justification);
+        const preferred = activeSpatialGrid().getSlabSupportForWall(parent.id, wall.start, wall.end, wall.curveOffset, wall.thickness, candidate.id, undefined, undefined, wall.justification);
         if (preferred.electedSlabId === candidate.id) {
             candidateElevations.add(candidate.elevation);
         }
@@ -212,16 +212,16 @@ export function resolveFenceSupportSlabPatch(fence, nodes, options) {
         // (cos yRot, sin yRot) in XZ, so the segment angle aligns the band.
         const rotation = [0, Math.atan2(bz - az, bx - ax), 0];
         if (options?.preferredSlabId) {
-            const preferredElevation = spatialGridManager.getHostSlabElevationForFootprint(parent.id, options.preferredSlabId, position, dimensions, rotation);
+            const preferredElevation = activeSpatialGrid().getHostSlabElevationForFootprint(parent.id, options.preferredSlabId, position, dimensions, rotation);
             if (preferredElevation !== null &&
                 (maxElevation == null || preferredElevation <= maxElevation + SUPPORT_ELEVATION_EPSILON)) {
                 return { supportSlabId: options.preferredSlabId };
             }
         }
-        const candidates = spatialGridManager.getSupportCandidatesForFootprint(parent.id, position, dimensions, rotation);
+        const candidates = activeSpatialGrid().getSupportCandidatesForFootprint(parent.id, position, dimensions, rotation);
         for (const candidate of candidates)
             candidateElevations.add(candidate.elevation);
-        const support = spatialGridManager.getSlabSupportForItem(parent.id, position, dimensions, rotation, maxElevation);
+        const support = activeSpatialGrid().getSlabSupportForItem(parent.id, position, dimensions, rotation, maxElevation);
         if (support.slabId && (!winner || support.elevation > winner.elevation)) {
             winner = { slabId: support.slabId, elevation: support.elevation };
         }
@@ -325,7 +325,7 @@ export function resolveWallConstruction(nodes, levelId, walls, options) {
             maxElevation: wallOptions?.supportCap ?? null,
             preferredSlabId: preferredSupportSlabId,
         });
-        const sourceSupport = spatialGridManager.getSlabSupportForWall(levelId, createdWall.start, createdWall.end, createdWall.curveOffset, createdWall.thickness, supportPatch.supportSlabId, wallOptions?.supportCap ?? null, undefined, createdWall.justification);
+        const sourceSupport = activeSpatialGrid().getSlabSupportForWall(levelId, createdWall.start, createdWall.end, createdWall.curveOffset, createdWall.thickness, supportPatch.supportSlabId, wallOptions?.supportCap ?? null, undefined, createdWall.justification);
         const groundDraft = preferredSupportSlabId === GROUND_SUPPORT_ID && (terrainBase != null || flatConstructionBase);
         const supportOffset = groundDraft && wallOptions?.constructionElevation != null
             ? wallOptions.constructionElevation - sourceSupport.elevation

package/dist/i18n/format.d.ts

@@ -0,0 +1,41 @@
+export interface NumberFormatOptions {
+    /** Minimum fraction digits. */
+    min?: number;
+    /** Maximum fraction digits. */
+    max?: number;
+    useGrouping?: boolean;
+    /**
+     * Locale used for formatting. React renderers must pass useLocale() so the
+     * server and hydration snapshots use the same locale.
+     */
+    locale?: string;
+}
+export type LengthUnit = 'm' | 'cm' | 'mm' | 'ft' | 'in';
+/**
+ * The persisted level is zero-based at grade. Japanese and Simplified Chinese
+ * label that same storey as floor 1, so floors above it display one higher.
+ */
+export declare function levelDisplayNumber(level: number, locale?: string): number;
+export declare function formatNumber(value: number, options?: NumberFormatOptions): string;
+/**
+ * `value.toFixed(digits)` in the locale's notation: the same rounding as
+ * `toFixed` (so "2.55" stays "2.5"), then the locale's decimal separator, no
+ * grouping, and "-0.00" as "0.00".
+ */
+export declare function formatFixed(value: number, digits: number, locale?: string): string;
+/**
+ * Names listed in a sentence. English keeps the plain comma list the editor has
+ * always written ("Kitchen, Hall, Bath"); other locales use their own list
+ * separators and conjunction (Japanese "Kitchen、Hall、Bath", French
+ * "Kitchen, Hall et Bath"), which a comma join gets wrong.
+ */
+export declare function formatList(items: readonly string[], locale?: string): string;
+export declare function formatLength(meters: number, unit: LengthUnit, options?: NumberFormatOptions): string;
+/**
+ * Normalize a decimal for parsers that expect `.`. Localized inputs accept
+ * their locale separator and `.`; grouping is intentionally not accepted in
+ * numeric editor fields because it is ambiguous with decimal commas.
+ */
+export declare function normalizeDecimalInput(input: string, locale?: string): string;
+export declare function parseLocalizedNumber(input: string, locale?: string): number | null;
+//# sourceMappingURL=format.d.ts.map

package/dist/i18n/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/i18n/format.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,mBAAmB;IAClC,+BAA+B;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,+BAA+B;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,MAAM,UAAU,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAmCxD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,SAAc,GAAG,MAAM,CAe9E;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAqBrF;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,SAAO,GAAG,MAAM,CAIhF;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,SAAO,GAAG,MAAM,CAO1E;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,UAAU,EAChB,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAMR;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,SAAc,GAAG,MAAM,CAIjF;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,SAAc,GAAG,MAAM,GAAG,IAAI,CAKvF"}

package/dist/i18n/format.js

@@ -0,0 +1,124 @@
+import { getLocale } from './registry.js';
+const UNIT_SCALE = {
+    m: 1,
+    cm: 100,
+    mm: 1000,
+    ft: 1 / 0.3048,
+    in: 1 / 0.0254,
+};
+const DEFAULT_UNIT_DIGITS = {
+    m: 2,
+    cm: 1,
+    mm: 0,
+    ft: 2,
+    in: 1,
+};
+function fractionDigits(value, fallback) {
+    if (!(typeof value === 'number' && Number.isFinite(value)))
+        return fallback;
+    return Math.max(0, Math.min(20, Math.round(value)));
+}
+function decimalSeparator(locale) {
+    try {
+        return (new Intl.NumberFormat([locale, 'en'])
+            .formatToParts(1.1)
+            .find((part) => part.type === 'decimal')?.value ?? '.');
+    }
+    catch {
+        return '.';
+    }
+}
+/**
+ * The persisted level is zero-based at grade. Japanese and Simplified Chinese
+ * label that same storey as floor 1, so floors above it display one higher.
+ */
+export function levelDisplayNumber(level, locale = getLocale()) {
+    if (level <= 0)
+        return level;
+    try {
+        const parsed = new Intl.Locale(locale);
+        if (parsed.language === 'ja')
+            return level + 1;
+        if (parsed.language === 'zh' &&
+            (parsed.script === 'Hans' || (!parsed.script && parsed.region === 'CN'))) {
+            return level + 1;
+        }
+    }
+    catch {
+        // Invalid locales use the stored English numbering.
+    }
+    return level;
+}
+export function formatNumber(value, options = {}) {
+    if (!Number.isFinite(value))
+        return '--';
+    const minimumFractionDigits = fractionDigits(options.min, 0);
+    const maximumFractionDigits = Math.max(minimumFractionDigits, fractionDigits(options.max, Math.max(3, minimumFractionDigits)));
+    try {
+        return new Intl.NumberFormat([options.locale ?? 'en', 'en'], {
+            minimumFractionDigits,
+            maximumFractionDigits,
+            useGrouping: options.useGrouping ?? false,
+        }).format(value);
+    }
+    catch {
+        return new Intl.NumberFormat('en', {
+            minimumFractionDigits,
+            maximumFractionDigits,
+            useGrouping: options.useGrouping ?? false,
+        }).format(value);
+    }
+}
+/**
+ * `value.toFixed(digits)` in the locale's notation: the same rounding as
+ * `toFixed` (so "2.55" stays "2.5"), then the locale's decimal separator, no
+ * grouping, and "-0.00" as "0.00".
+ */
+export function formatFixed(value, digits, locale = 'en') {
+    if (!Number.isFinite(value))
+        return '--';
+    const rounded = Number(value.toFixed(digits));
+    return formatNumber(Object.is(rounded, -0) ? 0 : rounded, { min: digits, max: digits, locale });
+}
+/**
+ * Names listed in a sentence. English keeps the plain comma list the editor has
+ * always written ("Kitchen, Hall, Bath"); other locales use their own list
+ * separators and conjunction (Japanese "Kitchen、Hall、Bath", French
+ * "Kitchen, Hall et Bath"), which a comma join gets wrong.
+ */
+export function formatList(items, locale = 'en') {
+    if (/^en\b/i.test(locale))
+        return items.join(', ');
+    try {
+        return new Intl.ListFormat([locale, 'en'], { type: 'conjunction' }).format(items);
+    }
+    catch {
+        return items.join(', ');
+    }
+}
+export function formatLength(meters, unit, options = {}) {
+    if (!Number.isFinite(meters))
+        return '--';
+    return `${formatNumber(meters * UNIT_SCALE[unit], {
+        ...options,
+        max: options.max ?? DEFAULT_UNIT_DIGITS[unit],
+    })}\u00a0${unit}`;
+}
+/**
+ * Normalize a decimal for parsers that expect `.`. Localized inputs accept
+ * their locale separator and `.`; grouping is intentionally not accepted in
+ * numeric editor fields because it is ambiguous with decimal commas.
+ */
+export function normalizeDecimalInput(input, locale = getLocale()) {
+    const separator = decimalSeparator(locale);
+    if (separator === '.' || input.includes('.'))
+        return input;
+    return input.replaceAll(separator, '.');
+}
+export function parseLocalizedNumber(input, locale = getLocale()) {
+    const normalized = normalizeDecimalInput(input.trim(), locale).replace('−', '-');
+    if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(normalized))
+        return null;
+    const value = Number(normalized);
+    return Number.isFinite(value) ? value : null;
+}

package/dist/i18n/index.d.ts

@@ -0,0 +1,5 @@
+export type { MessageDescriptor } from '@lingui/core';
+export { formatFixed, formatLength, formatList, formatNumber, type LengthUnit, levelDisplayNumber, type NumberFormatOptions, normalizeDecimalInput, parseLocalizedNumber, } from './format.js';
+export { type CompiledTranslationMessages, createI18n, defaultI18n, getLocale, type PascalI18n, registerCompiledMessages, registerMessages, setLocale, subscribe, type TranslationMessage, type TranslationMessages, type TranslationParams, translate, } from './registry.js';
+export { PascalI18nProvider, useLocale, usePascalI18n } from './use-translate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/i18n/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/i18n/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AACrD,OAAO,EACL,WAAW,EACX,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,KAAK,UAAU,EACf,kBAAkB,EAClB,KAAK,mBAAmB,EACxB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,UAAU,CAAA;AACjB,OAAO,EACL,KAAK,2BAA2B,EAChC,UAAU,EACV,WAAW,EACX,SAAS,EACT,KAAK,UAAU,EACf,wBAAwB,EACxB,gBAAgB,EAChB,SAAS,EACT,SAAS,EACT,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,SAAS,GACV,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/i18n/index.js

@@ -0,0 +1,3 @@
+export { formatFixed, formatLength, formatList, formatNumber, levelDisplayNumber, normalizeDecimalInput, parseLocalizedNumber, } from './format.js';
+export { createI18n, defaultI18n, getLocale, registerCompiledMessages, registerMessages, setLocale, subscribe, translate, } from './registry.js';
+export { PascalI18nProvider, useLocale, usePascalI18n } from './use-translate.js';

package/dist/i18n/registry.d.ts

@@ -0,0 +1,78 @@
+import { type I18n as LinguiI18n, type MessageDescriptor, type MessageOptions, type Messages, type Values } from '@lingui/core';
+/** @experimental Unreleased API; signatures may change before the first i18n release. */
+export type TranslationParams = Record<string, string | number>;
+/** @experimental Unreleased API; signatures may change before the first i18n release. */
+export type TranslationMessage = string;
+/** @experimental Unreleased API; signatures may change before the first i18n release. */
+export type TranslationMessages = Record<string, TranslationMessage>;
+/** @experimental Unreleased API; signatures may change before the first i18n release. */
+export type CompiledTranslationMessages = Messages;
+/**
+ * A request- or editor-local locale selection over Pascal's shared message
+ * registry. Message parsing, interpolation, and ICU selection are delegated to
+ * private Lingui instances.
+ *
+ * @experimental Unreleased API; signatures may change before the first i18n release.
+ */
+export declare class PascalI18n {
+    readonly i18n: LinguiI18n;
+    private readonly englishI18n;
+    private readonly listeners;
+    private readonly localeListeners;
+    private retentionCount;
+    private locale;
+    private version;
+    constructor(initialLocale?: string);
+    getLocale(): string;
+    getVersion(): number;
+    setLocale(nextLocale: string): void;
+    subscribe(listener: () => void): () => void;
+    /** Subscribe only to locale selection, excluding catalog refreshes. */
+    subscribeLocale(listener: (locale: string) => void): () => void;
+    /**
+     * Retain this scope for shared catalog updates while a client provider is
+     * mounted. Server rendering never calls effects, so request scopes are not
+     * held by the module registry.
+     */
+    retain(): () => void;
+    destroy(): void;
+    _(descriptor: MessageDescriptor): string;
+    _(id: string, values?: Values, options?: MessageOptions): string;
+    refresh(notify?: boolean): void;
+}
+/**
+ * Create an isolated locale scope backed by the shared Pascal message packs.
+ *
+ * @experimental Unreleased API; signatures may change before the first i18n release.
+ */
+export declare function createI18n(options?: {
+    locale?: string;
+}): PascalI18n;
+/** @experimental Unreleased API; signatures may change before the first i18n release. */
+export declare const defaultI18n: PascalI18n;
+/**
+ * Register a raw ICU MessageFormat pack. The Lingui compiler is loaded only
+ * for this authoring/host path; bundled packs use registerCompiledMessages.
+ * The whole pack is validated before it becomes visible.
+ *
+ * @experimental Unreleased API; signatures may change before the first i18n release.
+ */
+export declare function registerMessages(messageLocale: string, namespace: string, messages: TranslationMessages): Promise<void>;
+/**
+ * Register a catalog produced by `lingui compile`. Later registrations replace
+ * earlier messages with the same fully namespaced ID.
+ *
+ * @experimental Unreleased API; signatures may change before the first i18n release.
+ */
+export declare function registerCompiledMessages(messageLocale: string, namespace: string, messages: CompiledTranslationMessages): void;
+/** @experimental Unreleased API; signatures may change before the first i18n release. */
+export declare function setLocale(nextLocale: string): void;
+/** @experimental Unreleased API; signatures may change before the first i18n release. */
+export declare function getLocale(): string;
+/** @experimental Unreleased API; signatures may change before the first i18n release. */
+export declare function subscribe(listener: () => void): () => void;
+/** @experimental Unreleased API; signatures may change before the first i18n release. */
+export declare function getI18nVersion(): number;
+/** @experimental Unreleased API; signatures may change before the first i18n release. */
+export declare function translate(key: string, englishDefault: TranslationMessage, params?: TranslationParams, requestedLocale?: string): string;
+//# sourceMappingURL=registry.d.ts.map

package/dist/i18n/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/i18n/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,IAAI,UAAU,EACvB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,QAAQ,EAEb,KAAK,MAAM,EACZ,MAAM,cAAc,CAAA;AAErB,yFAAyF;AACzF,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAA;AAC/D,yFAAyF;AACzF,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAA;AACvC,yFAAyF;AACzF,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;AACpE,yFAAyF;AACzF,MAAM,MAAM,2BAA2B,GAAG,QAAQ,CAAA;AAgFlD;;;;;;GAMG;AACH,qBAAa,UAAU;IACrB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAY;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAClD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAsC;IACtE,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,OAAO,CAAI;IAEnB,YAAY,aAAa,SAAO,EAK/B;IAED,SAAS,IAAI,MAAM,CAElB;IAED,UAAU,IAAI,MAAM,CAEnB;IAED,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAOlC;IAED,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAK1C;IAED,uEAAuE;IACvE,eAAe,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,CAK9D;IAED;;;;OAIG;IACH,MAAM,IAAI,MAAM,IAAI,CAWnB;IAED,OAAO,IAAI,IAAI,CAKd;IAED,CAAC,CAAC,UAAU,EAAE,iBAAiB,GAAG,MAAM,CAAA;IACxC,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAAA;IAWhE,OAAO,CAAC,MAAM,UAAO,GAAG,IAAI,CAY3B;CACF;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,UAAU,CAExE;AAED,yFAAyF;AACzF,eAAO,MAAM,WAAW,YAAe,CAAA;AAGvC;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CACpC,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,2BAA2B,GACpC,IAAI,CAMN;AAED,yFAAyF;AACzF,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAElD;AAED,yFAAyF;AACzF,wBAAgB,SAAS,IAAI,MAAM,CAElC;AAED,yFAAyF;AACzF,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAE1D;AAED,yFAAyF;AACzF,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,yFAAyF;AACzF,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,EACX,cAAc,EAAE,kBAAkB,EAClC,MAAM,CAAC,EAAE,iBAAiB,EAC1B,eAAe,SAAc,GAC5B,MAAM,CAUR"}