@pascal-app/nodes 1.0.0-beta.5 → 1.0.1

package/dist/wall/wall-batch-system.js

@@ -1,5 +1,5 @@
 'use client';
-import { sceneRegistry, useScene } from '@pascal-app/core';
+import { emitter, sceneRegistry, useScene } from '@pascal-app/core';
 import { drainRebuiltWalls, getPendingWallRebuildCount, isIsolationActive, SCENE_LAYER, useViewer, } from '@pascal-app/viewer';
 import { useFrame, useThree } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
@@ -40,6 +40,7 @@ const batchByNode = new Map();
 const staleLevels = new Set();
 const changedWalls = new Set();
 const EMPTY_IDS = new Set();
+let lastCutawayHiddenWalls = EMPTY_IDS;
 let knownWallCount = -1;
 let lastWallChangeAtMs = 0;
 let batchingSuspended = false;
@@ -56,6 +57,17 @@ function showOwnGeometry(nodeId) {
     if (mesh)
         revealBatchedWall(mesh);
 }
+export function revealBatchedWallsForCapture() {
+    for (const nodeId of batchByNode.keys())
+        showOwnGeometry(nodeId);
+}
+export function holdBatchedWallsAfterCapture() {
+    for (const nodeId of batchByNode.keys()) {
+        const mesh = sceneRegistry.nodes.get(nodeId);
+        if (mesh)
+            hideBatchedWall(mesh);
+    }
+}
 /** Hands a wall back to itself: the merged mesh stops drawing it, it resumes. */
 function releaseWall(nodeId) {
     const record = batchByNode.get(nodeId);
@@ -94,6 +106,8 @@ function toCandidate(nodeId, node, excludedNodeIds = EMPTY_IDS) {
     const mesh = sceneRegistry.nodes.get(nodeId);
     if (!mesh?.visible)
         return null;
+    if (mesh.userData.wallHidden === true)
+        return null;
     // Solo's shadow-caster-only pass and the viewer's isolation filter both
     // hide a wall by taking it off the scene layer. Sewing it in would put it
     // back on screen through the merged mesh, which neither asked for.
@@ -113,25 +127,32 @@ function toCandidate(nodeId, node, excludedNodeIds = EMPTY_IDS) {
  *
  * The merged mesh captures one material set when it is sewn and nothing
  * re-reads it, so batching is only sound while every batched wall's materials
- * hold still. That is true in one wall mode. `cutaway` re-assigns materials
- * from the camera's facing test as the view turns, `down` makes every wall
- * see-through and `translucent` does the same by definition — in all three the
- * merged copy would keep drawing walls the cutaway pass has since turned to
- * glass. Isolation is the other stand-down: it hides the level root the merged
- * mesh hangs off, which would leave a focused batched wall drawn by nobody.
+ * hold still. That is true in `up`; in `cutaway`, walls stamped `wallHidden`
+ * are released per wall in the same frame because WallCutout runs at priority
+ * 0 and this system at 5. `down` and `translucent` make every wall see-through.
+ * Isolation is the other stand-down: it hides the level root the merged mesh
+ * hangs off, which would leave a focused batched wall drawn by nobody.
  */
 export function canBatchWalls(wallMode, isolationActive) {
-    return !isolationActive && wallMode === 'up';
+    return !isolationActive && (wallMode === 'up' || wallMode === 'cutaway');
 }
 /**
- * Walls the cutaway pass is currently tinting — a selection or a delete hover.
+ * Walls the viewer is currently lighting up — a selection, or any hover.
+ *
+ * A selection or delete hover paints the wall by swapping the materials on its
+ * own mesh, which the merged mesh does not follow. Every other hover draws an
+ * outline instead, and that needs the same thing for a different reason: the
+ * outline node renders `outliner.hoveredObjects` through the main camera, which
+ * enables no batched layer, so a sewn wall reaches neither mask pass and
+ * hovering it lights up nothing at all — in select mode, and in paint mode
+ * where the outline is the only signal for which surface the next click lands
+ * on.
  *
- * It paints them by swapping the materials on the wall's own mesh, which the
- * merged mesh does not follow, so a lit wall goes back to drawing itself. There
- * are only ever a handful, and a handful of extra draw calls is what the tint
- * costs.
+ * Both wants are the same one: a lit wall goes back to drawing its own
+ * geometry. Only ever a handful are lit at once, and a handful of extra draw
+ * calls is what lighting them costs.
  */
-function collectTintedWalls(wallIds) {
+export function collectTintedWalls(wallIds) {
     const viewer = useViewer.getState();
     const tinted = new Set();
     for (const id of viewer.selection.selectedIds)
@@ -140,7 +161,7 @@ function collectTintedWalls(wallIds) {
     for (const id of viewer.previewSelectedIds)
         if (wallIds.has(id))
             tinted.add(id);
-    const hovered = viewer.hoverHighlightMode === 'delete' ? viewer.hoveredId : null;
+    const hovered = viewer.hoveredId;
     if (hovered && wallIds.has(hovered))
         tinted.add(hovered);
     return tinted;
@@ -223,6 +244,7 @@ function mergeLevel(levelId, excludedNodeIds = EMPTY_IDS) {
             continue;
         const mesh = new Mesh(batch.geometry, candidates[0].materials);
         mesh.name = 'wall-batch';
+        mesh.userData.pascalExport = 'strip';
         mesh.castShadow = true;
         mesh.receiveShadow = true;
         mesh.matrixAutoUpdate = false;
@@ -248,6 +270,49 @@ export const WallBatchSystem = () => {
     const invalidate = useThree((state) => state.invalidate);
     const wakeRef = useRef(null);
     useFrame(() => runBatchFrame(invalidate, wakeRef), 5);
+    // Captures and exports clone the scene and prune whatever is off the scene
+    // layer, so the sources come back for the capture and go under again after
+    // it. The node batch used to reveal them as a side effect of its own sweep
+    // (shared hold reason) and nothing ever re-hid them: every batched wall
+    // drew twice for the rest of the session.
+    useEffect(() => {
+        emitter.on('thumbnail:before-capture', revealBatchedWallsForCapture);
+        emitter.on('thumbnail:after-capture', holdBatchedWallsAfterCapture);
+        return () => {
+            emitter.off('thumbnail:before-capture', revealBatchedWallsForCapture);
+            emitter.off('thumbnail:after-capture', holdBatchedWallsAfterCapture);
+        };
+    }, []);
+    // Scripted-probe hook, ?perf sessions only (mirrors __itemBatch): the
+    // panel has no row for the merged wall batch, so probes read it here.
+    useEffect(() => {
+        if (!new URLSearchParams(window.location.search).has('perf'))
+            return;
+        const probe = {
+            stats: () => {
+                let batches = 0;
+                for (const records of batchesByLevel.values())
+                    batches += records.length;
+                let hidden = 0;
+                for (const nodeId of sceneRegistry.byType.wall ?? EMPTY_IDS) {
+                    if (sceneRegistry.nodes.get(nodeId)?.userData.wallHidden === true)
+                        hidden++;
+                }
+                return {
+                    walls: batchByNode.size,
+                    batches,
+                    levels: batchesByLevel.size,
+                    hidden,
+                    suspended: batchingSuspended,
+                    wallMode: useViewer.getState().wallMode,
+                };
+            },
+        };
+        window.__wallBatch = probe;
+        return () => {
+            delete window.__wallBatch;
+        };
+    }, []);
     useEffect(() => () => {
         if (wakeRef.current)
             clearTimeout(wakeRef.current);
@@ -255,6 +320,7 @@ export const WallBatchSystem = () => {
             disposeLevelBatches(levelId);
         changedWalls.clear();
         staleLevels.clear();
+        lastCutawayHiddenWalls = EMPTY_IDS;
         knownWallCount = -1;
         batchingSuspended = false;
         lastAppearance.shading = undefined;
@@ -276,7 +342,7 @@ export const WallBatchSystem = () => {
  * "did this wall move" on its own, and the per-frame cost is the size of the
  * dirty set rather than the size of the floor.
  */
-function runBatchFrame(invalidate, wakeRef) {
+export function runBatchFrame(invalidate, wakeRef) {
     const wallIds = sceneRegistry.byType.wall ?? EMPTY_IDS;
     const nodes = useScene.getState().nodes;
     // Walls the wall system rebuilt: it clears each mark as it goes, so by the
@@ -313,6 +379,39 @@ function runBatchFrame(invalidate, wakeRef) {
         releaseWall(nodeId);
         changed = true;
     }
+    // Only cutaway hides walls one by one; `up` hides none and the other modes
+    // stand the batch down, so the stamp scan is worth a frame only there.
+    const cutawayHiddenWalls = new Set();
+    if (useViewer.getState().wallMode === 'cutaway') {
+        for (const nodeId of wallIds) {
+            const mesh = sceneRegistry.nodes.get(nodeId);
+            if (mesh?.userData.wallHidden === true)
+                cutawayHiddenWalls.add(nodeId);
+        }
+    }
+    for (const nodeId of cutawayHiddenWalls) {
+        const record = batchByNode.get(nodeId);
+        if (!record)
+            continue;
+        releaseWall(nodeId);
+        staleLevels.add(record.levelId);
+        changed = true;
+    }
+    // A stamp that lifts hands the wall back to its own draw call, and nothing
+    // else marks the level — so the flip itself has to, or the wall would stay
+    // out of the merged mesh until an unrelated edit re-sews the floor.
+    for (const nodeId of lastCutawayHiddenWalls) {
+        if (cutawayHiddenWalls.has(nodeId))
+            continue;
+        const node = nodes[nodeId];
+        if (node?.type === 'wall' && node.parentId)
+            staleLevels.add(node.parentId);
+        changed = true;
+    }
+    lastCutawayHiddenWalls = cutawayHiddenWalls;
+    const excludedNodeIds = new Set(cutawayHiddenWalls);
+    for (const nodeId of tintedWalls)
+        excludedNodeIds.add(nodeId);
     // A theme, texture or material-library switch re-makes every wall's
     // materials without marking a single node, so the merged copies have to be
     // sewn again from the new ones. See `appearanceChanged`.
@@ -336,13 +435,11 @@ function runBatchFrame(invalidate, wakeRef) {
             changed = true;
         }
     }
-    // Two things make merging unsound, and both are handled the same way: the
-    // batch stands down for as long as they hold, and sews the floors back
-    // together once they lift. Isolation hides everything outside the focused
-    // subtree, and a level's merged mesh hangs off the level root — so it goes
-    // dark with everything else, leaving a focused batched wall drawn by nobody.
-    // Every wall mode but `up` re-assigns wall materials the merged mesh does not
-    // follow. See `canBatchWalls`.
+    // Isolation, `down` and `translucent` make batching unsound, so the batch
+    // stands down while they hold and sews the floors back together once they
+    // lift. `cutaway` stays live because WallCutout stamps hidden walls at
+    // priority 0 and this system releases them per wall at priority 5 in the
+    // same frame. See `canBatchWalls`.
     const suspended = !canBatchWalls(useViewer.getState().wallMode, isIsolationActive());
     if (suspended !== batchingSuspended) {
         batchingSuspended = suspended;
@@ -381,8 +478,8 @@ function runBatchFrame(invalidate, wakeRef) {
         return;
     }
     for (const levelId of staleLevels) {
-        if (unbatchedWallCount(levelId, tintedWalls) >= MIN_BATCH_WALLS) {
-            mergeLevel(levelId, tintedWalls);
+        if (unbatchedWallCount(levelId, excludedNodeIds) >= MIN_BATCH_WALLS) {
+            mergeLevel(levelId, excludedNodeIds);
         }
     }
     staleLevels.clear();

package/dist/wall/wall-batch.js

@@ -161,9 +161,9 @@ export function applyWallBatchGroups(batch, hidden) {
  * its subtree keeps rendering and picking.
  */
 export function hideBatchedWall(mesh) {
-    hideFromScene(mesh, 'batched');
+    hideFromScene(mesh, 'wall-batched');
 }
 /** Hands a wall back its own draw call — unless solo or isolation still hide it. */
 export function revealBatchedWall(mesh) {
-    showInScene(mesh, 'batched');
+    showInScene(mesh, 'wall-batched');
 }

package/dist/window/definition.d.ts

@@ -1,5 +1,6 @@
-import type { NodeDefinition } from '@pascal-app/core';
+import type { AnyNodeId, NodeDefinition, SceneApi, WindowNode as WindowNodeType } from '@pascal-app/core';
 import { WindowNode } from './schema';
+export declare function resolveWindowHandlePortalTarget(window: WindowNodeType, scene: Pick<SceneApi, 'get'>): AnyNodeId | null;
 /**
  * Window — Phase 5 batch kind. Mirrors door's shape: hosted on walls,
  * cuts holes in them, animated open/close state for opening windows.

package/dist/window/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,cAAc,EAIf,MAAM,kBAAkB,CAAA;AAiBzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAkIrC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAqG9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAGT,cAAc,EAEd,QAAQ,EAER,UAAU,IAAI,cAAc,EAC7B,MAAM,kBAAkB,CAAA;AAqBzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAQrC,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAC3B,SAAS,GAAG,IAAI,CAWlB;AA0JD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAqG9D,CAAA"}

package/dist/window/definition.js

@@ -1,3 +1,4 @@
+import { getDormerWallHorizontalBoundsAtHeight, getDormerWallOpeningVerticalBounds, } from '@pascal-app/core';
 import { buildWindowFloorplanSchedule, computeWindowFloorplanLevelData, } from '../shared/opening-documentation';
 import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime';
 import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host';
@@ -16,9 +17,19 @@ const SIDE_HANDLE_OFFSET = 0.24;
 const HEIGHT_HANDLE_OFFSET = 0.24;
 const MIN_WINDOW_HEIGHT = 0.3;
 const MIN_WINDOW_WIDTH = 0.3;
-// How far the move cross floats off the wall face (+Z, the window's facing
-// normal) so it's grabbable instead of buried in the sash/frame.
-const MOVE_HANDLE_LIFT = 0.12;
+export function resolveWindowHandlePortalTarget(window, scene) {
+    const parentId = window.parentId;
+    if (!parentId)
+        return null;
+    const grandparentId = scene.get(parentId)
+        ?.parentId;
+    if (!grandparentId)
+        return null;
+    if (window.dormerId !== parentId)
+        return grandparentId;
+    return (scene.get(grandparentId)?.parentId ??
+        grandparentId);
+}
 function readWallLength(w, scene) {
     if (!w.wallId)
         return Number.POSITIVE_INFINITY;
@@ -27,6 +38,30 @@ function readWallLength(w, scene) {
         return Number.POSITIVE_INFINITY;
     return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
 }
+function resolveDormerHost(window, scene) {
+    const dormerId = window.dormerId ?? window.parentId;
+    if (!dormerId)
+        return null;
+    const dormer = scene.get(dormerId);
+    return dormer?.type === 'dormer' ? dormer : null;
+}
+function readDormerFaceWidthMax(window, scene, localGrowSign) {
+    const dormer = resolveDormerHost(window, scene);
+    if (!dormer)
+        return null;
+    const bounds = getDormerWallHorizontalBoundsAtHeight(dormer, window.dormerFace ?? 'front', window.position[1] + window.height / 2);
+    const faceGrowSign = Math.cos(window.rotation[1]) >= 0 ? localGrowSign : -localGrowSign;
+    const anchorX = window.position[0] - (faceGrowSign * window.width) / 2;
+    return faceGrowSign > 0 ? bounds.max - anchorX : anchorX - bounds.min;
+}
+function readDormerFaceHeightMax(window, scene, growSign) {
+    const dormer = resolveDormerHost(window, scene);
+    if (!dormer)
+        return null;
+    const bounds = getDormerWallOpeningVerticalBounds(dormer, window.dormerFace ?? 'front', window.position[0], window.width);
+    const anchorY = window.position[1] - (growSign * window.height) / 2;
+    return growSign > 0 ? bounds.max - anchorY : anchorY - bounds.min;
+}
 function windowWidthHandle(side) {
     const sign = side === 'right' ? 1 : -1;
     return {
@@ -36,8 +71,12 @@ function windowWidthHandle(side) {
         // front instead of edge-on (the window sits on a vertical wall).
         faceNormal: true,
         anchor: side === 'right' ? 'min' : 'max',
+        gridSnap: true,
         min: MIN_WINDOW_WIDTH,
         max: (n, scene) => {
+            const dormerMax = readDormerFaceWidthMax(n, scene, sign);
+            if (dormerMax !== null)
+                return Math.max(MIN_WINDOW_WIDTH, dormerMax);
             // Roof-hosted windows clamp against the face profile (the
             // wall-based limits read Infinity when wallId is unset).
             const roofMax = readRoofFaceWidthMax(n, scene, sign);
@@ -67,6 +106,7 @@ function windowWidthHandle(side) {
             rotationY: () => (side === 'right' ? 0 : Math.PI),
         },
         portal: 'grandparent',
+        portalTarget: resolveWindowHandlePortalTarget,
     };
 }
 // Window height has two arrows (top + bottom edge) — each anchors at the
@@ -79,8 +119,12 @@ function windowHeightHandle(edge) {
         axis: 'y',
         // top arrow anchors at -Y (bottom stays fixed); bottom at +Y (top stays).
         anchor: edge === 'top' ? 'min' : 'max',
+        gridSnap: true,
         min: MIN_WINDOW_HEIGHT,
         max: (n, scene) => {
+            const dormerMax = readDormerFaceHeightMax(n, scene, sign);
+            if (dormerMax !== null)
+                return Math.max(MIN_WINDOW_HEIGHT, dormerMax);
             const roofMax = readRoofFaceHeightMax(n, scene, sign);
             if (roofMax !== null)
                 return Math.max(MIN_WINDOW_HEIGHT, roofMax);
@@ -110,27 +154,10 @@ function windowHeightHandle(edge) {
             position: (n) => [0, sign * (n.height / 2 + HEIGHT_HANDLE_OFFSET), 0],
         },
         portal: 'grandparent',
-    };
-}
-// Press-drag move grip at the window centre, standing in the wall face. Routes
-// through the same move tool as the floating Move button (3D
-// `affordanceTools.move`, 2D `floorplanMoveTarget`) — slide within the wall
-// plane + re-host onto another wall — committing on release, no second click.
-function windowMoveHandle() {
-    return {
-        kind: 'tap-action',
-        shape: 'move-cross',
-        plane: 'node-normal',
-        portal: 'grandparent',
-        cursor: 'move',
-        onActivate: (node, _scene, editor) => editor.engageMoveDrag(node),
-        placement: {
-            position: () => [0, 0, MOVE_HANDLE_LIFT],
-        },
+        portalTarget: resolveWindowHandlePortalTarget,
     };
 }
 const windowHandles = [
-    windowMoveHandle(),
     windowWidthHandle('left'),
     windowWidthHandle('right'),
     windowHeightHandle('top'),
@@ -151,7 +178,7 @@ export const windowDefinition = {
     kind: 'window',
     snapProfile: 'item',
     facingIndicator: true,
-    schemaVersion: 2,
+    schemaVersion: 3,
     schema: WindowNode,
     category: 'structure',
     extensions: {
@@ -180,9 +207,9 @@ export const windowDefinition = {
             cutScope: 'wall',
             dirtyHandledByOwnSystem: true,
         },
-        // `wallId` / `roofSegmentId` are re-derived from the surface under
+        // `wallId` / `roofSegmentId` / `dormerId` are re-derived from the surface under
         // the cursor at preset placement time — see door for the pattern.
-        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace'],
+        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace', 'dormerId', 'dormerFace'],
         // Frame / glass slots painted through the registry. The window system tags
         // each mesh with its `userData.slotId`; paint writes `node.slots`.
         slots: () => windowSlots(),

package/dist/window/floorplan-move.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAOxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAiPrE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAOxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAkPrE,CAAA"}

package/dist/window/floorplan-move.js

@@ -198,7 +198,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                 return false;
             // Block on overlap UNLESS Alt force-places — same `placeable` rule as
             // the 3D move + the shared `resolveOpeningPlacement`.
-            const collides = hasWallChildOverlap(lastValid.parentId, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
+            const collides = hasWallChildOverlap(lastValid.parentId, useScene.getState().nodes, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
             return resolveOpeningPlacement({ collides, forcePlace }).placeable;
         },
         commit() {

package/dist/window/move-tool.d.ts

@@ -3,13 +3,15 @@ import { WindowNode } from '@pascal-app/core';
  * Move/duplicate tool for WindowNodes — wall-only, same guardrails as WindowTool.
  *
  * Move mode (metadata.isNew falsy):
- *   Adopts the existing window, pauses temporal. On commit: restores original state
- *   (clean undo baseline) then resumes + updateNode (undo reverts to original position).
- *   On cancel: restores original state.
+ *   Adopts the existing window and holds a refcounted history pause for the
+ *   gesture. On commit: restores original state (clean undo baseline) then runs
+ *   updateNode as the gesture's single tracked write (undo reverts to the
+ *   original position). On cancel: restores original state, never tracked.
  *
  * Duplicate mode (metadata.isNew = true):
- *   The node is a freshly created transient copy. On commit: deletes transient + resumes
- *   + createNode (undo removes the new window entirely). On cancel: deletes the node.
+ *   The node is a freshly created transient copy. On commit: deletes the
+ *   transient paused + createNode as the single tracked write (undo removes the
+ *   new window entirely). On cancel: deletes the node.
  */
 declare const MoveWindowTool: React.FC<{
     node: WindowNode;

package/dist/window/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAYL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAqDzB;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAigClD,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAiBL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAiEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAoyClD,CAAA;AAED,eAAe,cAAc,CAAA"}