@pascal-app/viewer 1.0.3 → 1.0.5

package/dist/systems/level/level-hold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"level-hold.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-hold.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,aAAa,YAAa,MAAM,KAAK,MAAM,SAEvD,CAAA;AAED,eAAO,MAAM,UAAU,YAAa,MAAM,KAAG,MAAM,GAAG,SAA+B,CAAA;AAErF,eAAO,MAAM,YAAY,YAAa,MAAM,SAE3C,CAAA"}

package/dist/systems/level/level-hold.js

@@ -0,0 +1,14 @@
+/**
+ * Levels a construction reveal presents at a height of its own: the levels above a floor being taken
+ * apart stay where they stood until it has gone, then the reveal brings them down onto what is below,
+ * writing the height every frame. `LevelSystem` reads `heldLevelY` ahead of the stacked elevation, so a
+ * held level is neither lerped nor snapped. Presentation only: no scene write.
+ */
+const heldY = new Map();
+export const setHeldLevelY = (levelId, y) => {
+    heldY.set(levelId, y);
+};
+export const heldLevelY = (levelId) => heldY.get(levelId);
+export const releaseLevel = (levelId) => {
+    heldY.delete(levelId);
+};

package/dist/systems/level/level-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"level-system.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-system.tsx"],"names":[],"mappings":"AAcA,eAAO,MAAM,WAAW,YA6DvB,CAAA"}
+{"version":3,"file":"level-system.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-system.tsx"],"names":[],"mappings":"AAWA,eAAO,MAAM,WAAW,YAyEvB,CAAA"}

package/dist/systems/level/level-system.js

@@ -3,17 +3,17 @@ import { useFrame } from '@react-three/fiber';
 import { lerp } from 'three/src/math/MathUtils.js';
 import { applyShadowOnly, clearShadowOnly } from '../../lib/shadow-only';
 import useViewer from '../../store/use-viewer';
+import { heldLevelY } from './level-hold';
 import { EXPLODED_GAP, resolveLevelVisibility } from './level-utils';
-// Levels currently in shadow-caster-only mode (solo hides them from the color
-// passes but keeps their sun shadows). Tracked so we can restore layer masks
-// exactly once on transition; apply re-runs every frame so meshes rebuilt
-// while hidden (theme/texture changes) get re-hidden.
-const shadowOnlyLevels = new WeakSet();
+import { shadowOnlyLevels } from './shadow-only-levels';
+const placed = new WeakSet();
 export const LevelSystem = () => {
     useFrame((_, delta) => {
         const nodes = useScene.getState().nodes;
         const levelMode = useViewer.getState().levelMode;
+        const hideAbove = useViewer.getState().hideLevelsAboveSelection;
         const selectedLevel = useViewer.getState().selection.levelId;
+        const levelsRevealing = useViewer.getState().levelsRevealing;
         const levelElevations = getLevelElevations(nodes);
         const entries = [];
         sceneRegistry.byType.level.forEach((levelId) => {
@@ -27,6 +27,10 @@ export const LevelSystem = () => {
                 });
             }
         });
+        // A level that has just mounted (a restored floor, a new storey) cuts every level to its height
+        // together: sliding them from where they were would run the floor and the levels above through
+        // each other.
+        const appeared = entries.some(({ obj }) => !placed.has(obj));
         const selectedIndex = selectedLevel
             ? entries.find((e) => e.levelId === selectedLevel)?.index
             : undefined;
@@ -41,14 +45,23 @@ export const LevelSystem = () => {
             // oscillated kilometers off-screen and the level-fit camera followed
             // (blank viewport). Clamping keeps every step a contraction: identical
             // feel at 60 fps, exact snap instead of overshoot on slow frames.
-            obj.position.y = lerp(obj.position.y, targetY, Math.min(1, delta * 12));
+            const held = heldLevelY(levelId);
+            if (held !== undefined)
+                obj.position.y = held;
+            else if (appeared)
+                obj.position.y = targetY;
+            else
+                obj.position.y = lerp(obj.position.y, targetY, Math.min(1, delta * 12));
+            placed.add(obj);
             const { visible, shadowOnly } = resolveLevelVisibility({
                 levelMode,
+                hideAbove,
                 hasSelectedLevel: Boolean(selectedLevel),
                 isSelected: level?.id === selectedLevel,
                 index,
                 selectedIndex,
                 nodeVisible: level?.visible !== false,
+                revealing: levelsRevealing.includes(levelId),
             });
             if (shadowOnly) {
                 applyShadowOnly(obj);

package/dist/systems/level/level-utils.d.ts

@@ -1,4 +1,5 @@
-export declare const EXPLODED_GAP = 5;
+import { type SceneViewPresentation } from '@pascal-app/core/agent-operations';
+export { EXPLODED_GAP } from '@pascal-app/core';
 /**
  * The Y a level settles at under the given presentation mode — its stacked
  * elevation plus the exploded gap. Analytic (scene store + mode), never a
@@ -12,19 +13,27 @@ export declare function getLevelPresentationY(levelId: string, nodes: Record<str
  * shadow-caster only.
  *
  * Two unrelated things hide a level and they do not compose: the author's own
- * `visible` flag (the sidebar eye), which hides the floor outright, and solo
- * mode, which hides every level but the soloed one — keeping the levels ABOVE
- * it in the shadow map so the sun still shadows the soloed floor through them.
+ * `visible` flag (the sidebar eye), which hides the floor outright, and
+ * presentation hiding — solo mode hides every level but the soloed one, and
+ * the editor's level display (`hideAbove`) hides the levels above the
+ * selected one. Presentation-hidden levels ABOVE the selected one stay in the
+ * shadow map so the sun still shadows the selected floor through them.
  * A level the author hid never enters that shadow-caster branch: its shadows
  * on the floor below would be exactly what hiding it was meant to remove.
+ *
+ * A level a construction reveal is playing on (`revealing`) shows whatever the
+ * presentation hides, so the animation is seen; only the author's own hiding
+ * keeps it out.
  */
-export declare function resolveLevelVisibility({ levelMode, hasSelectedLevel, isSelected, index, selectedIndex, nodeVisible, }: {
+export declare function resolveLevelVisibility({ levelMode, hideAbove, hasSelectedLevel, isSelected, index, selectedIndex, nodeVisible, revealing, }: {
     levelMode: 'stacked' | 'exploded' | 'solo' | 'manual';
+    hideAbove: boolean;
     hasSelectedLevel: boolean;
     isSelected: boolean;
     index: number;
     selectedIndex: number | undefined;
     nodeVisible: boolean;
+    revealing: boolean;
 }): {
     visible: boolean;
     shadowOnly: boolean;
@@ -43,5 +52,9 @@ export declare function resolveLevelVisibility({ levelMode, hasSelectedLevel, is
  *   renderer.render(scene, camera)
  *   restore()
  */
-export declare function snapLevelsToTruePositions(): () => void;
+export declare function snapLevelsToTruePositions({ readOnly, }?: {
+    readOnly?: boolean;
+}): () => void;
+/** The viewer's settled level presentation for one render, without changing saved preferences. */
+export declare function presentLevelsForCapture(presentation: SceneViewPresentation): () => void;
 //# sourceMappingURL=level-utils.d.ts.map

package/dist/systems/level/level-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"level-utils.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,IAAI,CAAA;AAE7B;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GACpD,MAAM,CAKR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,SAAS,EACT,gBAAgB,EAChB,UAAU,EACV,KAAK,EACL,aAAa,EACb,WAAW,GACZ,EAAE;IACD,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAA;IACrD,gBAAgB,EAAE,OAAO,CAAA;IACzB,UAAU,EAAE,OAAO,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,WAAW,EAAE,OAAO,CAAA;CACrB,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAM5C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,IAAI,CA2CtD"}
+{"version":3,"file":"level-utils.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-utils.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,qBAAqB,EAE3B,MAAM,mCAAmC,CAAA;AAS1C,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE/C;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GACpD,MAAM,CAKR;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,SAAS,EACT,SAAS,EACT,gBAAgB,EAChB,UAAU,EACV,KAAK,EACL,aAAa,EACb,WAAW,EACX,SAAS,GACV,EAAE;IACD,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAA;IACrD,SAAS,EAAE,OAAO,CAAA;IAClB,gBAAgB,EAAE,OAAO,CAAA;IACzB,UAAU,EAAE,OAAO,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,WAAW,EAAE,OAAO,CAAA;IACpB,SAAS,EAAE,OAAO,CAAA;CACnB,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAS5C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,QAAgB,GACjB,GAAE;IACD,QAAQ,CAAC,EAAE,OAAO,CAAA;CACd,GAAG,MAAM,IAAI,CAiDlB;AAED,kGAAkG;AAClG,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,qBAAqB,GAAG,MAAM,IAAI,CAiCvF"}

package/dist/systems/level/level-utils.js

@@ -1,5 +1,9 @@
-import { getLevelElevations, sceneRegistry, useScene } from '@pascal-app/core';
-export const EXPLODED_GAP = 5;
+import { EXPLODED_GAP, getLevelElevations, sceneRegistry, useScene, } from '@pascal-app/core';
+import { sceneViewPresentationLevel, } from '@pascal-app/core/agent-operations';
+import { temporarilyHideFromScene, temporarilyShowPresentation, temporarilyShowShadowOnly, } from '../../lib/scene-visibility';
+import { applyShadowOnly, clearShadowOnly } from '../../lib/shadow-only';
+import { shadowOnlyLevels } from './shadow-only-levels';
+export { EXPLODED_GAP } from '@pascal-app/core';
 /**
  * The Y a level settles at under the given presentation mode — its stacked
  * elevation plus the exploded gap. Analytic (scene store + mode), never a
@@ -18,16 +22,25 @@ export function getLevelPresentationY(levelId, nodes, levelMode) {
  * shadow-caster only.
  *
  * Two unrelated things hide a level and they do not compose: the author's own
- * `visible` flag (the sidebar eye), which hides the floor outright, and solo
- * mode, which hides every level but the soloed one — keeping the levels ABOVE
- * it in the shadow map so the sun still shadows the soloed floor through them.
+ * `visible` flag (the sidebar eye), which hides the floor outright, and
+ * presentation hiding — solo mode hides every level but the soloed one, and
+ * the editor's level display (`hideAbove`) hides the levels above the
+ * selected one. Presentation-hidden levels ABOVE the selected one stay in the
+ * shadow map so the sun still shadows the selected floor through them.
  * A level the author hid never enters that shadow-caster branch: its shadows
  * on the floor below would be exactly what hiding it was meant to remove.
+ *
+ * A level a construction reveal is playing on (`revealing`) shows whatever the
+ * presentation hides, so the animation is seen; only the author's own hiding
+ * keeps it out.
  */
-export function resolveLevelVisibility({ levelMode, hasSelectedLevel, isSelected, index, selectedIndex, nodeVisible, }) {
+export function resolveLevelVisibility({ levelMode, hideAbove, hasSelectedLevel, isSelected, index, selectedIndex, nodeVisible, revealing, }) {
     if (!nodeVisible)
         return { visible: false, shadowOnly: false };
-    const hidden = levelMode === 'solo' && hasSelectedLevel && !isSelected;
+    if (revealing)
+        return { visible: true, shadowOnly: false };
+    const hidden = (levelMode === 'solo' && hasSelectedLevel && !isSelected) ||
+        (hideAbove && selectedIndex !== undefined && index > selectedIndex);
     const shadowOnly = hidden && selectedIndex !== undefined && index > selectedIndex;
     return { visible: shadowOnly || !hidden, shadowOnly };
 }
@@ -45,7 +58,7 @@ export function resolveLevelVisibility({ levelMode, hasSelectedLevel, isSelected
  *   renderer.render(scene, camera)
  *   restore()
  */
-export function snapLevelsToTruePositions() {
+export function snapLevelsToTruePositions({ readOnly = false, } = {}) {
     const nodes = useScene.getState().nodes;
     const entries = [];
     sceneRegistry.byType.level.forEach((levelId) => {
@@ -62,11 +75,17 @@ export function snapLevelsToTruePositions() {
     const levelElevations = getLevelElevations(nodes);
     // Snapshot current Y and visibility so we can restore them after the render
     const snapshot = new Map(entries.map(({ levelId, obj }) => [levelId, { y: obj.position.y, visible: obj.visible }]));
-    // Snap to true stacked positions and undo presentation hiding
+    // Snap to true stacked positions and undo presentation hiding — including
+    // the levels kept shadow-caster-only above the selected level.
+    const shadowOnly = entries.filter(({ obj }) => shadowOnlyLevels.has(obj));
     for (const { levelId, obj, nodeVisible } of entries) {
         obj.position.y = levelElevations.get(levelId)?.baseY ?? 0;
         obj.visible = nodeVisible;
     }
+    const restoreMasks = readOnly ? shadowOnly.map(({ obj }) => temporarilyShowShadowOnly(obj)) : [];
+    if (!readOnly)
+        for (const { obj } of shadowOnly)
+            clearShadowOnly(obj);
     return () => {
         for (const { levelId, obj } of entries) {
             const saved = snapshot.get(levelId);
@@ -75,5 +94,45 @@ export function snapLevelsToTruePositions() {
                 obj.visible = saved.visible;
             }
         }
+        if (readOnly)
+            for (const restore of restoreMasks.reverse())
+                restore();
+        else
+            for (const { obj } of shadowOnly)
+                applyShadowOnly(obj);
+    };
+}
+/** The viewer's settled level presentation for one render, without changing saved preferences. */
+export function presentLevelsForCapture(presentation) {
+    const nodes = useScene.getState().nodes;
+    const selected = sceneViewPresentationLevel(nodes, presentation);
+    if (selected &&
+        (!sceneRegistry.nodes.has(selected.id) || !sceneRegistry.byType.level?.has(selected.id)))
+        throw new Error('The level to capture is not ready in this renderer. Try again.');
+    const restores = [snapLevelsToTruePositions({ readOnly: true })];
+    for (const levelId of sceneRegistry.byType.level ?? []) {
+        const obj = sceneRegistry.nodes.get(levelId);
+        const level = nodes[levelId];
+        if (!obj || level?.type !== 'level')
+            continue;
+        obj.position.y = getLevelPresentationY(levelId, nodes, presentation.mode);
+        const { visible, shadowOnly } = resolveLevelVisibility({
+            levelMode: presentation.mode,
+            hideAbove: false,
+            hasSelectedLevel: Boolean(selected),
+            isSelected: level.id === selected?.id,
+            index: level.level,
+            selectedIndex: selected?.type === 'level' ? selected.level : undefined,
+            nodeVisible: level.visible !== false,
+            revealing: false,
+        });
+        obj.visible = visible;
+        restores.push(level.id === selected?.id ? temporarilyShowPresentation(obj) : temporarilyShowShadowOnly(obj));
+        if (shadowOnly)
+            restores.push(temporarilyHideFromScene(obj, 'shadow-only'));
+    }
+    return () => {
+        for (const restore of restores.reverse())
+            restore();
     };
 }

package/dist/systems/level/shadow-only-levels.d.ts

@@ -0,0 +1,9 @@
+import type { Object3D } from 'three';
+/**
+ * Levels currently in shadow-caster-only mode (hidden above the selected level
+ * by solo or by the editor's level display). Tracked so layer masks are
+ * restored exactly once on transition, and so a full-building capture can
+ * show them for its one render.
+ */
+export declare const shadowOnlyLevels: WeakSet<Object3D<import("three").Object3DEventMap>>;
+//# sourceMappingURL=shadow-only-levels.d.ts.map

package/dist/systems/level/shadow-only-levels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-only-levels.d.ts","sourceRoot":"","sources":["../../../src/systems/level/shadow-only-levels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,qDAA0B,CAAA"}

package/dist/systems/level/shadow-only-levels.js

@@ -0,0 +1,7 @@
+/**
+ * Levels currently in shadow-caster-only mode (hidden above the selected level
+ * by solo or by the editor's level display). Tracked so layer masks are
+ * restored exactly once on transition, and so a full-building capture can
+ * show them for its one render.
+ */
+export const shadowOnlyLevels = new WeakSet();

package/dist/systems/roof/__fixtures__/roof-plane-cases.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Every roof the hosted Architect plugin's `hip_roof_planes` and `gable_roof_planes` built, each
+ * beside the `roof_segment_add` call that covers it and the roof segment that call writes, so the
+ * two plane tools can retire into it (catalogue slice R). No stored thread called either tool, so
+ * the cases are what their contracts take (both ridge axes, a hip either way and square, the
+ * default, wide, flush and wider-than-the-eaves gable overhangs, a thickness, an eave on the plate,
+ * over it and on posts) and the plugin's own call (a hip at the walls' 2.6 m tops).
+ *
+ * The plane tools took the rectangle of the walls' outside faces, a rise per 12, the overhang past
+ * those faces in metres (a gable's ends their own), a thickness square to the slope (0.29 m by
+ * default) and an eave height that was the roof's SURFACE at the outside wall face. The segment
+ * takes the same rectangle (`rectAt: 'outside'`), the pitch, the overhangs and the thickness in
+ * any unit, and an eave that is the plate it bears on, its default the walls' tops; the walls'
+ * thickness, which it reads from the walls along those faces (6.5 in where none stand, a porch on
+ * posts), puts their centre lines inside the faces.
+ *
+ * A plane call whose roof stood on its walls, or over them, is the same roof as a segment: same
+ * outline, surface, ridge and thickness (`lift` 0).
+ *
+ * Not reproduced, on purpose (no stored call made either, so each is a call a model could make):
+ * - A plane call with its eave at the walls' tops, the plugin's own and the likeliest, sank its roof
+ *   into them: its slab's underside stood `thickness / cos(pitch)` under the plate at the wall face.
+ *   A segment is never sunk under the walls it sits on (`eave_under_walls`); the replacement leaves
+ *   the eave out and the roof sits on them, the same outline, pitch and thickness, its surface
+ *   `lift` higher. Those rows say so.
+ * - Planes over a storey with another over it stood inside that storey; a segment refuses that
+ *   (`into_storey_above`). The hosted table checks the refusal.
+ * - The plane tools answered each plane's id, so one slope could be edited or painted on its own
+ *   (`update_roof_plane`). A segment is one mass whose slopes change together; one slope on its own
+ *   is `create_roof_plane`'s, which stays, and the retired tools' answer says so.
+ *
+ * The viewer runs the segments through the roof geometry against the planes' own geometry
+ * (`roof-plane-cases.test.ts`); the hosted plugin runs each replacement call through
+ * `roof_segment_add` and reads back the segment it wrote.
+ */
+type Rect = [number, number, number, number];
+/** The walls' thickness, a 2x6 wall finished: what `roof_segment_add` reads from them. */
+export declare const ROOF_PLANE_WALL_THICKNESS: number;
+/** The covering a segment lays over its deck, in the thickness the plane tools took whole. */
+export declare const ROOF_PLANE_COVERING = 0.02;
+export type RoofPlaneCall = {
+    tool: 'hip_roof_planes' | 'gable_roof_planes';
+    rect: Rect;
+    ridgeAxis?: 'x' | 'z';
+    /** Rise per 12. */
+    pitch: number;
+    /** The roof's surface at the outside wall face, metres above the storey's floor. */
+    eaveHeight: number;
+    overhang?: number;
+    gableOverhang?: number;
+    thickness?: number;
+    name?: string;
+};
+export type RoofSegmentAddCall = {
+    roofType: 'hip' | 'gable';
+    name: string;
+    rect: Rect;
+    rectAt: 'outside';
+    ridgeAxis: 'x' | 'z';
+    pitchTwelfths: number;
+    overhangIn: string;
+    gableOverhangIn?: string;
+    thicknessIn: string;
+    eaveHeight?: number;
+};
+/** The segment a replacement call writes, in its storey's plan and metres. */
+export type ExpectedRoofSegment = {
+    roofType: 'hip' | 'gable';
+    name: string;
+    /** The centre of its wall centre-line rectangle. */
+    centre: [number, number];
+    /** Along its ridge axis and across it, at the wall centre lines. */
+    width: number;
+    depth: number;
+    rotation: number;
+    /** Degrees. */
+    pitch: number;
+    /** Along the slope, as the node stores it. */
+    overhang: number;
+    /** In plan past the gable-end walls' outside faces; none on a hip. */
+    gableOverhang?: number;
+    wallThickness: number;
+    deckThickness: number;
+    shingleThickness: number;
+    /** The plate it bears on, metres above the storey's floor. */
+    eave: number;
+};
+export type RoofPlaneCase = {
+    name: string;
+    /** The walls under the roof: their outside faces and how tall they stand (none: posts). */
+    walls: {
+        rect: Rect;
+        height: number;
+    } | null;
+    call: RoofPlaneCall;
+    replacement: RoofSegmentAddCall;
+    segment: ExpectedRoofSegment;
+    /** How far the segment's surface stands over the planes' (0: the same roof). */
+    lift: number;
+};
+export declare const ROOF_PLANE_CASES: readonly RoofPlaneCase[];
+export {};
+//# sourceMappingURL=roof-plane-cases.d.ts.map

package/dist/systems/roof/__fixtures__/roof-plane-cases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-plane-cases.d.ts","sourceRoot":"","sources":["../../../../src/systems/roof/__fixtures__/roof-plane-cases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAG5C,0FAA0F;AAC1F,eAAO,MAAM,yBAAyB,QAAW,CAAA;AACjD,8FAA8F;AAC9F,eAAO,MAAM,mBAAmB,OAAO,CAAA;AAMvC,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,iBAAiB,GAAG,mBAAmB,CAAA;IAC7C,IAAI,EAAE,IAAI,CAAA;IACV,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,CAAA;IACrB,mBAAmB;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,oFAAoF;IACpF,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,KAAK,GAAG,OAAO,CAAA;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,IAAI,CAAA;IACV,MAAM,EAAE,SAAS,CAAA;IACjB,SAAS,EAAE,GAAG,GAAG,GAAG,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,8EAA8E;AAC9E,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,KAAK,GAAG,OAAO,CAAA;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,oDAAoD;IACpD,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxB,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,eAAe;IACf,KAAK,EAAE,MAAM,CAAA;IACb,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAA;IAChB,sEAAsE;IACtE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,gBAAgB,EAAE,MAAM,CAAA;IACxB,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,2FAA2F;IAC3F,KAAK,EAAE;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IAC5C,IAAI,EAAE,aAAa,CAAA;IACnB,WAAW,EAAE,kBAAkB,CAAA;IAC/B,OAAO,EAAE,mBAAmB,CAAA;IAC5B,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AA0ED,eAAO,MAAM,gBAAgB,EAAE,SAAS,aAAa,EAsRpD,CAAA"}