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

package/dist/pipe-trap/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/tool.tsx"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,QAAA,MAAM,YAAY,0CA4GjB,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/tool.tsx"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,QAAA,MAAM,YAAY,0CAqHjB,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/pipe-trap/tool.js

@@ -1,10 +1,12 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, PipeTrapNode, useScene } from '@pascal-app/core';
-import { isGridSnapActive, triggerSFX, useEditor } from '@pascal-app/editor';
+import { isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useEffect, useMemo, useRef, useState } from 'react';
+import { subscribeAccessorySnapping } from '../shared/accessory-snapping';
+import { alignDrawPoint, clearDrawAlignment } from '../shared/draw-alignment';
 import { LevelOffsetGroup } from '../shared/level-offset-group';
 import { pipeTrapDefinition } from './definition';
 import { buildPipeTrapGeometry } from './geometry';
@@ -50,11 +52,16 @@ const PipeTrapTool = () => {
         const resolve = (event) => {
             const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
             return {
-                position: [snap(event.localPosition[0], step), 0, snap(event.localPosition[2], step)],
+                position: alignDrawPoint([snap(event.localPosition[0], step), 0, snap(event.localPosition[2], step)], {
+                    applySnap: isMagneticSnapActive(),
+                    bypass: !isMagneticSnapActive(),
+                }),
                 diameter: diameterRef.current,
             };
         };
+        let lastEvent = null;
         const onMove = (event) => {
+            lastEvent = event;
             setCursor(resolve(event).position);
         };
         const onClick = (event) => {
@@ -83,13 +90,19 @@ const PipeTrapTool = () => {
                 triggerSFX('sfx:item-rotate');
             }
         };
+        const unsubscribeSnapping = subscribeAccessorySnapping(() => {
+            if (lastEvent)
+                onMove(lastEvent);
+        });
         emitter.on('grid:move', onMove);
         emitter.on('grid:click', onClick);
         window.addEventListener('keydown', onKeyDown, true);
         return () => {
+            unsubscribeSnapping();
             emitter.off('grid:move', onMove);
             emitter.off('grid:click', onClick);
             window.removeEventListener('keydown', onKeyDown, true);
+            clearDrawAlignment();
         };
     }, [activeLevelId]);
     if (!activeLevelId || !cursor)

package/dist/procedural-item/definition.d.ts

@@ -0,0 +1,4 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { ProceduralItemNode } from '@pascal-app/core/procedural-items';
+export declare const proceduralItemDefinition: NodeDefinition<typeof ProceduralItemNode>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/procedural-item/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/procedural-item/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgD,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEpG,OAAO,EAKL,kBAAkB,EAWnB,MAAM,mCAAmC,CAAA;AA6D1C,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAmO9E,CAAA"}

package/dist/procedural-item/definition.js

@@ -0,0 +1,254 @@
+import { useScene } from '@pascal-app/core';
+import { boundsOf, boxCorners, evaluateRecipe, frame, ProceduralItemNode, parameterPatch, proceduralFootprint, proceduralSlotColor, queryProceduralItem, resolveProceduralWallPlacement, setProceduralMaterial, shelfRecipe, snapParameters, transformPoint, validateProceduralRelations, } from '@pascal-app/core/procedural-items';
+import { itemPaint } from '../item/paint';
+import { proceduralFloorplanMoveTarget } from './move-session';
+const GIZMO_SIDE_OFFSET = 0.3;
+const GIZMO_FRONT_OFFSET = 0.3;
+const ROTATE_RING_OFFSET = 0.06;
+function handleBounds(node, part) {
+    const e = evaluateRecipe(node.recipe, node.parameters);
+    const shapes = part ? e.shapes.filter((shape) => shape.partId === part) : [];
+    return shapes.length
+        ? boundsOf(shapes.flatMap((shape) => boxCorners(shape.size.map((v) => -v / 2), shape.size.map((v) => v / 2)).map((point) => transformPoint(frame(shape.position, shape.rotation), point))))
+        : e;
+}
+function proceduralRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => {
+            const [rx, ry, rz] = initial.rotation;
+            return { rotation: [rx, ry - delta, rz] };
+        },
+        placement: {
+            position: (n) => {
+                const b = evaluateRecipe(n.recipe, n.parameters);
+                return [
+                    b.max[0] + GIZMO_SIDE_OFFSET,
+                    (b.min[1] + b.max[1]) / 2,
+                    b.max[2] + GIZMO_FRONT_OFFSET,
+                ];
+            },
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            center: (n) => {
+                const b = evaluateRecipe(n.recipe, n.parameters);
+                return b.min.map((v, i) => (v + b.max[i]) / 2);
+            },
+            radius: (n) => {
+                const b = evaluateRecipe(n.recipe, n.parameters);
+                return Math.hypot(b.dimensions[0] / 2, b.dimensions[2] / 2) + ROTATE_RING_OFFSET;
+            },
+            y: (n) => {
+                const b = evaluateRecipe(n.recipe, n.parameters);
+                return (b.min[1] + b.max[1]) / 2;
+            },
+        },
+    };
+}
+export const proceduralItemDefinition = {
+    kind: 'procedural-item',
+    schemaVersion: 1,
+    schema: ProceduralItemNode,
+    category: 'furnish',
+    snapProfile: 'item',
+    surfaceRole: 'furnishing',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        recipe: shelfRecipe,
+        parameters: {},
+        slots: {},
+        children: [],
+        attachments: {},
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        dragBounds: (n) => {
+            const node = n;
+            const e = evaluateRecipe(node.recipe, node.parameters);
+            return {
+                size: e.dimensions,
+                center: e.min.map((v, i) => (v + e.max[i]) / 2),
+            };
+        },
+        hostable: {
+            parents: ['level', 'wall', 'ceiling', 'procedural-item', 'item', 'shelf'],
+            align: 'face',
+        },
+        hostRefFields: ['wallId', 'side', 'supportSlabId'],
+        floorPlaced: {
+            footprint: (n) => proceduralFootprint(n),
+            applies: (n) => !n.recipe.mounting,
+            collides: true,
+        },
+        movable: { axes: ['x', 'z'], gridSnap: true },
+        rotatable: { axes: ['y'], snapAngles: [0, Math.PI / 4, Math.PI / 2, Math.PI] },
+        duplicable: true,
+        deletable: true,
+        slots: (n) => {
+            const node = n;
+            return node.recipe.slots.map((s) => ({ slotId: s.id, label: s.label, default: s.color }));
+        },
+        surfaces: {
+            custom: (n) => evaluateRecipe(n.recipe, n.parameters).surfaces.map((s) => ({
+                id: s.id,
+                position: s.position,
+                normal: s.normal,
+                rotation: s.rotation,
+                size: s.size,
+            })),
+        },
+        paint: {
+            ...itemPaint,
+            commit: ({ node, role, material, materialPreset }) => setProceduralMaterial(node.id, role, materialPreset, material),
+        },
+    },
+    relations: { hosts: ['item', 'procedural-item'], cascadeDelete: 'descendants' },
+    renderer: { kind: 'parametric', module: () => import('./renderer') },
+    parametrics: { groups: [], customPanel: () => import('@pascal-app/editor/procedural-items') },
+    affordanceTools: { move: () => import('./move-tool') },
+    floorplanMoveTarget: proceduralFloorplanMoveTarget,
+    keyboardActions: {
+        r: {
+            appliesTo: (n) => Boolean(n.wallId),
+            run: (n) => {
+                const node = n;
+                const nodes = useScene.getState().nodes;
+                const wall = nodes[node.wallId];
+                if (wall?.type !== 'wall')
+                    return;
+                const next = resolveProceduralWallPlacement(node, wall, node.position[0], node.position[1], node.side === 'back' ? 'front' : 'back', nodes);
+                if (next)
+                    useScene.getState().updateNode(node.id, {
+                        side: next.side,
+                        position: [next.position[0], next.position[1], node.position[2]],
+                    });
+            },
+        },
+    },
+    handles: (node) => {
+        const result = [];
+        for (const p of node.recipe.parameters) {
+            if (!p.axis)
+                continue;
+            const axis = p.axis, index = axis === 'x' ? 0 : axis === 'y' ? 1 : 2;
+            const downward = axis === 'y' && node.recipe.mounting?.attachTo === 'ceiling';
+            result.push({
+                kind: 'linear-resize',
+                latchGroup: p.part,
+                faceNormal: Boolean(node.wallId),
+                portal: node.recipe.mounting ? 'grandparent' : 'self',
+                axis,
+                direction: downward ? -1 : undefined,
+                anchor: axis === 'y' ? (downward ? 'max' : 'min') : 'center',
+                min: p.min,
+                max: p.max,
+                currentValue: (n) => n.parameters[p.id] ?? p.default,
+                apply: (n, v, scene) => {
+                    const patch = parameterPatch(n, p.id, Math.min(p.max, Math.max(p.min, v)));
+                    if (!patch)
+                        return {};
+                    try {
+                        validateProceduralRelations({ ...n, ...patch }, scene.nodes());
+                        validateProceduralRelations({ ...n, parameters: snapParameters(n.recipe, patch.parameters) }, scene.nodes());
+                        return patch;
+                    }
+                    catch {
+                        return {};
+                    }
+                },
+                commit: (n, patch, scene) => {
+                    const parameters = snapParameters(n.recipe, patch.parameters ?? n.parameters);
+                    validateProceduralRelations({ ...n, parameters }, scene.nodes());
+                    scene.update(n.id, { parameters });
+                },
+                placement: {
+                    clearance: {
+                        edge: (n) => handleBounds(n, p.part)[downward ? 'min' : 'max'][index],
+                        distance: 0.4,
+                    },
+                    position: (n) => {
+                        const b = handleBounds(n, p.part);
+                        const pos = b.max.map((v, i) => (i === index ? v + 0.15 : (b.min[i] + v) / 2));
+                        if (downward)
+                            pos[index] = b.min[index] - 0.15;
+                        return pos;
+                    },
+                },
+            });
+        }
+        if (node.recipe.mounting?.attachTo !== 'wall-side')
+            result.push({
+                ...proceduralRotateHandle(),
+                portal: node.recipe.mounting ? 'grandparent' : 'self',
+            });
+        return result;
+    },
+    floorplan: (node, ctx) => {
+        const chain = { [node.id]: node };
+        let current = node.parentId, depth = 0;
+        while (current && depth++ < 32) {
+            const parent = ctx.resolve(current);
+            if (!parent)
+                break;
+            chain[current] = parent;
+            current = parent.parentId;
+        }
+        const q = queryProceduralItem(node, chain), b = q.levelBounds;
+        const floorPlanUrl = node.metadata.floorPlanUrl;
+        if (typeof floorPlanUrl === 'string' && floorPlanUrl.trim()) {
+            const local = q.localBounds;
+            const center = transformPoint(q.frame, local.min.map((v, i) => (v + local.max[i]) / 2));
+            const points = [
+                [local.min[0], local.min[2]],
+                [local.max[0], local.min[2]],
+                [local.max[0], local.max[2]],
+                [local.min[0], local.max[2]],
+            ].map(([x, z]) => {
+                const point = transformPoint(q.frame, [x, 0, z]);
+                return [point[0], point[2]];
+            });
+            const selected = ctx.viewState?.selected || ctx.viewState?.highlighted;
+            const stroke = selected ? (ctx.viewState?.palette?.selectedStroke ?? '#3b82f6') : '#92400e';
+            const strokeWidth = selected ? 0.035 : 0.012;
+            const children = [
+                { kind: 'polygon', points, fill: 'transparent', stroke, strokeWidth, opacity: 0.85 },
+                {
+                    kind: 'image',
+                    url: floorPlanUrl,
+                    center: [center[0], center[2]],
+                    width: local.dimensions[0],
+                    height: local.dimensions[2],
+                    rotation: Math.atan2(q.frame.axes[0][2], q.frame.axes[0][0]),
+                },
+            ];
+            if (selected)
+                children.push({ kind: 'polygon', points, fill: 'none', stroke, strokeWidth });
+            return { kind: 'group', children };
+        }
+        return {
+            kind: 'rect',
+            x: b.min[0],
+            y: b.min[2],
+            width: b.dimensions[0],
+            height: b.dimensions[2],
+            fill: proceduralSlotColor(node.slots[node.recipe.slots[0].id], node.recipe.slots[0].color, ctx.materials ?? {}),
+            stroke: '#44403c',
+            strokeWidth: 0.01,
+        };
+    },
+    presentation: {
+        label: 'Procedural item',
+        description: 'Experimental editable recipe',
+        icon: { kind: 'iconify', name: 'lucide:boxes' },
+    },
+    mcp: { description: 'Experimental procedural item with a validated recipe.' },
+};

package/dist/procedural-item/geometry.d.ts

@@ -0,0 +1,31 @@
+import { type Evaluation, type ProceduralItemNode } from '@pascal-app/core/procedural-items';
+import { type BufferGeometry } from 'three';
+export type Batch = {
+    slot: string;
+    geometry: BufferGeometry;
+    ranges: {
+        end: number;
+        partId: string;
+        shapeId: string;
+    }[];
+};
+export type BuiltItem = {
+    batches: Batch[];
+    evaluation: Evaluation;
+    milliseconds: number;
+    triangles: number;
+};
+export declare const proceduralMetrics: {
+    builds: number;
+    cacheHits: number;
+    lastBuildMs: number;
+    liveEntries: number;
+};
+export declare const geometrySignature: (node: ProceduralItemNode) => string;
+export declare function buildProceduralGeometry(node: ProceduralItemNode): BuiltItem;
+export declare function acquireProceduralGeometry(node: ProceduralItemNode): {
+    value: BuiltItem;
+    release: () => void;
+};
+export declare function partAtFace(ranges: Batch['ranges'], face: number): string | null;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/procedural-item/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/procedural-item/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAEf,KAAK,kBAAkB,EACxB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAEL,KAAK,cAAc,EAMpB,MAAM,OAAO,CAAA;AAGd,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,cAAc,CAAA;IACxB,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAC3D,CAAA;AACD,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,KAAK,EAAE,CAAA;IAChB,UAAU,EAAE,UAAU,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AACD,eAAO,MAAM,iBAAiB;;;;;CAA8D,CAAA;AAE5F,eAAO,MAAM,iBAAiB,GAAI,MAAM,kBAAkB,WACV,CAAA;AAChD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,CA8D3E;AACD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,kBAAkB;;;EAwBjE;AACD,wBAAgB,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,iBAE/D"}

package/dist/procedural-item/geometry.js

@@ -0,0 +1,88 @@
+import { evaluateRecipe, } from '@pascal-app/core/procedural-items';
+import { BoxGeometry, CylinderGeometry, Euler, Matrix4, Quaternion, Vector3, } from 'three';
+import { RoundedBoxGeometry } from 'three/addons/geometries/RoundedBoxGeometry.js';
+import { mergeGeometries } from 'three/addons/utils/BufferGeometryUtils.js';
+export const proceduralMetrics = { builds: 0, cacheHits: 0, lastBuildMs: 0, liveEntries: 0 };
+const cache = new Map();
+export const geometrySignature = (node) => JSON.stringify([node.recipe, node.parameters]);
+export function buildProceduralGeometry(node) {
+    const start = performance.now(), evaluation = evaluateRecipe(node.recipe, node.parameters);
+    const bySlot = new Map();
+    for (const shape of evaluation.shapes) {
+        const [w, h, d] = shape.size;
+        const source = shape.primitive === 'roundedBox'
+            ? new RoundedBoxGeometry(w, h, d, 2, shape.radius)
+            : shape.primitive === 'cylinder'
+                ? new CylinderGeometry(0.5, 0.5, 1, 24, 1)
+                : new BoxGeometry(w, h, d);
+        if (shape.primitive === 'cylinder')
+            source.scale(w, h, d);
+        const geometry = source.index ? source.toNonIndexed() : source;
+        if (geometry !== source)
+            source.dispose();
+        geometry.clearGroups();
+        const vertices = geometry.getAttribute('position'), normals = geometry.getAttribute('normal'), uv = geometry.getAttribute('uv');
+        for (let i = 0; i < vertices.count; i++) {
+            const x = vertices.getX(i), y = vertices.getY(i), z = vertices.getZ(i);
+            const nx = Math.abs(normals.getX(i)), ny = Math.abs(normals.getY(i)), nz = Math.abs(normals.getZ(i));
+            uv.setXY(i, nx > ny && nx > nz ? z : x, ny > nx && ny > nz ? z : y);
+        }
+        geometry.applyMatrix4(new Matrix4().compose(new Vector3(...shape.position), new Quaternion().setFromEuler(new Euler(...shape.rotation)), new Vector3(1, 1, 1)));
+        const entry = bySlot.get(shape.slot) ?? { geometries: [], ranges: [], faces: 0 };
+        entry.geometries.push(geometry);
+        entry.faces += geometry.getAttribute('position').count / 3;
+        entry.ranges.push({ end: entry.faces, partId: shape.partId, shapeId: shape.id });
+        bySlot.set(shape.slot, entry);
+    }
+    const batches = [];
+    for (const [slot, entry] of bySlot) {
+        const geometry = mergeGeometries(entry.geometries, false);
+        for (const g of entry.geometries)
+            g.dispose();
+        if (!geometry)
+            throw new Error('Unable to batch procedural geometry');
+        geometry.computeBoundingBox();
+        geometry.computeBoundingSphere();
+        batches.push({ slot, geometry, ranges: entry.ranges });
+    }
+    const milliseconds = performance.now() - start;
+    proceduralMetrics.builds++;
+    proceduralMetrics.lastBuildMs = milliseconds;
+    return {
+        batches,
+        evaluation,
+        milliseconds,
+        triangles: batches.reduce((n, b) => n + b.geometry.getAttribute('position').count / 3, 0),
+    };
+}
+export function acquireProceduralGeometry(node) {
+    const key = geometrySignature(node);
+    let entry = cache.get(key);
+    if (entry)
+        proceduralMetrics.cacheHits++;
+    else {
+        entry = { value: buildProceduralGeometry(node), users: 0 };
+        cache.set(key, entry);
+    }
+    entry.users++;
+    proceduralMetrics.liveEntries = cache.size;
+    let released = false;
+    return {
+        value: entry.value,
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            const current = cache.get(key);
+            if (current && --current.users === 0) {
+                for (const batch of current.value.batches)
+                    batch.geometry.dispose();
+                cache.delete(key);
+            }
+            proceduralMetrics.liveEntries = cache.size;
+        },
+    };
+}
+export function partAtFace(ranges, face) {
+    return ranges.find((r) => face < r.end)?.partId ?? null;
+}

package/dist/procedural-item/index.d.ts

@@ -0,0 +1,3 @@
+export { proceduralItemDefinition } from './definition';
+export { acquireProceduralGeometry, buildProceduralGeometry, geometrySignature, partAtFace, proceduralMetrics, } from './geometry';
+//# sourceMappingURL=index.d.ts.map

package/dist/procedural-item/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/procedural-item/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAA;AACvD,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,iBAAiB,EACjB,UAAU,EACV,iBAAiB,GAClB,MAAM,YAAY,CAAA"}

package/dist/procedural-item/index.js

@@ -0,0 +1,2 @@
+export { proceduralItemDefinition } from './definition';
+export { acquireProceduralGeometry, buildProceduralGeometry, geometrySignature, partAtFace, proceduralMetrics, } from './geometry';

package/dist/procedural-item/move-session.d.ts

@@ -0,0 +1,15 @@
+import { type AnyNodeId, type CeilingNode, type FloorplanMoveTarget, type FloorplanMoveTargetSession, type WallNode } from '@pascal-app/core';
+import { type ProceduralItemNode } from '@pascal-app/core/procedural-items';
+export declare const createProceduralWallMoveSession: typeof createProceduralMountedMoveSession;
+export declare const createProceduralCeilingMoveSession: typeof createProceduralMountedMoveSession;
+declare function createProceduralMountedMoveSession(node: ProceduralItemNode, levelId: AnyNodeId): FloorplanMoveTargetSession & {
+    wall(wall: WallNode, x: number, y: number, side: "front" | "back", alt: boolean): void;
+    ceiling(ceiling: CeilingNode, x: number, z: number, alt: boolean): void;
+    rotate(direction: number): void;
+    free(point: readonly [number, number]): void;
+    commit(): void;
+    readonly candidate: ProceduralItemNode | null;
+};
+export declare const proceduralFloorplanMoveTarget: FloorplanMoveTarget<ProceduralItemNode>;
+export {};
+//# sourceMappingURL=move-session.d.ts.map

package/dist/procedural-item/move-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-session.d.ts","sourceRoot":"","sources":["../../src/procedural-item/move-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAI/B,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAML,KAAK,kBAAkB,EAOxB,MAAM,mCAAmC,CAAA;AA0B1C,eAAO,MAAM,+BAA+B,2CAAqC,CAAA;AACjF,eAAO,MAAM,kCAAkC,2CAAqC,CAAA;AAEpF,iBAAS,kCAAkC,CAAC,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,SAAS;eA4BzE,QAAQ,KAAK,MAAM,KAAK,MAAM,QAAQ,OAAO,GAAG,MAAM,OAAO,OAAO,GAAG,IAAI;qBACrE,WAAW,KAAK,MAAM,KAAK,MAAM,OAAO,OAAO,GAAG,IAAI;sBACrD,MAAM,GAAG,IAAI;gBACnB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;cAClC,IAAI;wBACM,kBAAkB,GAAG,IAAI;EAiKhD;AAED,eAAO,MAAM,6BAA6B,EAAE,mBAAmB,CAAC,kBAAkB,CAqBjF,CAAA"}