@pascal-app/core 1.0.3 → 1.0.5

package/dist/building/level-duplication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"level-duplication.d.ts","sourceRoot":"","sources":["../../src/building/level-duplication.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAGd,KAAK,SAAS,EAEf,MAAM,WAAW,CAAA;AAOlB,MAAM,MAAM,oBAAoB,GAC5B,YAAY,GACZ,WAAW,GACX,qBAAqB,GACrB,qBAAqB,CAAA;AAqGzB,6FAA6F;AAC7F,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,SAAS,yvCAElF;AAED,wBAAgB,4BAA4B,CAAC,EAC3C,KAAK,EACL,KAAK,EACL,MAAM,EACN,MAAM,EACN,QAAkB,GACnB,EAAE;IACD,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,KAAK,EAAE,SAAS,CAAA;IAChB,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB,MAAM,EAAE,oBAAoB,CAAA;IAC5B,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAO4B,SAAS,CAAC,IAAI,CAAC;eAAS,MAAM;eAAS,SAAS;;;;cAiOZ,OAAO,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBhF"}

package/dist/building/level-duplication.js

@@ -0,0 +1,328 @@
+import { floorPlateAtGroundContact, supportDerivedFloorHeight } from '../lib/floor-foundation-datum.js';
+import { expandFloorIntentChanges } from '../lib/floor-intent-changes.js';
+import { footprintIoU } from '../lib/floor-plates.js';
+import { getDefaultLevelName } from '../lib/level-name.js';
+import { reconcileSceneStructure } from '../lib/structure-reconcile.js';
+import { generateId, UnitNode, } from '../schema/index.js';
+import { DEFAULT_SLAB_ELEVATION } from '../schema/nodes/slab.js';
+import { isRoofLevel, isStoreyContent } from '../services/roof-level.js';
+import { seatRoofs } from '../services/roof-move.js';
+import { isDerivedNode } from '../store/derived-node-guard.js';
+import { cloneLevelSubtree, remapNodeReferences } from '../utils/clone-scene-graph.js';
+const NON_DUPLICABLE_NODE_TYPES = new Set(['scan', 'guide', 'spawn']);
+const STRUCTURAL_NODE_TYPES = new Set([
+    'level',
+    'wall',
+    'fence',
+    'zone',
+    'slab',
+    'ceiling',
+    'roof',
+    'roof-segment',
+    'stair',
+    'stair-segment',
+    'window',
+    'door',
+]);
+function shouldKeepNode(node, preset) {
+    if (NON_DUPLICABLE_NODE_TYPES.has(node.type))
+        return false;
+    if (preset === 'everything')
+        return true;
+    if (preset === 'structure-furniture')
+        return true;
+    if (preset === 'structure' || preset === 'structure-materials') {
+        return STRUCTURAL_NODE_TYPES.has(node.type);
+    }
+    return true;
+}
+/**
+ * Material field keys per kind, used by the `structure` duplicate preset
+ * to strip materials from the cloned subtree. Lookup table replaces the
+ * legacy per-kind switch — the Phase 6 grep gate flagged `case '<kind>':`
+ * in this file as the remaining per-kind dispatch outside the registry.
+ *
+ * Future: move this to a `capabilities.materialFields` declaration on
+ * each kind's `NodeDefinition` so adding a new kind with materials is a
+ * registry-only edit. Today the registry doesn't surface material fields
+ * in a uniform way (each kind's panel reads / writes them directly), so
+ * this map mirrors the legacy behavior 1:1.
+ */
+const MATERIAL_FIELDS_BY_KIND = {
+    wall: [
+        'material',
+        'materialPreset',
+        'interiorMaterial',
+        'interiorMaterialPreset',
+        'exteriorMaterial',
+        'exteriorMaterialPreset',
+    ],
+    slab: ['material', 'materialPreset'],
+    ceiling: ['material', 'materialPreset'],
+    fence: ['material', 'materialPreset'],
+    shelf: ['material', 'materialPreset'],
+    'roof-segment': ['material', 'materialPreset'],
+    'stair-segment': ['material', 'materialPreset'],
+    window: ['material', 'materialPreset'],
+    door: ['material', 'materialPreset'],
+    roof: [
+        'material',
+        'materialPreset',
+        'topMaterial',
+        'topMaterialPreset',
+        'edgeMaterial',
+        'edgeMaterialPreset',
+        'wallMaterial',
+        'wallMaterialPreset',
+    ],
+    stair: [
+        'material',
+        'materialPreset',
+        'railingMaterial',
+        'railingMaterialPreset',
+        'treadMaterial',
+        'treadMaterialPreset',
+        'sideMaterial',
+        'sideMaterialPreset',
+    ],
+};
+function stripMaterials(node) {
+    const fields = MATERIAL_FIELDS_BY_KIND[node.type];
+    if (!fields)
+        return node;
+    const next = { ...node };
+    for (const field of fields)
+        delete next[field];
+    return next;
+}
+function findLevelBuildingId(nodes, levelId) {
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'building' || !('children' in node) || !Array.isArray(node.children)) {
+            continue;
+        }
+        if (node.children.includes(levelId)) {
+            return node.id;
+        }
+    }
+    return undefined;
+}
+/** The building a level belongs to; a bootstrap level may only be listed in its children. */
+export function levelBuildingId(nodes, level) {
+    return level.parentId ?? findLevelBuildingId(nodes, level.id);
+}
+export function buildLevelDuplicateCreateOps({ nodes, level, levels, preset, position = 'above', }) {
+    const { clonedNodes, newLevelId, idMap } = cloneLevelSubtree(nodes, level.id);
+    const parentBuildingId = levelBuildingId(nodes, level);
+    const nextLevelNumber = position === 'above' ? level.level + 1 : level.level;
+    // Only the floors in the way move up: a free floor index above the copy (floors deleted before
+    // copying, as the agents' build guide does) is filled, not carried up. Pushing every floor above
+    // sent a tall build's floor 8 from index 7 to 10.
+    const shiftedLevels = [];
+    let free = nextLevelNumber;
+    for (const entry of levels
+        .filter((candidate) => (position === 'below' || candidate.id !== level.id) && candidate.level >= nextLevelNumber)
+        .sort((a, b) => a.level - b.level)) {
+        if (entry.level > free)
+            break;
+        shiftedLevels.push({
+            id: entry.id,
+            level: entry.level + 1,
+            // A stored placeholder would pin the old floor's name; cleared, it reads by its new place.
+            ...(entry.name === getDefaultLevelName(entry.level) || entry.name === `Level ${entry.level}`
+                ? { name: undefined }
+                : {}),
+        });
+        free = entry.level + 1;
+    }
+    const filteredNodes = clonedNodes
+        .filter((node) => shouldKeepNode(node, preset))
+        .map((node) => (preset === 'structure' ? stripMaterials(node) : node));
+    const keptIds = new Set(filteredNodes.map((node) => node.id));
+    const cleanedNodes = filteredNodes.map((node) => {
+        if (!('children' in node && Array.isArray(node.children))) {
+            return node;
+        }
+        return {
+            ...node,
+            children: node.children.filter((childId) => keptIds.has(childId)),
+        };
+    });
+    if (parentBuildingId && nodes[parentBuildingId]?.type === 'building') {
+        for (const unit of Object.values(nodes)) {
+            if (unit.type !== 'unit' ||
+                unit.parentId !== parentBuildingId ||
+                unit.members.length === 0 ||
+                !unit.members.every((id) => {
+                    const zone = nodes[id];
+                    const remapped = idMap.get(id);
+                    return (zone?.type === 'zone' &&
+                        zone.parentId === level.id &&
+                        remapped !== undefined &&
+                        keptIds.has(remapped));
+                }))
+                continue;
+            cleanedNodes.push(UnitNode.parse({
+                ...unit,
+                id: undefined,
+                parentId: parentBuildingId,
+                name: `${unit.name} copy`,
+                members: unit.members.map((id) => idMap.get(id)),
+            }));
+        }
+    }
+    const copy = cleanedNodes.find((node) => node.id === newLevelId);
+    copy.level = nextLevelNumber;
+    // A walled level someone declared the roof level is a storey once copied: the copy is one.
+    if (isRoofLevel(copy) &&
+        cleanedNodes.some((node) => node.parentId === newLevelId && isStoreyContent(node.type, node.metadata))) {
+        const { role: _role, ...metadata } = copy.metadata;
+        copy.metadata = metadata;
+    }
+    // Unnamed like a level from the add buttons, so it reads by its place in the building.
+    delete copy.name;
+    copy.baseElevation = 0;
+    copy.parentId = parentBuildingId ?? null;
+    const draft = {
+        ...nodes,
+        ...Object.fromEntries(shiftedLevels.map(({ id, ...data }) => [id, { ...nodes[id], ...data }])),
+        ...Object.fromEntries(cleanedNodes.map((node) => [node.id, node])),
+    };
+    // A ground footprint carries its lift into the storey stack. Repeating
+    // that lift on its upper copy would add the foundation height a second time.
+    const sourceByCopy = new Map([...idMap].map(([source, target]) => [target, source]));
+    const constructionChanges = Object.values(draft).flatMap((node) => {
+        const source = nodes[(sourceByCopy.get(node.id) ?? node.id)];
+        if (node.type !== 'slab' ||
+            node.plateRole !== 'base' ||
+            source?.type !== 'slab' ||
+            !(floorPlateAtGroundContact(nodes, source) ||
+                (sourceByCopy.has(node.id) && source.foundation?.type === 'solid')) ||
+            floorPlateAtGroundContact(draft, node))
+            return [];
+        const reference = supportDerivedFloorHeight(draft, node);
+        return [
+            {
+                id: node.id,
+                data: {
+                    floorHeight: undefined,
+                    referenceFloorElevation: reference,
+                    elevation: reference - DEFAULT_SLAB_ELEVATION + node.thickness,
+                    foundation: { type: 'none' },
+                },
+            },
+        ];
+    });
+    for (const { id, data } of expandFloorIntentChanges(draft, constructionChanges)) {
+        draft[id] = { ...draft[id], ...data };
+        for (const [key, value] of Object.entries(data))
+            if (value === undefined)
+                delete draft[id][key];
+    }
+    const surfaces = cleanedNodes.filter(isDerivedNode).map((node) => draft[node.id]);
+    for (const surface of surfaces)
+        delete draft[surface.id];
+    draft[newLevelId] = { ...copy, children: copy.children.filter((id) => !!draft[id]) };
+    let generated = reconcileSceneStructure({
+        nodes: draft,
+        levelIds: [newLevelId],
+        mintId: generateId,
+    }).nodes;
+    const surfaceIds = new Map();
+    for (const surface of surfaces) {
+        const linked = surface.type === 'slab' ? surface.zoneIds : surface.type === 'ceiling' ? [surface.zoneId] : [];
+        const target = Object.values(generated)
+            .filter((node) => node.parentId === newLevelId &&
+            node.type === surface.type &&
+            (node.type === 'slab' && surface.type === 'slab'
+                ? node.plateRole === surface.plateRole &&
+                    node.zoneIds?.some((id) => linked?.includes(id))
+                : node.type === 'ceiling' && linked?.includes(node.zoneId)))
+            .sort((a, b) => {
+            if (a.id === surface.id)
+                return -1;
+            if (b.id === surface.id)
+                return 1;
+            if (!isDerivedNode(a) || !isDerivedNode(b))
+                return 0;
+            const footprint = { outer: surface.polygon, holes: surface.holes ?? [] };
+            return (footprintIoU(footprint, { outer: b.polygon, holes: b.holes ?? [] }) -
+                footprintIoU(footprint, { outer: a.polygon, holes: a.holes ?? [] }));
+        })[0];
+        if (!target)
+            continue;
+        surfaceIds.set(surface.id, target.id);
+        if (target.type === 'slab' && surface.type === 'slab' && target.plateRole === 'base') {
+            const { thickness, elevation, floorHeight, referenceFloorElevation, foundation, material, materialPreset, slots, name, } = surface;
+            generated[target.id] = {
+                ...target,
+                thickness,
+                elevation,
+                floorHeight,
+                referenceFloorElevation,
+                foundation,
+                material,
+                materialPreset,
+                slots,
+                name,
+            };
+        }
+        if (target.type === 'ceiling' && surface.type === 'ceiling')
+            generated[target.id] = {
+                ...target,
+                height: surface.height,
+                material: surface.material,
+                materialPreset: surface.materialPreset,
+                slots: surface.slots,
+            };
+    }
+    // Everything hosted on a copied surface (ceiling lights, supports, decks,
+    // lean-tos, hangers) follows it to its regenerated id.
+    for (const node of Object.values(generated))
+        if (sourceByCopy.has(node.id))
+            generated[node.id] = remapNodeReferences(node, surfaceIds);
+    for (const id of surfaceIds.values()) {
+        const surface = generated[id];
+        if (surface?.type === 'ceiling')
+            generated[id] = {
+                ...surface,
+                children: Object.values(generated)
+                    .filter((node) => node.parentId === id)
+                    .map((node) => node.id),
+            };
+    }
+    generated = reconcileSceneStructure({
+        nodes: generated,
+        levelIds: [newLevelId],
+        mintId: generateId,
+    }).nodes;
+    const created = Object.values(generated).filter((node) => !nodes[node.id]);
+    const updateOps = Object.values(generated).flatMap((node) => {
+        const old = nodes[node.id];
+        if (!old || JSON.stringify(old) === JSON.stringify(node))
+            return [];
+        const data = Object.fromEntries([...new Set([...Object.keys(old), ...Object.keys(node)])]
+            .filter((key) => JSON.stringify(old[key]) !==
+            JSON.stringify(node[key]))
+            .map((key) => [key, node[key]]));
+        const rebase = constructionChanges.find((change) => change.id === node.id);
+        return [{ id: node.id, data: { ...data, ...rebase?.data } }];
+    });
+    // The copy's roofs on its walls go to the level above it, as every roof writer seats them.
+    const seated = seatRoofs(nodes, {
+        create: created.map((node) => ({
+            node,
+            parentId: node.id === newLevelId
+                ? (parentBuildingId ?? undefined)
+                : (node.parentId ?? undefined),
+        })),
+        update: updateOps,
+    });
+    return {
+        createOps: seated.changes.create,
+        newLevelId,
+        shiftedLevels,
+        updateOps: seated.changes.update,
+        skippedNodes: clonedNodes.filter((node) => !keptIds.has(node.id)),
+        notes: seated.notes,
+    };
+}

package/dist/building/level-insertion.d.ts

@@ -0,0 +1,55 @@
+import { type AnyNode, type AnyNodeId } from '../schema/index.js';
+/**
+ * A new floor under the building's lowest, as the editor's "+" below makes it, without lifting the
+ * building. Levels stack from the lowest one's own `baseElevation`, so a new lowest floor left at 0
+ * would push every floor above it up by its height: a basement added to a house stood the house on
+ * the ground a storey too high (and a second basement, two storeys). The new floor takes the offset
+ * that puts it one storey under where the lowest floor stood, and the old lowest floor gives its own
+ * offset up, so every existing floor keeps its place. One change set, one undo step.
+ */
+export declare function buildLevelBelowChanges({ nodes, buildingId, height, }: {
+    nodes: Readonly<Record<string, AnyNode>>;
+    buildingId: string;
+    height: number;
+}): {
+    newLevel: {
+        object: "node";
+        name?: string | undefined;
+        parentId: string | null;
+        visible: boolean;
+        camera?: {
+            position: [number, number, number];
+            target: [number, number, number];
+            mode: "orthographic" | "perspective";
+            fov?: number | undefined;
+            zoom?: number | undefined;
+        } | undefined;
+        metadata: Record<string, unknown>;
+        provenance?: {
+            refs: {
+                ns?: string | undefined;
+                id: string;
+                role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+            }[];
+            lineage?: {
+                op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+                fromIds: string[];
+            } | undefined;
+        } | undefined;
+        id: `level_${string}`;
+        type: "level";
+        children: (`block_${string}` | `ceiling_${string}` | `column_${string}` | `construction-dimension_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `slab_${string}` | `spawn_${string}` | `stair_${string}` | `structural-grid_${string}` | `wall_${string}` | `zone_${string}`)[];
+        level: number;
+        baseElevation: number;
+        height?: number | undefined;
+    };
+    create: {
+        node: AnyNode;
+        parentId: AnyNodeId;
+    }[];
+    update: {
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    }[];
+};
+//# sourceMappingURL=level-insertion.d.ts.map

package/dist/building/level-insertion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"level-insertion.d.ts","sourceRoot":"","sources":["../../src/building/level-insertion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,WAAW,CAAA;AAGnE;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,KAAK,EACL,UAAU,EACV,MAAM,GACP,EAAE;IACD,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACxC,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;CACf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsBgC,OAAO;kBAA0B,SAAS;;;YAG7C,SAAS;cAAgC,OAAO,CAAC,OAAO,CAAC;;EAGtF"}

package/dist/building/level-insertion.js

@@ -0,0 +1,35 @@
+import { LevelNode } from '../schema/index.js';
+import { getAuthoredLevelElevations } from '../services/storey.js';
+/**
+ * A new floor under the building's lowest, as the editor's "+" below makes it, without lifting the
+ * building. Levels stack from the lowest one's own `baseElevation`, so a new lowest floor left at 0
+ * would push every floor above it up by its height: a basement added to a house stood the house on
+ * the ground a storey too high (and a second basement, two storeys). The new floor takes the offset
+ * that puts it one storey under where the lowest floor stood, and the old lowest floor gives its own
+ * offset up, so every existing floor keeps its place. One change set, one undo step.
+ */
+export function buildLevelBelowChanges({ nodes, buildingId, height, }) {
+    const building = nodes[buildingId];
+    const levels = (building?.type === 'building' ? building.children : []).flatMap((id) => {
+        const level = nodes[id];
+        return level?.type === 'level' ? [level] : [];
+    });
+    const lowest = levels.reduce((low, level) => (low === null || level.level < low.level ? level : low), null);
+    const standsAt = lowest
+        ? (getAuthoredLevelElevations(nodes).get(lowest.id)?.baseY ?? lowest.baseElevation)
+        : 0;
+    const newLevel = LevelNode.parse({
+        level: (lowest?.level ?? 1) - 1,
+        height,
+        children: [],
+        parentId: buildingId,
+        baseElevation: lowest ? standsAt - height : 0,
+    });
+    return {
+        newLevel,
+        create: [{ node: newLevel, parentId: buildingId }],
+        update: lowest && lowest.baseElevation !== 0
+            ? [{ id: lowest.id, data: { baseElevation: 0 } }]
+            : [],
+    };
+}

package/dist/building/merge-windows.d.ts

@@ -0,0 +1,58 @@
+import { type AgentRefusal } from '../agent-tools/refusal.js';
+import type { AnyNode, AnyNodeId, WindowNode } from '../schema/index.js';
+/**
+ * Two windows that exist become one: the one operation behind the editor's Merge windows button,
+ * Wrap the corner when a window already waits at the corner, and the agents' `merge_windows`.
+ *
+ * On two walls that meet at a corner, each reaching it within `CORNER_REACH_M`, they become one
+ * corner window: both adopted, each slid to the corner keeping its width, the glass fused, one sill.
+ * Side by side on one wall with at most `MERGE_GAP_M` between them and nothing between, they
+ * become one window spanning both outer edges. The first window named is the one whose height, sill
+ * and type (corner) or type and style (one wall) the result keeps. A `corner` either had that no
+ * longer makes a pair (its partner moved off the corner) is cleared on both sides.
+ */
+type Nodes = Readonly<Record<string, AnyNode>>;
+/** The widest gap between two windows on one wall that still merges them (m). */
+export declare const MERGE_GAP_M = 0.3;
+export type WindowMerge = {
+    kind: 'corner' | 'same-wall';
+    /** The windows that stay, in the order named. */
+    windowIds: string[];
+    /** The window that went into the first (a merge on one wall). */
+    removedIds: string[];
+    wallIds: string[];
+    /** The bottom edge of the result (m). */
+    sillHeight: number;
+    height: number;
+    /** The width of the merged window (a merge on one wall). */
+    width?: number;
+    /** The angle the walls make (a corner). */
+    angle?: number;
+    changes: {
+        update: {
+            id: AnyNodeId;
+            data: Partial<WindowNode>;
+        }[];
+        delete: AnyNodeId[];
+    };
+    message: string;
+};
+/**
+ * The plan to merge two windows, or a refusal that says why. Pure: `changes` is for the caller to
+ * apply (the editor's store, an agent operation's `SceneChanges`).
+ */
+export declare function mergeWindows(nodes: Nodes, firstId: string, secondId: string): WindowMerge;
+/**
+ * What the Merge windows button does for a selection: nothing unless exactly two windows are
+ * selected; otherwise the merge they would make, or the refusal, whose code and details the panel
+ * words for a person (its message is written for agents, with node ids and metres).
+ */
+export declare function windowMergeOffer(nodes: Nodes, selectedIds: readonly string[]): {
+    merge: WindowMerge;
+    refusal: null;
+} | {
+    merge: null;
+    refusal: AgentRefusal;
+} | null;
+export {};
+//# sourceMappingURL=merge-windows.d.ts.map

package/dist/building/merge-windows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-windows.d.ts","sourceRoot":"","sources":["../../src/building/merge-windows.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAA0B,MAAM,wBAAwB,CAAA;AAalF,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAY,UAAU,EAAE,MAAM,WAAW,CAAA;AAGzE;;;;;;;;;;GAUG;AAEH,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAE9C,iFAAiF;AACjF,eAAO,MAAM,WAAW,MAAM,CAAA;AAa9B,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,QAAQ,GAAG,WAAW,CAAA;IAC5B,iDAAiD;IACjD,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,iEAAiE;IACjE,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,yCAAyC;IACzC,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,4DAA4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,EAAE;QAAE,MAAM,EAAE;YAAE,EAAE,EAAE,SAAS,CAAC;YAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,CAAA;SAAE,EAAE,CAAC;QAAC,MAAM,EAAE,SAAS,EAAE,CAAA;KAAE,CAAA;IACxF,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAqCD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,CAuBzF;AA2JD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,SAAS,MAAM,EAAE,GAC7B;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,GAAG,IAAI,CASvF"}