@pascal-app/core 1.0.1 → 1.0.4

package/dist/agent-operations/door-clearance.js

@@ -0,0 +1,334 @@
+/**
+ * Door access keep-outs for MCP layout tools.
+ *
+ * Furniture that overlaps a door clear zone is reported as blocking the door.
+ * Used by furnish_room (skip placements) and verify_scene (layout issues).
+ *
+ * See docs/layout-clearance-error-log.md for pitfalls (levels, gap sign, scale).
+ */
+import { getScaledDimensions } from '../schema/index.js';
+import { wallLength } from './plan-geometry.js';
+/** Plan depth (m) cleared on each side of the wall face through the opening. */
+export const DEFAULT_DOOR_CLEAR_DEPTH = 0.65;
+/** Extra half-width (m) beyond the door leaf along the wall. */
+export const DEFAULT_DOOR_SIDE_PAD = 0.05;
+/**
+ * True when A and B come closer than `gap` meters (including penetration).
+ * `gap` is the **minimum free space required** between boxes:
+ * expand each box by gap/2, then test intersection.
+ */
+export function aabbsOverlap(a, b, gap = 0) {
+    const g = gap;
+    return a.maxX + g > b.minX && a.minX - g < b.maxX && a.maxZ + g > b.minZ && a.minZ - g < b.maxZ;
+}
+/**
+ * Walk parentId chain to the enclosing level id (pure; no bridge required).
+ */
+export function resolveNodeLevelId(nodeId, byId) {
+    let current = byId.get(nodeId);
+    const seen = new Set();
+    while (current) {
+        if (seen.has(current.id))
+            return null;
+        seen.add(current.id);
+        if (current.type === 'level')
+            return current.id;
+        const parentId = current.parentId;
+        if (parentId && byId.has(parentId)) {
+            current = byId.get(parentId);
+            continue;
+        }
+        current = findParentByChildren(current.id, byId);
+    }
+    return null;
+}
+function findParentByChildren(nodeId, byId) {
+    for (const candidate of byId.values()) {
+        if (!('children' in candidate) || !Array.isArray(candidate.children))
+            continue;
+        const containsNode = candidate.children.some((child) => {
+            if (typeof child === 'string')
+                return child === nodeId;
+            return (child !== null &&
+                typeof child === 'object' &&
+                'id' in child &&
+                child.id === nodeId);
+        });
+        if (containsNode)
+            return candidate;
+    }
+    return undefined;
+}
+/**
+ * Axis-aligned item footprint in plan (x/z), rotation-aware.
+ * Prefer scaled dimensions when the node is available.
+ */
+export function itemPlanAabb(position, dimensions, rotationYRad = 0) {
+    const x = position[0] ?? 0;
+    const z = position[2] ?? 0;
+    const [w = 1, , d = 1] = dimensions ?? [1, 1, 1];
+    const cos = Math.abs(Math.cos(rotationYRad));
+    const sin = Math.abs(Math.sin(rotationYRad));
+    const halfW = (w * cos + d * sin) / 2;
+    const halfD = (w * sin + d * cos) / 2;
+    return {
+        minX: x - halfW,
+        maxX: x + halfW,
+        minZ: z - halfD,
+        maxZ: z + halfD,
+    };
+}
+/** Scaled plan footprint used by legacy placement and door-clearance callers. */
+export function itemNodePlanAabb(node) {
+    if (node.type !== 'item')
+        return null;
+    if (!Array.isArray(node.asset.dimensions))
+        return null;
+    const [width, height, depth] = getScaledDimensions(node);
+    const rotationY = Array.isArray(node.rotation) ? (node.rotation[1] ?? 0) : 0;
+    if (![node.position[0], node.position[2], width, height, depth, rotationY].every(Number.isFinite)) {
+        return null;
+    }
+    return itemPlanAabb(node.position, [Math.abs(width), Math.abs(height), Math.abs(depth)], rotationY);
+}
+export function inspectItemPlanFootprint(node, options) {
+    if (options?.floorOnly &&
+        (node.asset.attachTo === 'wall' ||
+            node.asset.attachTo === 'wall-side' ||
+            node.asset.attachTo === 'ceiling')) {
+        return { ok: false, reason: 'unsupported_attachment' };
+    }
+    const position = node.position;
+    if (!Array.isArray(position)) {
+        return { ok: false, reason: 'non_finite_position' };
+    }
+    const x = position[0];
+    const y = position[1];
+    const z = position[2];
+    if (!(Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z))) {
+        return { ok: false, reason: 'non_finite_position' };
+    }
+    const rotation = Array.isArray(node.rotation) ? node.rotation : [0, 0, 0];
+    const rotationX = rotation[0] ?? Number.NaN;
+    const rotationY = rotation[1] ?? Number.NaN;
+    const rotationZ = rotation[2] ?? Number.NaN;
+    if (!(Number.isFinite(rotationX) && Number.isFinite(rotationY) && Number.isFinite(rotationZ))) {
+        return { ok: false, reason: 'non_finite_rotation' };
+    }
+    if (Math.abs(rotationX) > 1e-6 || Math.abs(rotationZ) > 1e-6) {
+        return { ok: false, reason: 'non_planar_rotation' };
+    }
+    const dimensions = node.asset.dimensions;
+    if (!Array.isArray(dimensions) || dimensions.length !== 3) {
+        return { ok: false, reason: 'missing_dimensions' };
+    }
+    const width = dimensions[0] ?? Number.NaN;
+    const height = dimensions[1] ?? Number.NaN;
+    const depth = dimensions[2] ?? Number.NaN;
+    if (!(Number.isFinite(width) && Number.isFinite(height) && Number.isFinite(depth))) {
+        return { ok: false, reason: 'non_finite_dimensions' };
+    }
+    if (width <= 0 || depth <= 0) {
+        return { ok: false, reason: 'non_positive_plan_dimensions' };
+    }
+    const scale = Array.isArray(node.scale) ? node.scale : [1, 1, 1];
+    const scaleX = scale[0] ?? Number.NaN;
+    const scaleY = scale[1] ?? Number.NaN;
+    const scaleZ = scale[2] ?? Number.NaN;
+    if (!(Number.isFinite(scaleX) && Number.isFinite(scaleY) && Number.isFinite(scaleZ))) {
+        return { ok: false, reason: 'non_finite_scale' };
+    }
+    if (scaleX === 0 || scaleZ === 0) {
+        return { ok: false, reason: 'zero_plan_scale' };
+    }
+    const [scaledWidth, scaledHeight, scaledDepth] = getScaledDimensions(node);
+    const effectiveDimensions = [
+        Math.abs(scaledWidth),
+        Math.abs(scaledHeight),
+        Math.abs(scaledDepth),
+    ];
+    if (!effectiveDimensions.every(Number.isFinite)) {
+        return { ok: false, reason: 'non_finite_dimensions' };
+    }
+    if (effectiveDimensions[0] <= 0 || effectiveDimensions[2] <= 0) {
+        return { ok: false, reason: 'non_positive_plan_dimensions' };
+    }
+    return {
+        ok: true,
+        aabb: itemPlanAabb(node.position, effectiveDimensions, rotationY),
+        sourceDimensions: [width, height, depth],
+        effectiveDimensions,
+        rotationY,
+    };
+}
+/**
+ * Build a rectangular keep-out around a wall door, extruded perpendicular to the wall
+ * on both faces so either swing side is protected.
+ */
+export function doorKeepoutFromWall(wall, door, options) {
+    const clearDepth = options?.clearDepth ?? DEFAULT_DOOR_CLEAR_DEPTH;
+    const sidePad = options?.sidePad ?? DEFAULT_DOOR_SIDE_PAD;
+    const length = wallLength(wall);
+    if (length <= 1e-6)
+        return null;
+    const width = typeof door.width === 'number' && door.width > 0 ? door.width : 0.9;
+    const localX = Array.isArray(door.position) ? (door.position[0] ?? length / 2) : length / 2;
+    const [sx, sz] = wall.start;
+    const [ex, ez] = wall.end;
+    const dx = (ex - sx) / length;
+    const dz = (ez - sz) / length;
+    const nx = -dz;
+    const nz = dx;
+    const half = width / 2 + sidePad;
+    const corners = [];
+    for (const along of [localX - half, localX + half]) {
+        const cx = sx + dx * along;
+        const cz = sz + dz * along;
+        for (const side of [-clearDepth, clearDepth]) {
+            corners.push([cx + nx * side, cz + nz * side]);
+        }
+    }
+    const xs = corners.map((c) => c[0]);
+    const zs = corners.map((c) => c[1]);
+    return {
+        doorId: door.id,
+        wallId: wall.id,
+        levelId: options?.levelId ?? null,
+        width,
+        localX,
+        aabb: {
+            minX: Math.min(...xs),
+            maxX: Math.max(...xs),
+            minZ: Math.min(...zs),
+            maxZ: Math.max(...zs),
+        },
+    };
+}
+export function collectDoorKeepouts(nodes, options) {
+    const byId = new Map();
+    for (const node of nodes)
+        byId.set(node.id, node);
+    const keepouts = [];
+    for (const node of byId.values()) {
+        if (node.type !== 'door')
+            continue;
+        const wallId = node.wallId ?? node.parentId;
+        if (!wallId)
+            continue;
+        const wall = byId.get(wallId);
+        if (wall?.type !== 'wall')
+            continue;
+        const levelId = resolveNodeLevelId(wall.id, byId) ?? resolveNodeLevelId(node.id, byId);
+        if (options?.levelId && levelId !== options.levelId)
+            continue;
+        const keepout = doorKeepoutFromWall(wall, node, {
+            clearDepth: options?.clearDepth,
+            sidePad: options?.sidePad,
+            levelId,
+        });
+        if (keepout)
+            keepouts.push(keepout);
+    }
+    return keepouts;
+}
+export function itemBlocksDoorKeepout(itemAabb, keepout) {
+    return aabbsOverlap(itemAabb, keepout.aabb, 0.02);
+}
+export function findBlockedDoors(args) {
+    const nodes = [...args.nodes];
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const keepouts = collectDoorKeepouts(nodes, {
+        clearDepth: args.clearDepth,
+        sidePad: args.sidePad,
+        levelId: args.levelId,
+    });
+    if (keepouts.length === 0)
+        return [];
+    const issues = [];
+    for (const node of nodes) {
+        if (node.type !== 'item')
+            continue;
+        const itemLevel = resolveNodeLevelId(node.id, byId);
+        if (args.levelId && itemLevel !== args.levelId)
+            continue;
+        const aabb = itemNodePlanAabb(node);
+        if (!aabb)
+            continue;
+        for (const keepout of keepouts) {
+            // Same-level only (multi-story safety).
+            if (keepout.levelId && itemLevel && keepout.levelId !== itemLevel)
+                continue;
+            if (args.levelId && keepout.levelId && keepout.levelId !== args.levelId)
+                continue;
+            if (!itemBlocksDoorKeepout(aabb, keepout))
+                continue;
+            const itemName = node.name ?? node.asset?.name ?? node.id;
+            issues.push({
+                doorId: keepout.doorId,
+                wallId: keepout.wallId,
+                itemId: node.id,
+                levelId: itemLevel,
+                itemName: typeof itemName === 'string' ? itemName : undefined,
+                message: `Door ${keepout.doorId} on wall ${keepout.wallId} is blocked by item ${itemName} (${node.id})`,
+            });
+        }
+    }
+    return issues;
+}
+/**
+ * Synthetic keep-outs for a room polygon edge that will host a door (before doors exist).
+ * Used by furnish_room when doorWallIndex is known.
+ */
+export function keepoutForPolygonEdge(polygon, edgeIndex, options) {
+    if (polygon.length < 3)
+        return null;
+    const i = ((edgeIndex % polygon.length) + polygon.length) % polygon.length;
+    const start = polygon[i];
+    const end = polygon[(i + 1) % polygon.length];
+    const wall = {
+        id: `edge-${i}`,
+        start,
+        end,
+    };
+    const length = wallLength(wall);
+    if (length <= 1e-6)
+        return null;
+    const width = options?.width ?? 0.9;
+    const t = options?.t ?? 0.5;
+    const localX = Math.min(Math.max(t * length, width / 2), length - width / 2);
+    const keepout = doorKeepoutFromWall(wall, {
+        id: `planned-door-${i}`,
+        position: [localX, 1.05, 0],
+        width,
+    }, { clearDepth: options?.clearDepth, sidePad: options?.sidePad });
+    return keepout?.aabb ?? null;
+}
+/**
+ * Whether an existing keep-out already covers this room-edge planned zone
+ * (so we do not double-count a real door on that edge).
+ *
+ * Requires the planned keep-out **center** to lie inside the existing keep-out,
+ * and the existing box to cover a large fraction of the planned area.
+ * Plain AABB overlap is not enough (nearby hallway doors must not suppress
+ * this room's entrance keep-out).
+ */
+export function keepoutCoversPlanned(existing, planned) {
+    const cx = (planned.minX + planned.maxX) / 2;
+    const cz = (planned.minZ + planned.maxZ) / 2;
+    const centerInside = cx >= existing.minX && cx <= existing.maxX && cz >= existing.minZ && cz <= existing.maxZ;
+    if (!centerInside)
+        return false;
+    // Intersection area / planned area must be substantial (same opening, not a glancing touch).
+    const ix0 = Math.max(existing.minX, planned.minX);
+    const ix1 = Math.min(existing.maxX, planned.maxX);
+    const iz0 = Math.max(existing.minZ, planned.minZ);
+    const iz1 = Math.min(existing.maxZ, planned.maxZ);
+    if (ix1 <= ix0 || iz1 <= iz0)
+        return false;
+    const inter = (ix1 - ix0) * (iz1 - iz0);
+    const plannedArea = Math.max(1e-9, (planned.maxX - planned.minX) * (planned.maxZ - planned.minZ));
+    return inter / plannedArea >= 0.5;
+}
+export function aabbFromPlan(a) {
+    return a;
+}

package/dist/agent-operations/duplicate-level.d.ts

@@ -0,0 +1,12 @@
+import { type LevelDuplicatePreset } from '../building/level-duplication.js';
+import type { AgentOperation } from './types.js';
+type DuplicateLevelInput = {
+    levelId?: string;
+    position?: 'above' | 'below';
+    name?: string;
+    preset?: LevelDuplicatePreset;
+};
+/** `duplicate_level`: the editor's level duplication, above or below the original. */
+export declare const duplicateLevel: AgentOperation<DuplicateLevelInput>;
+export {};
+//# sourceMappingURL=duplicate-level.d.ts.map

package/dist/agent-operations/duplicate-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-level.d.ts","sourceRoot":"","sources":["../../src/agent-operations/duplicate-level.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,oBAAoB,EAE1B,MAAM,+BAA+B,CAAA;AAKtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,KAAK,mBAAmB,GAAG;IACzB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,oBAAoB,CAAA;CAC9B,CAAA;AAQD,sFAAsF;AACtF,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,mBAAmB,CA6C9D,CAAA"}

package/dist/agent-operations/duplicate-level.js

@@ -0,0 +1,54 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { buildLevelDuplicateCreateOps, levelBuildingId, } from '../building/level-duplication.js';
+import { getLevelDisplayName } from '../lib/level-name.js';
+import { requireLevel } from './level-target.js';
+import { levelsOf } from './scene-queries.js';
+const countByType = (nodes) => {
+    const counts = {};
+    for (const node of nodes)
+        counts[node.type] = (counts[node.type] ?? 0) + 1;
+    return counts;
+};
+/** `duplicate_level`: the editor's level duplication, above or below the original. */
+export const duplicateLevel = (nodes, input, context) => {
+    const levelId = input.levelId ?? context.activeLevelId;
+    if (!levelId)
+        refuse('level_required', 'Say which level to copy: a levelId from list_levels.');
+    const level = requireLevel(nodes, levelId);
+    const all = nodes;
+    const buildingId = levelBuildingId(all, level);
+    const building = buildingId ? nodes[buildingId] : undefined;
+    if (building?.type !== 'building')
+        refuse('no_building', `Level ${levelId} is not in a building, so it has no floors to join.`, {
+            levelId,
+        });
+    const { createOps, newLevelId, shiftedLevels, updateOps, skippedNodes } = buildLevelDuplicateCreateOps({
+        nodes: all,
+        level,
+        levels: levelsOf(nodes).filter((entry) => entry.parentId === building.id || building.children.includes(entry.id)),
+        preset: input.preset ?? 'everything',
+        position: input.position ?? 'above',
+    });
+    const create = createOps.map(({ node, parentId }) => ({
+        node: node.id === newLevelId && input.name ? { ...node, name: input.name } : node,
+        parentId,
+    }));
+    const copy = create.find(({ node }) => node.id === newLevelId).node;
+    return {
+        result: {
+            newLevelId,
+            name: getLevelDisplayName(copy),
+            floorIndex: copy.level,
+            shiftedLevelIds: shiftedLevels.map((entry) => entry.id),
+            copied: countByType(create.map(({ node }) => node)),
+            skipped: countByType(skippedNodes),
+            // Counts are in `copied`; a floor copy is hundreds of ids the model reads back every call.
+            newNodeIds: create.slice(0, 40).map(({ node }) => node.id),
+            ...(create.length > 40 ? { newNodeIdsOmitted: create.length - 40 } : {}),
+        },
+        changes: {
+            create,
+            update: updateOps,
+        },
+    };
+};

package/dist/agent-operations/find-by-type.d.ts

@@ -0,0 +1,11 @@
+import type { AgentOperation } from './types.js';
+/**
+ * `find_by_type`: everything of one type, nodes and the typed parts of
+ * authored objects alike. Parts are read from each object's manifest; the
+ * object stays the thing that is selected, moved and edited.
+ */
+export declare const findByType: AgentOperation<{
+    type: string;
+    levelId?: string;
+}>;
+//# sourceMappingURL=find-by-type.d.ts.map

package/dist/agent-operations/find-by-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-by-type.d.ts","sourceRoot":"","sources":["../../src/agent-operations/find-by-type.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAyC7C;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CA2DzE,CAAA"}

package/dist/agent-operations/find-by-type.js

@@ -0,0 +1,94 @@
+import { isScriptedNode } from '../lib/geometry-script-node.js';
+import { requireLevel } from './level-target.js';
+import { levelIdOf } from './scene-queries.js';
+const round = (v) => Math.round(v * 1000) / 1000;
+/** A point in an item's frame, in its level's frame (items on a level: position + yaw). */
+function toLevel(item, [x, y, z]) {
+    const yaw = item.rotation[1] ?? 0;
+    const [sx, sy, sz] = item.scale;
+    const lx = x * sx;
+    const lz = z * sz;
+    return [
+        round(item.position[0] + Math.cos(yaw) * lx + Math.sin(yaw) * lz),
+        round(item.position[1] + y * sy),
+        round(item.position[2] - Math.sin(yaw) * lx + Math.cos(yaw) * lz),
+    ];
+}
+function boundsInLevel(item, bounds) {
+    const corners = [];
+    for (const x of [bounds.min[0], bounds.max[0]])
+        for (const y of [bounds.min[1], bounds.max[1]])
+            for (const z of [bounds.min[2], bounds.max[2]])
+                corners.push(toLevel(item, [x, y, z]));
+    return {
+        min: [0, 1, 2].map((k) => Math.min(...corners.map((c) => c[k]))),
+        max: [0, 1, 2].map((k) => Math.max(...corners.map((c) => c[k]))),
+    };
+}
+const emitsLight = (node) => node.type === 'item' &&
+    Boolean(node.asset.interactive?.effects.some((effect) => effect.kind === 'light'));
+const matchesWord = (text, word) => Boolean(text) &&
+    text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .includes(word);
+/**
+ * `find_by_type`: everything of one type, nodes and the typed parts of
+ * authored objects alike. Parts are read from each object's manifest; the
+ * object stays the thing that is selected, moved and edited.
+ */
+export const findByType = (nodes, { type, levelId }) => {
+    // A level that is not there is said, as get_zones says it, not answered with nothing found.
+    if (levelId)
+        requireLevel(nodes, levelId);
+    const word = type.trim().toLowerCase().replace(/s$/, '');
+    const results = [];
+    for (const node of Object.values(nodes)) {
+        const level = levelIdOf(nodes, node.id);
+        if (levelId && level !== levelId)
+            continue;
+        const item = node.type === 'item' ? node : null;
+        const typed = (isScriptedNode(node) ? node.source.manifest.parts : []).filter((part) => part.type);
+        const typedParts = typed.filter((part) => part.type === word);
+        // An authored item whose typed parts are all of this type is one (a
+        // lantern); a mixed one (a porch), or a window, door or column, answers
+        // with its parts.
+        const wholeAuthored = item !== null && typedParts.length > 0 && typedParts.length === typed.length;
+        const wholeMatch = node.type === word ||
+            wholeAuthored ||
+            (item &&
+                (matchesWord(item.asset.category, word) ||
+                    (word === 'light' && emitsLight(node) && typedParts.length === 0)));
+        if (wholeMatch) {
+            results.push({
+                id: node.id,
+                name: node.name ?? item?.asset.name,
+                nodeType: node.type,
+                levelId: level,
+            });
+            continue;
+        }
+        for (const part of typedParts) {
+            results.push({
+                id: node.id,
+                name: node.name ?? item?.asset.name,
+                nodeType: node.type,
+                levelId: level,
+                part: part.id,
+                partType: part.type,
+                ...(part.bounds && item && item.parentId === level
+                    ? { bounds: boundsInLevel(item, part.bounds) }
+                    : {}),
+            });
+        }
+    }
+    return {
+        result: {
+            type: word,
+            count: results.length,
+            nodes: results.filter((entry) => !entry.part).length,
+            parts: results.filter((entry) => entry.part).length,
+            results,
+        },
+    };
+};

package/dist/agent-operations/furnish-room.d.ts

@@ -0,0 +1,18 @@
+import type { FURNISHED_ROOM_TYPES } from '../agent-tools/furnish-room.js';
+import { type LevelTargetInput } from './level-target.js';
+import type { AgentOperation } from './types.js';
+type RoomType = (typeof FURNISHED_ROOM_TYPES)[number];
+type FurnishRoomInput = LevelTargetInput & {
+    zoneId?: string;
+    polygon?: number[][];
+    roomType: RoomType;
+    doorWallIndex?: number;
+};
+/**
+ * `furnish_room`: a room type's pieces from the host's catalog, against the walls the door decides,
+ * each moved off door clear zones and other items or skipped with the reason. The door wall is the
+ * edge a door of the room stands on (found by position), else doorWallIndex, else edge 0.
+ */
+export declare const furnishRoom: AgentOperation<FurnishRoomInput>;
+export {};
+//# sourceMappingURL=furnish-room.d.ts.map

package/dist/agent-operations/furnish-room.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"furnish-room.d.ts","sourceRoot":"","sources":["../../src/agent-operations/furnish-room.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAavE,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AAGnE,OAAO,KAAK,EAAgB,cAAc,EAAc,MAAM,SAAS,CAAA;AAEvE,KAAK,QAAQ,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAA;AAErD,KAAK,gBAAgB,GAAG,gBAAgB,GAAG;IACzC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,CAAA;IACpB,QAAQ,EAAE,QAAQ,CAAA;IAClB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAkND;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,gBAAgB,CA8ExD,CAAA"}