@pascal-app/core 1.0.4 → 1.0.5

package/dist/services/roof-level.d.ts

@@ -0,0 +1,121 @@
+import { type AnyNode, LevelNode, type RoofNode } from '../schema/index.js';
+/**
+ * Roofs and levels, one rule for every path that writes a roof (the editor's roof tool, the
+ * agents' create_roof, plugins): a roof lives on the level directly above the storey whose walls
+ * carry it. Over a building's top storey that is the building's roof level, kept above every
+ * storey, so exploded and solo level views lift the roof off the plan.
+ */
+type Nodes = Readonly<Record<string, AnyNode>>;
+/**
+ * Whether a node of this kind belongs on a storey, never on a roof level: a storey's structure and
+ * rooms, and every kind that stands on a floor (`capabilities.floorPlaced`: cabinets, shelves,
+ * columns, …).
+ */
+export declare const isStoreyContent: (type: string | undefined, metadata: Record<string, unknown> | undefined) => boolean;
+/** Retained roof geometry participates in level presentation without becoming parametric. */
+export declare const isRoofGeometry: (node: AnyNode | undefined) => boolean;
+/** Retained ceiling shells can lift with the roof while native room ceilings keep their hosts. */
+export declare const isCeilingGeometry: (node: AnyNode | undefined) => boolean;
+/** A level declared for its building's roofs (`metadata.role: 'roof'`). */
+export declare function isRoofLevel(node: AnyNode | undefined): boolean;
+/**
+ * A level that is its building's roof level: declared, whatever it holds (`verify_scene` reports a
+ * declared one someone walled); or, in a building that declares none, a level holding roofs and
+ * nothing a storey holds (a roof level written before levels declared it) with only such levels
+ * above it. Never the lowest level, a carport's roof on its posts being its ground floor. A level
+ * holding only roofs under a storey, or beside a declared roof level, is a storey still to be built
+ * with a lower wing's roof on it: it takes walls. The one rule every reader of a level's role goes
+ * by (`list_levels`, `verify_scene`, the agents' refusals, the editor's level stack and tools).
+ */
+export declare function servesAsRoofLevel(nodes: Nodes, level: LevelNode): boolean;
+export type RoofLevelPlan = 
+/** A storey stands above: it takes a roof over part of the storey below. */
+({
+    kind: 'storey';
+    levelId: string;
+}
+/** The building's roof level, `create`d first when it has none, `update`d when undeclared. */
+ | {
+    kind: 'roof';
+    levelId: string;
+    create: LevelNode | null;
+    update: {
+        id: string;
+        data: Partial<LevelNode>;
+    }[];
+}) & {
+    /**
+     * The storey's floor from the target level's, once the plan is written (m, negative): a roof
+     * measured from the storey's floor sits its container this high on the target level.
+     */
+    storeyOffset: number;
+};
+/**
+ * The level that takes the roofs over `storeyId`'s walls, as the scene stands. With a storey built
+ * above (anything on it), the storey directly above takes the roof over part of the one below: a
+ * porch, a lower wing. Else the building's roof level, above every level still to be built and
+ * every support level: the roof level there; the empty level directly above when it is the only
+ * one; else none yet (`level` null). Reads only, so a panel can ask on every store change.
+ */
+export declare function roofLevelAbove(nodes: Nodes, storeyId: string): {
+    kind: 'storey';
+    level: LevelNode;
+} | {
+    kind: 'roof';
+    level: LevelNode | null;
+};
+/**
+ * Where a roof carried by `storeyId`'s walls lives (`roofLevelAbove`): the storey directly above,
+ * or the building's roof level, declared if it was not, else a new "Roof" level `roofHeight` tall
+ * (the roof's rise over its eaves) on top. Pure: the caller writes the plan in the same step as the
+ * roof.
+ */
+export declare function planRoofLevel(nodes: Nodes, storeyId: string, roofHeight: number): RoofLevelPlan;
+/**
+ * The storey a level stands for: for a level serving as a roof level, the storey it covers
+ * (`storeyUnder`); else the level itself. Where storey content aimed at a roof level goes.
+ */
+export declare function storeyOf(nodes: Nodes, levelId: string): string;
+/**
+ * The storey a roof covers. On a roof level, the storey under it (`storeyUnder`). On a storey, the
+ * storey below when the roof stands near its floor (a porch's or a lower wing's roof, seated on the
+ * walls under it, as the rule places it); else the storey itself (a roof written on its own walls'
+ * level, before roof levels). Null off a level.
+ */
+export declare function coveredStoreyId(nodes: Nodes, roof: RoofNode): string | null;
+/** The roofs over a storey, wherever they stand (`coveredStoreyId`). */
+export declare function roofsOver(nodes: Nodes, storeyId: string): RoofNode[];
+/**
+ * Where a new top storey of `buildingId` goes: on top of its storeys, under the roof levels at the
+ * top of its stack, which each move up one (`shift`), so the roof stays above every storey.
+ */
+export declare function storeyInsertIndex(nodes: Nodes, buildingId: string): {
+    floorIndex: number;
+    shift: {
+        id: string;
+        data: Pick<LevelNode, 'level'>;
+    }[];
+};
+/**
+ * After a write that adds levels to `buildingId` (`before` to `after`), the floor indexes that keep
+ * its roof levels above every other level: the ones topping its stack before, and a roof level the
+ * write declares. An update per roof level that has to go up; none for a roof level in the middle
+ * of a stack, which a write that does not touch it leaves where it is.
+ */
+export declare function liftRoofLevels(before: Nodes, after: Nodes, buildingId: string): {
+    id: string;
+    data: Pick<LevelNode, 'level'>;
+}[];
+/**
+ * New floor indexes (`floors`: level id to its index) that put a building's roof level under one of
+ * its storeys it stood over: that pair, else null. Roles are read as the levels stand
+ * (`servesAsRoofLevel`), so an order a legacy stack already had passes, and so does one among
+ * storeys only. The one check every reorder goes by (the level selector, the chat's
+ * `reorder_level`, the capture app's REST reorder, `apply_patch`).
+ */
+export declare function roofLevelOrderBreach(nodes: Nodes, floors: ReadonlyMap<string, number>): {
+    roofId: string;
+    storeyId: string;
+} | null;
+export {};
+//# sourceMappingURL=roof-level.d.ts.map

package/dist/services/roof-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-level.d.ts","sourceRoot":"","sources":["../../src/services/roof-level.ts"],"names":[],"mappings":"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"}

package/dist/services/roof-level.js

@@ -0,0 +1,280 @@
+import { getDefaultLevelName, getLevelDisplayName } from '../lib/level-name.js';
+import { nodeRegistry } from '../registry/index.js';
+import { LevelNode } from '../schema/index.js';
+import { getLevelElevations } from './storey.js';
+/** What a storey holds and a roof level must not: its structure and rooms. */
+const STOREY_CONTENT = new Set([
+    'wall',
+    'zone',
+    'slab',
+    'ceiling',
+    'item',
+    'stair',
+]);
+/**
+ * Whether a node of this kind belongs on a storey, never on a roof level: a storey's structure and
+ * rooms, and every kind that stands on a floor (`capabilities.floorPlaced`: cabinets, shelves,
+ * columns, …).
+ */
+export const isStoreyContent = (type, metadata) => type !== undefined &&
+    !(type === 'item' && (metadata?.role === 'roof' || metadata?.role === 'ceiling')) &&
+    (STOREY_CONTENT.has(type) || nodeRegistry.get(type)?.capabilities?.floorPlaced !== undefined);
+/** Retained roof geometry participates in level presentation without becoming parametric. */
+export const isRoofGeometry = (node) => node?.type === 'roof' || (node?.type === 'item' && node.metadata?.role === 'roof');
+/** Retained ceiling shells can lift with the roof while native room ceilings keep their hosts. */
+export const isCeilingGeometry = (node) => node?.type === 'ceiling' || (node?.type === 'item' && node.metadata?.role === 'ceiling');
+/** A level declared for its building's roofs (`metadata.role: 'roof'`). */
+export function isRoofLevel(node) {
+    return node?.type === 'level' && node.metadata?.role === 'roof';
+}
+/** A level declared to carry structure, not rooms (`metadata.role: 'support'`). */
+const isSupportLevel = (level) => level.metadata?.role === 'support';
+const childrenOf = (nodes, level) => level.children.map((id) => nodes[id]).filter((child) => child !== undefined);
+/** A level holding roofs and nothing a storey holds, unless declared a support. */
+const holdsOnlyRoofs = (nodes, level) => {
+    if (isSupportLevel(level))
+        return false;
+    const children = childrenOf(nodes, level);
+    return (children.some(isRoofGeometry) &&
+        !children.some((child) => isStoreyContent(child.type, child.metadata)));
+};
+/** A building's levels: those it lists, and those naming it as their parent. */
+function levelsOf(nodes, buildingId) {
+    const building = buildingId ? nodes[buildingId] : undefined;
+    const listed = new Set(building?.type === 'building' ? building.children : []);
+    return Object.values(nodes).filter((node) => node.type === 'level' && (node.parentId === (buildingId ?? null) || listed.has(node.id)));
+}
+/**
+ * A level that is its building's roof level: declared, whatever it holds (`verify_scene` reports a
+ * declared one someone walled); or, in a building that declares none, a level holding roofs and
+ * nothing a storey holds (a roof level written before levels declared it) with only such levels
+ * above it. Never the lowest level, a carport's roof on its posts being its ground floor. A level
+ * holding only roofs under a storey, or beside a declared roof level, is a storey still to be built
+ * with a lower wing's roof on it: it takes walls. The one rule every reader of a level's role goes
+ * by (`list_levels`, `verify_scene`, the agents' refusals, the editor's level stack and tools).
+ */
+export function servesAsRoofLevel(nodes, level) {
+    if (isRoofLevel(level))
+        return true;
+    if (!holdsOnlyRoofs(nodes, level))
+        return false;
+    const stack = levelsOf(nodes, level.parentId);
+    return (!stack.some(isRoofLevel) &&
+        stack.some((other) => other.level < level.level) &&
+        stack.every((other) => other.level <= level.level || holdsOnlyRoofs(nodes, other)));
+}
+const elevationsOf = (nodes) => getLevelElevations(nodes);
+/** The other levels of a level's building, in stack order, below it or above it. */
+function stackOf(nodes, levelId, side) {
+    const elevations = elevationsOf(nodes);
+    const own = elevations.get(levelId);
+    if (!own)
+        return [];
+    return [...elevations]
+        .filter(([, entry]) => entry.buildingId === own.buildingId &&
+        (side === 'above' ? entry.ordinal > own.ordinal : entry.ordinal < own.ordinal))
+        .sort(([, a], [, b]) => (side === 'above' ? a.ordinal - b.ordinal : b.ordinal - a.ordinal))
+        .map(([id]) => nodes[id])
+        .filter((node) => node?.type === 'level');
+}
+/** How far `storeyId`'s floor sits from `levelId`'s (m): negative, the storey being below. */
+function storeyOffsetTo(nodes, storeyId, levelId) {
+    const elevations = elevationsOf(nodes);
+    return (elevations.get(storeyId)?.baseY ?? 0) - (elevations.get(levelId)?.baseY ?? 0);
+}
+/** A level reused as the roof level, declared when it was not. */
+function roofLevelPlan(nodes, storeyId, level) {
+    return {
+        kind: 'roof',
+        levelId: level.id,
+        storeyOffset: storeyOffsetTo(nodes, storeyId, level.id),
+        create: null,
+        update: isRoofLevel(level)
+            ? []
+            : [
+                {
+                    id: level.id,
+                    data: {
+                        metadata: { ...level.metadata, role: 'roof' },
+                        // A name a person gave stays; an unnamed level would read as a floor.
+                        name: getLevelDisplayName(level) === getDefaultLevelName(level.level)
+                            ? 'Roof'
+                            : level.name,
+                    },
+                },
+            ],
+    };
+}
+/**
+ * The level that takes the roofs over `storeyId`'s walls, as the scene stands. With a storey built
+ * above (anything on it), the storey directly above takes the roof over part of the one below: a
+ * porch, a lower wing. Else the building's roof level, above every level still to be built and
+ * every support level: the roof level there; the empty level directly above when it is the only
+ * one; else none yet (`level` null). Reads only, so a panel can ask on every store change.
+ */
+export function roofLevelAbove(nodes, storeyId) {
+    const above = stackOf(nodes, storeyId, 'above');
+    const isPlain = (level) => !servesAsRoofLevel(nodes, level) && !isSupportLevel(level);
+    // The roof stands on the storey directly above, an empty one still to be built included.
+    if (above.some((level) => isPlain(level) && level.children.length > 0))
+        return { kind: 'storey', level: above.find(isPlain) };
+    const top = above.filter((level) => !servesAsRoofLevel(nodes, level)).at(-1);
+    const roofLevel = above.find((level) => servesAsRoofLevel(nodes, level) && (!top || level.level > top.level));
+    if (roofLevel)
+        return { kind: 'roof', level: roofLevel };
+    if (above.length === 1 && isPlain(above[0]))
+        return { kind: 'roof', level: above[0] };
+    return { kind: 'roof', level: null };
+}
+/**
+ * Where a roof carried by `storeyId`'s walls lives (`roofLevelAbove`): the storey directly above,
+ * or the building's roof level, declared if it was not, else a new "Roof" level `roofHeight` tall
+ * (the roof's rise over its eaves) on top. Pure: the caller writes the plan in the same step as the
+ * roof.
+ */
+export function planRoofLevel(nodes, storeyId, roofHeight) {
+    const storey = nodes[storeyId];
+    if (storey?.type !== 'level')
+        throw Error(`${storeyId} is not a level`);
+    const target = roofLevelAbove(nodes, storeyId);
+    if (target.kind === 'storey')
+        return {
+            kind: 'storey',
+            levelId: target.level.id,
+            storeyOffset: storeyOffsetTo(nodes, storeyId, target.level.id),
+        };
+    if (target.level)
+        return roofLevelPlan(nodes, storeyId, target.level);
+    const top = stackOf(nodes, storeyId, 'above')
+        .filter((level) => !servesAsRoofLevel(nodes, level))
+        .at(-1);
+    const level = LevelNode.parse({
+        name: 'Roof',
+        parentId: storey.parentId,
+        level: (top ?? storey).level + 1,
+        height: Math.max(roofHeight, 0.2),
+        children: [],
+        metadata: { role: 'roof' },
+    });
+    return {
+        kind: 'roof',
+        levelId: level.id,
+        storeyOffset: storeyOffsetTo({ ...nodes, [level.id]: level }, storeyId, level.id),
+        create: level,
+        update: [],
+    };
+}
+/**
+ * The storey under a roof level: the highest below it that holds something (levels still to be
+ * built and support levels between are passed over), else the level directly below; the level
+ * itself with none below.
+ */
+function storeyUnder(nodes, level) {
+    const below = stackOf(nodes, level.id, 'below');
+    return (below.find((other) => !servesAsRoofLevel(nodes, other) && !isSupportLevel(other) && other.children.length > 0) ??
+        below[0] ??
+        level).id;
+}
+/**
+ * The storey a level stands for: for a level serving as a roof level, the storey it covers
+ * (`storeyUnder`); else the level itself. Where storey content aimed at a roof level goes.
+ */
+export function storeyOf(nodes, levelId) {
+    const level = nodes[levelId];
+    return level?.type === 'level' && servesAsRoofLevel(nodes, level)
+        ? storeyUnder(nodes, level)
+        : levelId;
+}
+/**
+ * The storey a roof covers. On a roof level, the storey under it (`storeyUnder`). On a storey, the
+ * storey below when the roof stands near its floor (a porch's or a lower wing's roof, seated on the
+ * walls under it, as the rule places it); else the storey itself (a roof written on its own walls'
+ * level, before roof levels). Null off a level.
+ */
+export function coveredStoreyId(nodes, roof) {
+    const level = roof.parentId ? nodes[roof.parentId] : undefined;
+    if (level?.type !== 'level')
+        return null;
+    if (servesAsRoofLevel(nodes, level))
+        return storeyUnder(nodes, level);
+    const below = stackOf(nodes, level.id, 'below');
+    if (!below.length)
+        return level.id;
+    const height = elevationsOf(nodes).get(level.id)?.height ?? 0;
+    return roof.position[1] < height / 2 ? below[0].id : level.id;
+}
+/** The roofs over a storey, wherever they stand (`coveredStoreyId`). */
+export function roofsOver(nodes, storeyId) {
+    return Object.values(nodes).filter((node) => node.type === 'roof' && coveredStoreyId(nodes, node) === storeyId);
+}
+/**
+ * The roof levels topping a building's stack (`servesAsRoofLevel`, which keeps an undeclared lowest
+ * level a storey), bottom up: a building whose only level is declared the roof level has that one.
+ */
+function topRoofLevels(nodes, buildingId) {
+    const levels = levelsOf(nodes, buildingId).sort((a, b) => a.level - b.level);
+    let top = levels.length;
+    while (top > 0 && servesAsRoofLevel(nodes, levels[top - 1]))
+        top--;
+    return levels.slice(top);
+}
+/**
+ * Where a new top storey of `buildingId` goes: on top of its storeys, under the roof levels at the
+ * top of its stack, which each move up one (`shift`), so the roof stays above every storey.
+ */
+export function storeyInsertIndex(nodes, buildingId) {
+    const roofLevels = topRoofLevels(nodes, buildingId);
+    if (!roofLevels.length) {
+        const levels = levelsOf(nodes, buildingId);
+        return {
+            floorIndex: levels.length ? Math.max(...levels.map((level) => level.level)) + 1 : 0,
+            shift: [],
+        };
+    }
+    return {
+        floorIndex: roofLevels[0].level,
+        shift: roofLevels.map((level) => ({ id: level.id, data: { level: level.level + 1 } })),
+    };
+}
+/**
+ * After a write that adds levels to `buildingId` (`before` to `after`), the floor indexes that keep
+ * its roof levels above every other level: the ones topping its stack before, and a roof level the
+ * write declares. An update per roof level that has to go up; none for a roof level in the middle
+ * of a stack, which a write that does not touch it leaves where it is.
+ */
+export function liftRoofLevels(before, after, buildingId) {
+    const ids = new Set(topRoofLevels(before, buildingId).map((level) => level.id));
+    const levels = levelsOf(after, buildingId);
+    for (const level of levels)
+        if (!before[level.id] && isRoofLevel(level))
+            ids.add(level.id);
+    const roofs = levels.filter((level) => ids.has(level.id)).sort((a, b) => a.level - b.level);
+    const others = levels.filter((level) => !ids.has(level.id));
+    if (!(roofs.length && others.length))
+        return [];
+    const top = Math.max(...others.map((level) => level.level));
+    return roofs.flatMap((level, i) => {
+        const floor = Math.max(level.level, top + 1 + i);
+        return floor === level.level ? [] : [{ id: level.id, data: { level: floor } }];
+    });
+}
+/**
+ * New floor indexes (`floors`: level id to its index) that put a building's roof level under one of
+ * its storeys it stood over: that pair, else null. Roles are read as the levels stand
+ * (`servesAsRoofLevel`), so an order a legacy stack already had passes, and so does one among
+ * storeys only. The one check every reorder goes by (the level selector, the chat's
+ * `reorder_level`, the capture app's REST reorder, `apply_patch`).
+ */
+export function roofLevelOrderBreach(nodes, floors) {
+    const floorOf = (level) => floors.get(level.id) ?? level.level;
+    const buildings = new Set([...floors.keys()].map((id) => nodes[id]).flatMap((node) => (node ? [node.parentId] : [])));
+    for (const buildingId of buildings) {
+        const levels = levelsOf(nodes, buildingId);
+        const roofs = levels.filter((level) => servesAsRoofLevel(nodes, level));
+        for (const roof of roofs)
+            for (const storey of levels.filter((level) => !roofs.includes(level)))
+                if (roof.level > storey.level && floorOf(roof) < floorOf(storey))
+                    return { roofId: roof.id, storeyId: storey.id };
+    }
+    return null;
+}

package/dist/services/roof-move.d.ts

@@ -0,0 +1,83 @@
+import type { SceneChanges } from '../agent-operations/types.js';
+import { type AnyNode, type AnyNodeId, type RoofNode } from '../schema/index.js';
+import { type RoofLevelPlan } from './roof-level.js';
+/**
+ * Roofs on the storey whose walls carry them: the repair for those written there before the roof
+ * level (or by a tool that ignored it), and the seat each writer runs on its own changes, so that
+ * no write leaves one there.
+ */
+type Nodes = Readonly<Record<string, AnyNode>>;
+/**
+ * A roof held by the storey whose walls carry it (written there before the rule, or by a tool that
+ * ignored it): it hides that storey's plan in solo and exploded views; the seat and
+ * `planRoofsOffStorey` move it. Some segment bears on the storey's walls (`segmentBearing`: walls
+ * along its edges, open air past them) and the roof follows walls, or a segment's base or eave
+ * stands at the eave those walls need (knee walls on the plate, or the segment's own walls rising to
+ * it). A lower wing's roof on the storey above is not one (its inner edge has rooms past it), nor a
+ * porch or portico on posts (no wall along its outer edges), nor a roof on another roof.
+ */
+export declare function isRoofOnStoreyWalls(nodes: Nodes, roofId: string): boolean;
+export type RoofMove = {
+    plan: RoofLevelPlan;
+    changes: Required<Pick<SceneChanges, 'create' | 'update'>>;
+};
+/**
+ * The repair for roofs written onto the storey whose walls carry them (`isRoofOnStoreyWalls`):
+ * each goes to the level the rule gives it, standing where it stood (`planRoofMove`). Null when the
+ * storey holds no such roof. Pure: one set of changes, so one undo step.
+ */
+export declare function planRoofsOffStorey(nodes: Nodes, storeyId: string): RoofMove | null;
+/**
+ * A roof on a level above the storey it covers (`coveredStoreyId`), at a height of its own
+ * (`support` level, as the agents' and the auto roof's are, measured from that storey's floor),
+ * keeps its height over that floor when its level rises or drops over the storey (the storey, or a
+ * support level or a level still to be built between them, made taller or shorter), as it did when
+ * it lived on the storey. The updates that keep it there from `before` to `after`; a roof moved in
+ * between, or whose level stands over another storey or other levels now, is left where it is.
+ */
+export declare function roofsKeptOverStorey(before: Nodes, after: Nodes): {
+    id: AnyNodeId;
+    data: Pick<RoofNode, 'position'>;
+}[];
+export type RoofSeat = {
+    changes: Required<Pick<SceneChanges, 'create' | 'update'>>;
+    /** One per roof seated, for the write's answer. */
+    notes: string[];
+};
+/**
+ * The seat over the scene a write produced, `after` as the store leaves it (creates parsed and
+ * attached, reparents and cascades applied), for writers that hold the result. A roof the write
+ * made, moved, turned or reshaped that stands on its storey's walls (`isRoofOnStoreyWalls`) goes to
+ * the level the rule gives it, as the repair moves it; one already on the same storey's walls before
+ * stays (an edit does not migrate a legacy roof; `verify_scene` reports it). Storey by storey, each
+ * move planned on the scene with the earlier ones applied, so one write makes one roof level per
+ * building. Null when no roof needs it.
+ */
+export declare function planRoofSeats(before: Nodes, after: Nodes): RoofSeat | null;
+type CreateEntry = {
+    node: AnyNode;
+    parentId?: string;
+};
+type NodeChanges = {
+    create?: readonly CreateEntry[];
+    update?: readonly {
+        id: string;
+        data: Partial<AnyNode>;
+    }[];
+    delete?: readonly string[];
+};
+/**
+ * A write's changes with the roofs it puts on their walls' storey seated by the rule
+ * (`planRoofSeats` over the scene they produce), and a note per roof. The seat is written into the
+ * changes themselves, so the writer's one store call lands it: a created roof's entry takes its new
+ * parent and height (its other fields kept) and leaves a created parent's `children`; an existing
+ * roof's move and a level's declaration are updates; a new roof level is created right after its
+ * building when the write creates the building, else first, listing its roofs, so a store creating
+ * in order and one applying updates first both land it.
+ */
+export declare function seatRoofs<C extends NodeChanges>(nodes: Nodes, changes: C): {
+    changes: C;
+    notes: string[];
+};
+export {};
+//# sourceMappingURL=roof-move.d.ts.map

package/dist/services/roof-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-move.d.ts","sourceRoot":"","sources":["../../src/services/roof-move.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE7D,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAId,KAAK,QAAQ,EAEd,MAAM,WAAW,CAAA;AAGlB,OAAO,EAAkC,KAAK,aAAa,EAAqB,MAAM,cAAc,CAAA;AAGpG;;;;GAIG;AAEH,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AA0B9C;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAiBzE;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,aAAa,CAAA;IACnB,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAA;CAC3D,CAAA;AAkED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CASlF;AAqCD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,KAAK,EACb,KAAK,EAAE,KAAK,GACX;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA;CAAE,EAAE,CA8BvD;AA2BD,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAA;IAC1D,mDAAmD;IACnD,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,QAAQ,GAAG,IAAI,CAkD1E;AAED,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AACvD,KAAK,WAAW,GAAG;IACjB,MAAM,CAAC,EAAE,SAAS,WAAW,EAAE,CAAA;IAC/B,MAAM,CAAC,EAAE,SAAS;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,CAAA;IAC1D,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC3B,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,WAAW,EAC7C,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,CAAC,GACT;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAkDjC"}