@pascal-app/viewer 0.9.1 → 1.0.0-beta.1

package/dist/systems/wall/opening-cutout-geometry.test.js

@@ -0,0 +1,172 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { DoorNode, WindowNode } from '@pascal-app/core';
+import { buildOpeningCutoutGeometry, buildOpeningCutoutShape, getOpeningCutoutBottomPadding, hasFlatOpeningCutoutBottom, } from './opening-cutout-geometry';
+function containsPoint(points, x, y) {
+    return points.some((point) => Math.abs(point.x - x) < 1e-6 && Math.abs(point.y - y) < 1e-6);
+}
+function getBounds(points) {
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (const point of points) {
+        minX = Math.min(minX, point.x);
+        maxX = Math.max(maxX, point.x);
+        minY = Math.min(minY, point.y);
+        maxY = Math.max(maxY, point.y);
+    }
+    return { minX, maxX, minY, maxY };
+}
+describe('buildOpeningCutoutShape', () => {
+    test('rectangle profile passes the rect through unchanged', () => {
+        const door = DoorNode.parse({});
+        const rect = { left: 1.2, right: 2.1, bottom: 0, top: 2.1 };
+        const points = buildOpeningCutoutShape(door, rect).getPoints();
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.top)).toBe(true);
+        const bounds = getBounds(points);
+        expect(bounds.minX).toBeCloseTo(rect.left, 9);
+        expect(bounds.maxX).toBeCloseTo(rect.right, 9);
+        expect(bounds.minY).toBeCloseTo(rect.bottom, 9);
+        expect(bounds.maxY).toBeCloseTo(rect.top, 9);
+    });
+    test('door rounded profile rounds only the top corners', () => {
+        const door = DoorNode.parse({ openingShape: 'rounded', cornerRadius: 0.2 });
+        const rect = { left: -0.45, right: 0.45, bottom: 0, top: 2.1 };
+        const points = buildOpeningCutoutShape(door, rect).getPoints();
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.right, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.left, rect.top - 0.2)).toBe(true);
+        expect(containsPoint(points, rect.left + 0.2, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top - 0.2)).toBe(true);
+        expect(containsPoint(points, rect.right - 0.2, rect.top)).toBe(true);
+    });
+    test('window rounded profile rounds all four corners', () => {
+        const window = WindowNode.parse({ openingShape: 'rounded', cornerRadius: 0.2 });
+        const rect = { left: -0.75, right: 0.75, bottom: 0.9, top: 2.4 };
+        const points = buildOpeningCutoutShape(window, rect).getPoints();
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(false);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(false);
+        expect(containsPoint(points, rect.left, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.right, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.left + 0.2, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.bottom + 0.2)).toBe(true);
+        expect(containsPoint(points, rect.right - 0.2, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top - 0.2)).toBe(true);
+        const bounds = getBounds(points);
+        expect(bounds.minX).toBeCloseTo(rect.left, 9);
+        expect(bounds.maxX).toBeCloseTo(rect.right, 9);
+        expect(bounds.minY).toBeCloseTo(rect.bottom, 9);
+        expect(bounds.maxY).toBeCloseTo(rect.top, 9);
+    });
+    test('shared corner radius is clamped to the opening half-extent', () => {
+        const window = WindowNode.parse({ openingShape: 'rounded', cornerRadius: 10 });
+        const rect = { left: -0.75, right: 0.75, bottom: 0.9, top: 2.4 };
+        const points = buildOpeningCutoutShape(window, rect).getPoints();
+        // 1.5 × 1.5 opening → radius clamps to 0.75; arcs meet at edge midpoints.
+        expect(containsPoint(points, rect.left, rect.bottom + 0.75)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top - 0.75)).toBe(true);
+        const bounds = getBounds(points);
+        expect(bounds.minX).toBeCloseTo(rect.left, 9);
+        expect(bounds.maxX).toBeCloseTo(rect.right, 9);
+    });
+    test('individual radii normalize when their sum exceeds the opening width', () => {
+        const window = WindowNode.parse({
+            openingShape: 'rounded',
+            openingRadiusMode: 'individual',
+            openingCornerRadii: [4, 4, 0, 0],
+        });
+        const rect = { left: -0.5, right: 0.5, bottom: 0, top: 2 };
+        const points = buildOpeningCutoutShape(window, rect).getPoints();
+        // Width 1 with top radii summing to 8 → scaled down to 0.5 each.
+        expect(containsPoint(points, rect.left, rect.top - 0.5)).toBe(true);
+        expect(containsPoint(points, rect.left + 0.5, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
+    });
+    test('arch profile springs at top - archHeight and peaks at the rect top', () => {
+        const door = DoorNode.parse({ openingShape: 'arch', archHeight: 0.45 });
+        const rect = { left: -0.45, right: 0.45, bottom: 0, top: 2.1 };
+        const points = buildOpeningCutoutShape(door, rect).getPoints();
+        expect(containsPoint(points, rect.left, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.bottom)).toBe(true);
+        expect(containsPoint(points, rect.right, rect.top - 0.45)).toBe(true);
+        expect(containsPoint(points, 0, rect.top)).toBe(true);
+        expect(containsPoint(points, rect.left, rect.top)).toBe(false);
+        expect(containsPoint(points, rect.right, rect.top)).toBe(false);
+    });
+    test('profiles are origin-agnostic — offset rects yield translated points', () => {
+        const window = WindowNode.parse({ openingShape: 'rounded', cornerRadius: 0.2 });
+        const centered = buildOpeningCutoutShape(window, {
+            left: -0.75,
+            right: 0.75,
+            bottom: -0.75,
+            top: 0.75,
+        }).getPoints();
+        const offset = buildOpeningCutoutShape(window, {
+            left: 2.25,
+            right: 3.75,
+            bottom: 0.9,
+            top: 2.4,
+        }).getPoints();
+        for (const point of centered) {
+            expect(containsPoint(offset, point.x + 3, point.y + 1.65)).toBe(true);
+        }
+        for (const point of offset) {
+            expect(containsPoint(centered, point.x - 3, point.y - 1.65)).toBe(true);
+        }
+    });
+});
+describe('buildOpeningCutoutGeometry', () => {
+    test('extrudes the rect through the depth, centered on the mid-plane', () => {
+        const door = DoorNode.parse({});
+        const geometry = buildOpeningCutoutGeometry(door, { left: -0.45, right: 0.45, bottom: -1.05, top: 1.05 }, 0.24, 0.1);
+        geometry.computeBoundingBox();
+        // Float32 position buffer → ~1e-7 relative precision.
+        const box = geometry.boundingBox;
+        expect(box.min.x).toBeCloseTo(-0.45, 6);
+        expect(box.max.x).toBeCloseTo(0.45, 6);
+        expect(box.min.y).toBeCloseTo(-1.05, 6);
+        expect(box.max.y).toBeCloseTo(1.05, 6);
+        expect(box.min.z).toBeCloseTo(-0.12, 6);
+        expect(box.max.z).toBeCloseTo(0.12, 6);
+    });
+});
+describe('hasFlatOpeningCutoutBottom', () => {
+    test('flat for rectangles, arches, and door rounded (top-only radii)', () => {
+        expect(hasFlatOpeningCutoutBottom(DoorNode.parse({}))).toBe(true);
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({ openingShape: 'arch' }))).toBe(true);
+        expect(hasFlatOpeningCutoutBottom(DoorNode.parse({ openingShape: 'rounded' }))).toBe(true);
+    });
+    test('rounded windows depend on their bottom radii', () => {
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({ openingShape: 'rounded' }))).toBe(false);
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({ openingShape: 'rounded', cornerRadius: 0 }))).toBe(true);
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({
+            openingShape: 'rounded',
+            openingRadiusMode: 'individual',
+            openingCornerRadii: [0.2, 0.2, 0, 0],
+        }))).toBe(true);
+        expect(hasFlatOpeningCutoutBottom(WindowNode.parse({
+            openingShape: 'rounded',
+            openingRadiusMode: 'individual',
+            openingCornerRadii: [0.2, 0.2, 0.2, 0.2],
+        }))).toBe(false);
+    });
+});
+describe('getOpeningCutoutBottomPadding', () => {
+    test('pads floor-level openings with a flat bottom', () => {
+        expect(getOpeningCutoutBottomPadding(DoorNode.parse({}), 0)).toBe(0.02);
+        expect(getOpeningCutoutBottomPadding(DoorNode.parse({ openingShape: 'rounded' }), 0)).toBe(0.02);
+        expect(getOpeningCutoutBottomPadding(WindowNode.parse({ openingShape: 'arch' }), 0)).toBe(0.02);
+    });
+    test('does not pad openings above the floor or rounded window bottoms', () => {
+        expect(getOpeningCutoutBottomPadding(DoorNode.parse({}), 0.9)).toBe(0);
+        expect(getOpeningCutoutBottomPadding(WindowNode.parse({ openingShape: 'rounded' }), 0)).toBe(0);
+    });
+});

package/dist/systems/wall/wall-cutout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-cutout.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-cutout.tsx"],"names":[],"mappings":"AAsCA,eAAO,MAAM,UAAU,YAwItB,CAAA"}
+{"version":3,"file":"wall-cutout.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-cutout.tsx"],"names":[],"mappings":"AAyDA,eAAO,MAAM,UAAU,YAuLtB,CAAA"}

package/dist/systems/wall/wall-cutout.js

@@ -1,9 +1,9 @@
-import { emitter, sceneRegistry, useScene } from '@pascal-app/core';
+import { emitter, getWallFaceBandConfig, getWallPlaneTop, resolveLevelId, resolveWallEffectiveHeight, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import { Vector3 } from 'three/webgpu';
 import useViewer from '../../store/use-viewer';
-import { getMaterialsForWall } from './wall-materials';
+import { getMaterialsForWall, getSelectionHighlightMaterials, getWallMaterialHash, } from './wall-materials';
 const tmpVec = new Vector3();
 const u = new Vector3();
 const v = new Vector3();
@@ -28,6 +28,9 @@ function getWallHideState(wallNode, wallMesh, wallMode, cameraDir) {
     }
     return hideWall;
 }
+function sameMaterialArray(a, b) {
+    return Array.isArray(a) && a.length === b.length && a.every((material, i) => material === b[i]);
+}
 export const WallCutout = () => {
     const lastCameraPosition = useRef(new Vector3());
     const lastCameraTarget = useRef(new Vector3());
@@ -36,6 +39,7 @@ export const WallCutout = () => {
     const lastShading = useRef(useViewer.getState().shading);
     const lastNumberOfWalls = useRef(0);
     const lastHighlightKey = useRef('');
+    const lastWallAppearanceKey = useRef('');
     const lastTextures = useRef(useViewer.getState().textures);
     const lastColorPreset = useRef(useViewer.getState().colorPreset);
     const lastSceneTheme = useRef(useViewer.getState().sceneTheme);
@@ -49,17 +53,27 @@ export const WallCutout = () => {
         const previewSelectedIds = useViewer.getState().previewSelectedIds;
         const hoveredId = useViewer.getState().hoveredId;
         const hoverHighlightMode = useViewer.getState().hoverHighlightMode;
+        const sceneState = useScene.getState();
         const currentTime = clock.elapsedTime;
         const currentCameraPosition = camera.position;
         camera.getWorldDirection(tmpVec);
         tmpVec.add(currentCameraPosition);
-        const highlightedWallIds = new Set([...selectedIds, ...previewSelectedIds].filter((id) => useScene.getState().nodes[id]?.type === 'wall'));
+        const highlightedWallIds = new Set([...selectedIds, ...previewSelectedIds].filter((id) => sceneState.nodes[id]?.type === 'wall'));
         const deleteHoveredWallId = hoverHighlightMode === 'delete' &&
             hoveredId &&
-            useScene.getState().nodes[hoveredId]?.type === 'wall'
+            sceneState.nodes[hoveredId]?.type === 'wall'
             ? hoveredId
             : null;
         const highlightKey = `${Array.from(highlightedWallIds).sort().join('|')}::${deleteHoveredWallId ?? ''}`;
+        const wallAppearanceKey = Array.from(sceneRegistry.byType.wall)
+            .sort()
+            .map((wallId) => {
+            const wallNode = sceneState.nodes[wallId];
+            if (wallNode?.type !== 'wall')
+                return `${wallId}:missing`;
+            return `${wallId}:${getWallMaterialHash(wallNode, shading, sceneState.materials)}:${JSON.stringify(wallNode.faceBands ?? null)}`;
+        })
+            .join('|');
         const distanceMoved = currentCameraPosition.distanceTo(lastCameraPosition.current);
         const directionChanged = tmpVec.distanceTo(lastCameraTarget.current);
         const timeSinceUpdate = currentTime - lastUpdateTime.current;
@@ -70,7 +84,8 @@ export const WallCutout = () => {
             lastColorPreset.current !== colorPreset ||
             lastSceneTheme.current !== sceneTheme ||
             sceneRegistry.byType.wall.size !== lastNumberOfWalls.current ||
-            lastHighlightKey.current !== highlightKey) {
+            lastHighlightKey.current !== highlightKey ||
+            lastWallAppearanceKey.current !== wallAppearanceKey) {
             lastCameraPosition.current.copy(currentCameraPosition);
             lastCameraTarget.current.copy(tmpVec);
             lastUpdateTime.current = currentTime;
@@ -80,27 +95,39 @@ export const WallCutout = () => {
                 const wallMesh = sceneRegistry.nodes.get(wallId);
                 if (!wallMesh)
                     return;
-                const wallNode = useScene.getState().nodes[wallId];
-                if (!wallNode || wallNode.type !== 'wall')
+                const wallNode = sceneState.nodes[wallId];
+                if (wallNode?.type !== 'wall')
                     return;
                 const hideWall = getWallHideState(wallNode, wallMesh, wallMode, u);
                 const isDeleteHighlighted = deleteHoveredWallId === wallId;
                 const isSelectionHighlighted = !isDeleteHighlighted && highlightedWallIds.has(wallId);
-                const materials = getMaterialsForWall(wallNode, shading, textures, colorPreset, sceneTheme);
-                if (hideWall) {
+                const levelId = resolveLevelId(wallNode, sceneState.nodes);
+                const support = spatialGridManager.getSlabSupportForWall(levelId, wallNode.start, wallNode.end, wallNode.curveOffset ?? 0, wallNode.thickness, wallNode.supportSlabId);
+                const effectiveWallHeight = resolveWallEffectiveHeight(wallNode, getWallPlaneTop(wallNode, levelId, sceneState.nodes), support.elevation);
+                const shouldSelectionHighlight = isSelectionHighlighted && !getWallFaceBandConfig(wallNode, effectiveWallHeight).enabled;
+                const materials = getMaterialsForWall(wallNode, shading, textures, colorPreset, sceneTheme, sceneState.materials);
+                if (wallMode === 'translucent') {
+                    ;
+                    wallMesh.material = isDeleteHighlighted
+                        ? materials.deleteTranslucent
+                        : shouldSelectionHighlight
+                            ? getSelectionHighlightMaterials(materials.translucent)
+                            : materials.translucent;
+                }
+                else if (hideWall) {
                     ;
                     wallMesh.material = isDeleteHighlighted
                         ? materials.deleteInvisible
-                        : isSelectionHighlighted
-                            ? materials.highlightedInvisible
+                        : shouldSelectionHighlight
+                            ? getSelectionHighlightMaterials(materials.invisible)
                             : materials.invisible;
                 }
                 else {
                     ;
                     wallMesh.material = isDeleteHighlighted
                         ? materials.deleteVisible
-                        : isSelectionHighlighted
-                            ? materials.highlightedVisible
+                        : shouldSelectionHighlight
+                            ? getSelectionHighlightMaterials(materials.visible)
                             : materials.visible;
                 }
             });
@@ -111,6 +138,7 @@ export const WallCutout = () => {
             lastSceneTheme.current = sceneTheme;
             lastNumberOfWalls.current = sceneRegistry.byType.wall.size;
             lastHighlightKey.current = highlightKey;
+            lastWallAppearanceKey.current = wallAppearanceKey;
         }
     });
     useEffect(() => {
@@ -121,17 +149,21 @@ export const WallCutout = () => {
                 if (!wallMesh)
                     return;
                 const wallNode = useScene.getState().nodes[wallId];
-                if (!wallNode || wallNode.type !== 'wall')
+                if (wallNode?.type !== 'wall')
                     return;
-                const mats = getMaterialsForWall(wallNode, useViewer.getState().shading, useViewer.getState().textures, useViewer.getState().colorPreset, useViewer.getState().sceneTheme);
+                const mats = getMaterialsForWall(wallNode, useViewer.getState().shading, useViewer.getState().textures, useViewer.getState().colorPreset, useViewer.getState().sceneTheme, useScene.getState().materials);
                 const current = wallMesh.material;
                 snapshot.set(wallMesh, current);
-                if (current === mats.highlightedVisible || current === mats.deleteVisible) {
+                if (current === mats.deleteVisible) {
                     wallMesh.material = mats.visible;
                 }
-                else if (current === mats.highlightedInvisible || current === mats.deleteInvisible) {
+                else if (current === mats.deleteInvisible) {
                     wallMesh.material = mats.invisible;
                 }
+                else if (current === mats.deleteTranslucent ||
+                    sameMaterialArray(current, getSelectionHighlightMaterials(mats.translucent))) {
+                    wallMesh.material = mats.translucent;
+                }
             });
         };
         const reapplyAfterCapture = () => {

package/dist/systems/wall/wall-materials.d.ts

@@ -1,17 +1,21 @@
-import { type WallNode } from '@pascal-app/core';
+import { type SceneMaterial, type SceneMaterialId, type WallNode } from '@pascal-app/core';
 import { type Material } from 'three';
 import { type ColorPreset, type RenderShading } from '../../lib/materials';
-export type WallMaterialArray = [Material, Material, Material];
+type SceneMaterials = Record<SceneMaterialId, SceneMaterial> | undefined;
+export type WallMaterialArray = Material[];
 export interface WallMaterials {
     visible: WallMaterialArray;
     invisible: WallMaterialArray;
+    translucent: WallMaterialArray;
     deleteVisible: WallMaterialArray;
     deleteInvisible: WallMaterialArray;
-    highlightedVisible: WallMaterialArray;
-    highlightedInvisible: WallMaterialArray;
+    deleteTranslucent: WallMaterialArray;
     materialHash: string;
 }
-export declare function getWallMaterialHash(wallNode: WallNode, shading: RenderShading): string;
-export declare function getMaterialsForWall(wallNode: WallNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): WallMaterials;
-export declare function getVisibleWallMaterials(wallNode: WallNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): WallMaterialArray;
+/** Lazy light-emissive selection variant of a wall's material array (keeps texture). */
+export declare function getSelectionHighlightMaterials(materials: WallMaterialArray): WallMaterialArray;
+export declare function getWallMaterialHash(wallNode: WallNode, shading: RenderShading, sceneMaterials?: SceneMaterials): string;
+export declare function getMaterialsForWall(wallNode: WallNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string, sceneMaterials?: SceneMaterials): WallMaterials;
+export declare function getVisibleWallMaterials(wallNode: WallNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string, sceneMaterials?: SceneMaterials): WallMaterialArray;
+export {};
 //# sourceMappingURL=wall-materials.d.ts.map

package/dist/systems/wall/wall-materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAS,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAG5C,OAAO,EAEL,KAAK,WAAW,EAIhB,KAAK,aAAa,EAEnB,MAAM,qBAAqB,CAAA;AAqB5B,MAAM,MAAM,iBAAiB,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;AAE9D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,iBAAiB,CAAA;IAC1B,SAAS,EAAE,iBAAiB,CAAA;IAC5B,aAAa,EAAE,iBAAiB,CAAA;IAChC,eAAe,EAAE,iBAAiB,CAAA;IAClC,kBAAkB,EAAE,iBAAiB,CAAA;IACrC,oBAAoB,EAAE,iBAAiB,CAAA;IACvC,YAAY,EAAE,MAAM,CAAA;CACrB;AA6HD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,GAAG,MAAM,CAUtF;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,aAAa,CA6Ef;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,iBAAiB,CAEnB"}
+{"version":3,"file":"wall-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,aAAa,EAClB,KAAK,eAAe,EAGpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAS,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAG5C,OAAO,EAEL,KAAK,WAAW,EAKhB,KAAK,aAAa,EAGnB,MAAM,qBAAqB,CAAA;AAE5B,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,CAAA;AAexE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,EAAE,CAAA;AAE1C,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,iBAAiB,CAAA;IAC1B,SAAS,EAAE,iBAAiB,CAAA;IAC5B,WAAW,EAAE,iBAAiB,CAAA;IAC9B,aAAa,EAAE,iBAAiB,CAAA;IAChC,eAAe,EAAE,iBAAiB,CAAA;IAClC,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,YAAY,EAAE,MAAM,CAAA;CACrB;AAiSD,wFAAwF;AACxF,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,iBAAiB,GAAG,iBAAiB,CAE9F;AA4DD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,aAAa,EACtB,cAAc,CAAC,EAAE,cAAc,GAC9B,MAAM,CAcR;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,cAAc,GAC9B,aAAa,CAgIf;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,cAAc,GAC9B,iBAAiB,CAGnB"}