@pascal-app/core 1.0.6 → 1.1.0

package/dist/agent-operations/room-readings.js

@@ -0,0 +1,369 @@
+import { foldRoomName, isOutdoorRoom, isWetRoomUse, roomUseOfName, } from '../building/room-use.js';
+import { getLevelDisplayName } from '../lib/level-name.js';
+import { area, intersection, union } from '../lib/polygon-boolean.js';
+import { roomDrawnFloor } from '../lib/room-drawn-floor.js';
+import { roomFloorPlate } from '../lib/room-floor-plate.js';
+import { getScaledDimensions, getWallTrimFaces, } from '../schema/index.js';
+import { getWallZoneSpans } from '../systems/wall/wall-finish.js';
+import { itemLevelPose } from './item-space.js';
+import { pointInPolygon } from './plan-geometry.js';
+import { roomWallFaces } from './room-faces.js';
+import { describeFinish, isDefaultFinish, roomFinishes } from './room-finishes.js';
+import { finishTiled } from './room-tile.js';
+import { readWet } from './room-wet.js';
+import { levelsOf, nodesOnLevel, queryNodes } from './scene-queries.js';
+const strongest = (readings) => readings.includes('yes') ? 'yes' : readings.includes('unknown') ? 'unknown' : 'no';
+/** Tiled on the floor or on the walls; `unknown` while either surface cannot be read and none is tile. */
+export const roomTiled = (room) => strongest([room.floor.tiled, room.walls.tiled]);
+const finishWord = (fact) => fact.name;
+function readFloor(zone, shown, materials) {
+    const facts = [
+        shown.floor ?? { ref: null, name: 'default' },
+        ...(shown.floor?.regions?.map((region) => region.finish) ?? []),
+    ];
+    const readings = facts.map((fact) => finishTiled(fact, materials));
+    // A floor built by a script lays its own boards or tiles, and its words are not read here.
+    if (zone.floor?.script)
+        readings.push('unknown');
+    const base = facts[0];
+    return {
+        finish: finishWord(base),
+        tiled: strongest(readings),
+        fact: base,
+        atDefault: isDefaultFinish(base) && !zone.floor?.script,
+    };
+}
+const footprintOf = (node) => ({
+    outer: node.polygon,
+    holes: node.holes ?? [],
+});
+/** Whether anything is under a room: its own plate, the drawn slab its floor was taken from, or slabs under most of its footprint. */
+function floorHeld(nodes, zone) {
+    if (zone.floor?.support === 'open')
+        return true;
+    const slabs = queryNodes(nodes, { type: 'slab', parentId: zone.parentId }).filter((node) => node.visible !== false && node.support !== 'open');
+    if (roomFloorPlate(slabs, zone.id) || roomDrawnFloor(nodes, zone.id))
+        return true;
+    const room = footprintOf(zone);
+    const roomArea = area([room]);
+    return (roomArea > 1e-4 &&
+        area(intersection(room, union(slabs.map((slab) => footprintOf(slab))))) >= roomArea / 2);
+}
+/** The floor a room shows, and, for a room whose floor is a drawn slab, that slab's surface when the room itself chose none. */
+function floorOf(nodes, zone, shown, materials) {
+    const floor = readFloor(zone, shown, materials);
+    const drawn = floor.atDefault ? roomDrawnFloor(nodes, zone.id) : null;
+    const slab = drawn ? nodes[drawn.slabId] : undefined;
+    const underSlab = slab?.type === 'slab'
+        ? describeFinish(slab.slots?.surface ?? slab.material ?? slab.materialPreset, materials)
+        : undefined;
+    return {
+        ...floor,
+        atDefault: floor.atDefault && (!underSlab || isDefaultFinish(underSlab)),
+        held: floorHeld(nodes, zone),
+    };
+}
+/** The wall faces that look into a room: their finishes, and whether they carry skirting. */
+function readWalls(nodes, zone, shown, materials) {
+    const shownFacts = (shown.walls?.finishes ?? []).map((entry) => entry.finish);
+    const facts = new Map(shownFacts.map((fact) => [finishWord(fact), fact]));
+    const finishes = new Set(facts.keys());
+    const tiled = (shown.walls?.finishes ?? []).map((entry) => finishTiled(entry.finish, materials));
+    let faces = 0;
+    let withSkirting = 0;
+    const seen = new Set();
+    for (const { wallId, face } of roomWallFaces(nodes, zone)) {
+        if (seen.has(`${wallId}/${face}`))
+            continue;
+        seen.add(`${wallId}/${face}`);
+        const wall = nodes[wallId];
+        faces += 1;
+        if (wall.skirting?.enabled && getWallTrimFaces(wall.skirting.sides).includes(face))
+            withSkirting += 1;
+        for (const region of wall.faceRegions ?? []) {
+            if (region.face !== face)
+                continue;
+            const fact = describeFinish(region.finish, materials);
+            finishes.add(finishWord(fact));
+            facts.set(finishWord(fact), fact);
+            tiled.push(finishTiled(fact, materials));
+        }
+        if (wall.finishScripts?.[face])
+            tiled.push('unknown');
+    }
+    return {
+        walls: {
+            finishes: [...finishes],
+            // No wall faces known (a zone with no boundary walls) is not a wall read as bare.
+            tiled: faces ? strongest(tiled) : 'unknown',
+            faces,
+            facts: [...facts.values()],
+        },
+        skirting: { faces, withSkirting },
+    };
+}
+const fnv = (text) => {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < text.length; index++) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(16).padStart(8, '0');
+};
+const round = (value) => typeof value === 'number' ? Math.round(value * 100) / 100 : value;
+/** A cabinet run's make-up, without where it stands: the same run laid elsewhere is the same design. */
+function runDesign(nodes, run) {
+    const modules = run.children.flatMap((id) => {
+        const module = nodes[id];
+        if (module?.type !== 'cabinet-module')
+            return [];
+        return [
+            [
+                module.moduleKind,
+                module.cabinetType,
+                round(module.width),
+                (module.stack ?? []).map((compartment) => compartment.type),
+            ],
+        ];
+    });
+    return fnv(JSON.stringify([run.frontStyle, run.handleStyle, run.runTier, modules]));
+}
+/** Where a catalog or scripted item stands in its level's plan, or the room it is already in. */
+function placeItem(nodes, byId, item, roomsOnLevel) {
+    let attached = item;
+    let root = item.parentId ? nodes[item.parentId] : undefined;
+    while (root?.type === 'item') {
+        attached = root;
+        root = root.parentId ? nodes[root.parentId] : undefined;
+    }
+    if (!root)
+        return null;
+    if (root.type === 'ceiling' && root.zoneId && roomsOnLevel.some((z) => z.id === root.zoneId))
+        return { zoneId: root.zoneId };
+    if (root.type === 'wall')
+        return placeOnWall(attached, root, roomsOnLevel);
+    if (root.type !== 'level' && root.type !== 'slab' && root.type !== 'ceiling')
+        return null;
+    const pose = itemLevelPose(item, byId);
+    return pose ? { point: [pose.position[0], pose.position[2]] } : null;
+}
+/** An item hosted on a wall belongs to the room whose face it is on, at its station along the wall. */
+function placeOnWall(item, wall, roomsOnLevel) {
+    const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    if (!(length > 0))
+        return null;
+    const station = (item.position[0] ?? 0) / length;
+    const faces = item.side === 'front' ? ['a'] : item.side === 'back' ? ['b'] : ['a', 'b'];
+    for (const face of faces)
+        for (const zone of roomsOnLevel) {
+            const span = getWallZoneSpans(wall, [zone]).find((s) => s.face === face && station >= s.t0 - 1e-6 && station <= s.t1 + 1e-6);
+            if (span)
+                return { zoneId: zone.id, hung: { wallId: wall.id, face, u: item.position[0] ?? 0 } };
+        }
+    return null;
+}
+const planArea = (zone) => Math.abs(zone.polygon.reduce((sum, [x, z], index) => {
+    const next = zone.polygon[(index + 1) % zone.polygon.length];
+    return sum + x * next[1] - next[0] * z;
+}, 0)) / 2;
+/** The room whose plan holds a point; the smallest when rooms overlap (a landing inside a hall). */
+function roomAt(point, rooms) {
+    return rooms
+        .filter((zone) => pointInPolygon(point, zone.polygon) &&
+        !(zone.holes ?? []).some((hole) => pointInPolygon(point, hole, false)))
+        .sort((a, b) => planArea(a) - planArea(b))[0];
+}
+/** An authored item's size to 5 cm and its finishes, which two scripts' pieces can share. */
+function itemLook(item) {
+    const size = getScaledDimensions(item)
+        .map((metres) => (Math.round(metres / 0.05) * 0.05).toFixed(2))
+        .join('x');
+    const finishes = Object.entries(item.slots ?? {}).sort(([a], [b]) => a.localeCompare(b));
+    return `${size}|${JSON.stringify(finishes)}`;
+}
+const GENERIC_CATEGORIES = new Set([
+    '',
+    'furniture',
+    'decor',
+    'decoration',
+    'object',
+    'item',
+    'other',
+    'misc',
+    'custom',
+    'accessory',
+    'accessories',
+]);
+/** Words of a name, accents folded; the digits and the words of the room are what a piece is not. */
+const wordsOf = (text) => foldRoomName(text)
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+/** Two words are one when equal or when long enough to share five letters ("parental", "parentale"). */
+const sameWord = (a, b) => a === b || (a.length >= 5 && b.length >= 5 && a.slice(0, 5) === b.slice(0, 5));
+/**
+ * What a piece is: its category, or, where the author gave only "furniture", its name without its
+ * room's words and numbers ("Lit Chambre 3" and "Lit Chambre 4" are both a "lit").
+ */
+function pieceKind(category, name, roomName) {
+    if (!GENERIC_CATEGORIES.has(foldRoomName(category)))
+        return category;
+    const room = wordsOf(roomName).filter((word) => word.length >= 3);
+    const kept = wordsOf(name).filter((word) => !/^\d+$/.test(word) && !room.some((other) => sameWord(word, other)));
+    return kept.join(' ') || 'piece';
+}
+/** The pieces standing in each room: catalog and scripted items, cabinet runs and shelves. */
+function readPieces(nodes, rooms) {
+    const byLevel = new Map();
+    for (const zone of rooms) {
+        const list = byLevel.get(zone.parentId ?? '') ?? [];
+        list.push(zone);
+        byLevel.set(zone.parentId ?? '', list);
+    }
+    // biome-ignore lint/plugin: every piece, of any kind, is filed under the room it stands in
+    const byId = new Map(Object.entries(nodes));
+    const found = new Map();
+    const put = (zoneId, piece) => found.set(zoneId, [...(found.get(zoneId) ?? []), piece]);
+    // biome-ignore lint/plugin: every piece, of any kind, is filed under the room it stands in
+    for (const node of Object.values(nodes)) {
+        let placed = null;
+        if (node.type === 'item') {
+            const levelId = levelOfNode(nodes, node);
+            const here = byLevel.get(levelId ?? '') ?? [];
+            const where = here.length ? placeItem(nodes, byId, node, here) : null;
+            if (where)
+                placed = {
+                    piece: {
+                        id: node.id,
+                        category: node.asset.category,
+                        design: node.source?.script ? `script:${node.source.script}` : node.asset.id,
+                        ...(node.source ? { look: itemLook(node) } : {}),
+                        name: node.name ?? node.asset.name,
+                        ...(where.hung ? { hung: where.hung } : {}),
+                    },
+                    point: where.point ?? null,
+                    zoneId: where.zoneId,
+                };
+        }
+        else if (node.type === 'procedural-item') {
+            // A design placed with place_design: on the floor, a slab or a ceiling, or hung on a wall.
+            const parent = node.parentId ? nodes[node.parentId] : undefined;
+            const here = byLevel.get(levelOfNode(nodes, node) ?? '') ?? [];
+            const where = parent?.type === 'wall'
+                ? placeOnWall(node, parent, here)
+                : parent?.type === 'level' || parent?.type === 'slab' || parent?.type === 'ceiling'
+                    ? { point: [node.position[0], node.position[2]] }
+                    : null;
+            if (where)
+                placed = {
+                    piece: {
+                        id: node.id,
+                        category: node.recipe.name,
+                        design: `recipe:${fnv(JSON.stringify(node.recipe))}`,
+                        name: node.name ?? node.recipe.name,
+                        ...('hung' in where && where.hung ? { hung: where.hung } : {}),
+                    },
+                    point: 'point' in where ? where.point : null,
+                    zoneId: 'zoneId' in where ? where.zoneId : undefined,
+                };
+        }
+        else if (node.type === 'cabinet' || node.type === 'shelf') {
+            if (node.parentId && nodes[node.parentId]?.type === 'level')
+                placed = {
+                    piece: {
+                        id: node.id,
+                        category: node.type === 'cabinet' ? 'cabinet-run' : 'shelf',
+                        design: node.type === 'cabinet'
+                            ? runDesign(nodes, node)
+                            : fnv(JSON.stringify([node.style, node.rows, node.columns, round(node.width)])),
+                        name: node.name ?? node.type,
+                    },
+                    point: [node.position[0], node.position[2]],
+                };
+        }
+        if (!placed)
+            continue;
+        const here = byLevel.get(levelOfNode(nodes, node) ?? '') ?? [];
+        const zoneId = placed.zoneId ?? (placed.point ? roomAt(placed.point, here)?.id : undefined);
+        if (zoneId)
+            put(zoneId, placed.piece);
+    }
+    return found;
+}
+function levelOfNode(nodes, node) {
+    const seen = new Set();
+    let at = node;
+    while (at && !seen.has(at.id)) {
+        if (at.type === 'level')
+            return at.id;
+        seen.add(at.id);
+        at = at.parentId ? nodes[at.parentId] : undefined;
+    }
+    return null;
+}
+/** Room contents and openings along its wall spans, including either side of a shared doorway. */
+export function roomIssueScope(nodes, requested) {
+    const wanted = requested.trim().toLowerCase();
+    const zones = queryNodes(nodes, { type: 'zone' });
+    const matched = zones.filter((zone) => zone.id.toLowerCase() === wanted || zone.name.trim().toLowerCase() === wanted);
+    if (!matched.length)
+        return [];
+    const pieces = readPieces(nodes, zones);
+    return matched.map((zone) => {
+        const nodeIds = new Set([zone.id, ...(pieces.get(zone.id) ?? []).map((piece) => piece.id)]);
+        for (const opening of queryNodes(nodes, {
+            type: ['door', 'window'],
+        })) {
+            const wall = nodes[opening.parentId ?? ''];
+            if (wall?.type !== 'wall' || levelOfNode(nodes, wall) !== zone.parentId)
+                continue;
+            const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+            if (!(length > 0))
+                continue;
+            const station = opening.position[0] / length;
+            // Drawn rooms can lack derived boundary IDs; the wall-facing span still establishes ownership.
+            if (getWallZoneSpans(wall, [{ ...zone, boundaryWallIds: [wall.id] }]).some((span) => station >= span.t0 - 1e-6 && station <= span.t1 + 1e-6))
+                nodeIds.add(opening.id);
+        }
+        return { roomId: zone.id, room: zone.name, nodeIds: [...nodeIds] };
+    });
+}
+/**
+ * Every room of the scene (a zone that is a room and has a floor) as the checks read it, in level
+ * order then by name. `materials` are the scene's, when the host has them, to name `scene:` finishes.
+ */
+export function readRooms(nodes, options = {}) {
+    const { materials } = options;
+    const rooms = [];
+    for (const level of levelsOf(nodes)) {
+        const levelName = getLevelDisplayName(level);
+        for (const node of nodesOnLevel(nodes, level.id))
+            if (node.type === 'zone' && node.spaceRole === 'room' && node.hasFloor !== false)
+                rooms.push({ zone: node, levelName });
+    }
+    // biome-ignore lint/plugin: every piece, of any kind, is filed under the room it stands in
+    const byId = new Map(Object.entries(nodes));
+    const pieces = readPieces(nodes, rooms.map(({ zone }) => zone));
+    return rooms.map(({ zone, levelName }) => {
+        const content = nodesOnLevel(nodes, zone.parentId ?? '');
+        const shown = roomFinishes(nodes, zone, content, materials);
+        const { walls, skirting } = readWalls(nodes, zone, shown, materials);
+        const use = roomUseOfName(zone.name);
+        const roomPieces = (pieces.get(zone.id) ?? []).map(({ category, ...piece }) => ({
+            ...piece,
+            kind: pieceKind(category, piece.name, zone.name),
+        }));
+        return {
+            id: zone.id,
+            name: zone.name,
+            levelId: zone.parentId ?? '',
+            levelName,
+            use,
+            indoor: !isOutdoorRoom(zone),
+            floor: floorOf(nodes, zone, shown, materials),
+            walls,
+            ...(isWetRoomUse(use) ? { wet: readWet(nodes, byId, zone, roomPieces, materials) } : {}),
+            skirting,
+            pieces: roomPieces,
+        };
+    });
+}

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

@@ -0,0 +1,15 @@
+import type { SceneMaterial } from '../schema/index.js';
+import type { FinishFact } from './room-finishes.js';
+/** `unknown` is a finish the nodes cannot name (an inline material, a scene ref with no scene
+ *  materials at hand, a script-built face): a check never fires on what it cannot read. */
+export type Tiled = 'yes' | 'no' | 'unknown';
+type Materials = Readonly<Record<string, SceneMaterial>> | undefined;
+/**
+ * Whether one finish is tile: the library's own kind, else its words. "Stone Tile" is filed under
+ * stone and "Statuaretto White" (white marble flooring) under stone too, so the kind alone misses
+ * both. A material the maker generated is read from what it is made of, as its name may say
+ * anything: a tile or marble preset is tile, a flat colour is paint, and a texture could be either.
+ */
+export declare function finishTiled(fact: FinishFact, materials?: Materials): Tiled;
+export {};
+//# sourceMappingURL=room-tile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"room-tile.d.ts","sourceRoot":"","sources":["../../src/agent-operations/room-tile.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAEjD;2FAC2F;AAC3F,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,CAAA;AAE5C,KAAK,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,GAAG,SAAS,CAAA;AAKpE;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,KAAK,CAc1E"}

package/dist/agent-operations/room-tile.js

@@ -0,0 +1,30 @@
+import { foldRoomName } from '../building/room-use.js';
+import { getSceneMaterialIdFromRef } from '../material-library.js';
+const TILE_WORDS = /tile|ceramic|cerame|mosaic|mosaique|terracotta|terre cuite|tomette|zellige|azulejo|porcelain|\bgres\b|marble|statuar|carrel|carreau|faience|marbre/;
+/**
+ * Whether one finish is tile: the library's own kind, else its words. "Stone Tile" is filed under
+ * stone and "Statuaretto White" (white marble flooring) under stone too, so the kind alone misses
+ * both. A material the maker generated is read from what it is made of, as its name may say
+ * anything: a tile or marble preset is tile, a flat colour is paint, and a texture could be either.
+ */
+export function finishTiled(fact, materials) {
+    if (fact.ref === null)
+        return fact.name === 'default' ? 'no' : 'unknown';
+    if (fact.kind === 'tile')
+        return 'yes';
+    // A written colour (#rrggbb, what a dressing layer paints with) is flat paint.
+    if (/^#[0-9a-f]{6}$/i.test(fact.ref))
+        return 'no';
+    if (TILE_WORDS.test(foldRoomName(`${fact.name} ${fact.ref}`)))
+        return 'yes';
+    const sceneId = getSceneMaterialIdFromRef(fact.ref);
+    if (sceneId) {
+        const made = materials?.[sceneId]?.material;
+        if (!made)
+            return 'unknown';
+        if (made.preset === 'tile' || made.preset === 'marble')
+            return 'yes';
+        return made.texture ? 'unknown' : 'no';
+    }
+    return fact.name === fact.ref ? 'unknown' : 'no';
+}

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

@@ -0,0 +1,55 @@
+import type { AnyNode, SceneMaterial, ZoneNode } from '../schema/index.js';
+import { type RoomWallFace } from './room-faces.js';
+import type { RoomPiece } from './room-readings.js';
+import { type Tiled } from './room-tile.js';
+import type { SceneNodes } from './types.js';
+/**
+ * What a wet room is tiled to: a bathroom, shower room, WC or laundry counts tiled when the walls its
+ * fixtures stand against are tiled to `WET_TILED_TO_M`, and to the ceiling around its shower. The
+ * wall faces read are the stretches a shower, bath, basin or toilet stands against (within
+ * `STANDS_AGAINST_M` of the face), else, when none can be placed, every face of the room. A face is
+ * tiled to a height when tile covers at least `COVERED` of its stretch up to there; what covers it is
+ * read as the renderer layers it (the base finish, then the face's regions, a later one over an
+ * earlier). A face a script builds, or a finish the nodes cannot name, is `unknown`, and unknown
+ * never fails a room.
+ */
+/** A wet room's walls are tiled up to this, metres. */
+export declare const WET_TILED_TO_M = 1.2;
+/** The share of a face's stretch tile must cover to count as tiled there. */
+export declare const COVERED = 0.8;
+export type WetReading = {
+    /** True when the faces read are those fixtures stand against; false when every face was read. */
+    byFixtures: boolean;
+    /** The least height tile reaches over the faces read, covering 80% of each stretch, metres; null when unreadable. */
+    tiledTo: number | null;
+    /** Whether tile shows anywhere on those faces. */
+    anyTile: boolean;
+    /** Whether those faces are tiled to `WET_TILED_TO_M`. */
+    tiled: Tiled;
+    /** The showers standing against a wall, and whether tile reaches the ceiling around each. */
+    showers: {
+        id: string;
+        name: string;
+        full: Tiled;
+    }[];
+    /** `no` when the walls are short of the height or a shower's surround is: what the finding reads. */
+    verdict: Tiled;
+};
+/** Tile heights sampled along a stretch of a face: where the unbroken run from the floor ends at each point, and whether an unreadable finish stops it. */
+export type Read = {
+    tops: number[];
+    open: boolean[];
+};
+export declare function readStretch(nodes: SceneNodes, zone: ZoneNode, stretch: RoomWallFace, range: {
+    u0: number;
+    u1: number;
+}, materials: Readonly<Record<string, SceneMaterial>> | undefined): Read & {
+    height: number;
+};
+/** Whether tile covers 80% of the samples up to `target`: yes, no, or unknown where unreadable parts could. */
+export declare function reaches(read: Read, target: number): Tiled;
+/** The height 80% of the samples reach at least. */
+export declare const coveredTo: (read: Read) => number;
+/** A wet room's walls against what it is tiled to; undefined for a room with no wall face. */
+export declare function readWet(nodes: SceneNodes, byId: Map<string, AnyNode>, zone: ZoneNode, pieces: readonly RoomPiece[], materials: Readonly<Record<string, SceneMaterial>> | undefined): WetReading | undefined;
+//# sourceMappingURL=room-wet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"room-wet.d.ts","sourceRoot":"","sources":["../../src/agent-operations/room-wet.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAY,QAAQ,EAAE,MAAM,WAAW,CAAA;AAI3E,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,cAAc,CAAA;AAE/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,aAAa,CAAA;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC;;;;;;;;;GASG;AAEH,uDAAuD;AACvD,eAAO,MAAM,cAAc,MAAM,CAAA;AACjC,6EAA6E;AAC7E,eAAO,MAAM,OAAO,MAAM,CAAA;AA0D1B,MAAM,MAAM,UAAU,GAAG;IACvB,iGAAiG;IACjG,UAAU,EAAE,OAAO,CAAA;IACnB,qHAAqH;IACrH,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,kDAAkD;IAClD,OAAO,EAAE,OAAO,CAAA;IAChB,yDAAyD;IACzD,KAAK,EAAE,KAAK,CAAA;IACZ,6FAA6F;IAC7F,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,CAAA;KAAE,EAAE,CAAA;IACpD,qGAAqG;IACrG,OAAO,EAAE,KAAK,CAAA;CACf,CAAA;AA4DD,2JAA2J;AAC3J,MAAM,MAAM,IAAI,GAAG;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,CAAA;AAEtD,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EACjC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,GAAG,SAAS,GAC7D,IAAI,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAS3B;AAED,+GAA+G;AAC/G,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,CAMzD;AAED,oDAAoD;AACpD,eAAO,MAAM,SAAS,SAAU,IAAI,WAErB,CAAA;AAqCf,8FAA8F;AAC9F,wBAAgB,OAAO,CACrB,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1B,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,GAAG,SAAS,GAC7D,UAAU,GAAG,SAAS,CAoCxB"}