@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

package/dist/lean-to-extension/placement-validation.js

@@ -0,0 +1,324 @@
+import { getActiveRoofHeight, getLevelElevations, } from '@pascal-app/core';
+import { resolveLeanToCornerJoints } from './corner-joint';
+import { resolveLeanToLayout } from './layout';
+import { leanToPlanFootprintFacets } from './plan-footprint';
+const CLEARANCE = 0.05;
+const COMPARISON_EPSILON = 1e-9;
+function overlaps(aCenter, aWidth, bCenter, bWidth) {
+    return Math.abs(aCenter - bCenter) < (aWidth + bWidth) / 2 + CLEARANCE;
+}
+function leanToSpansOverlap(a, b) {
+    return Math.abs(a.position[0] - b.position[0]) < (a.span + b.span) / 2 - 1e-6;
+}
+function planBounds(leanTo, wall) {
+    const points = leanToPlanFootprintFacets(leanTo, wall).flat();
+    return {
+        minX: Math.min(...points.map((point) => point[0])),
+        maxX: Math.max(...points.map((point) => point[0])),
+        minZ: Math.min(...points.map((point) => point[1])),
+        maxZ: Math.max(...points.map((point) => point[1])),
+    };
+}
+function boundsOverlap(a, b) {
+    return (a.minX < b.maxX - CLEARANCE &&
+        a.maxX > b.minX + CLEARANCE &&
+        a.minZ < b.maxZ - CLEARANCE &&
+        a.maxZ > b.minZ + CLEARANCE);
+}
+function transformFacet(facet, building) {
+    return [
+        transformPoint(facet[0], building),
+        transformPoint(facet[1], building),
+        transformPoint(facet[2], building),
+        transformPoint(facet[3], building),
+    ];
+}
+function convexFacetsOverlap(a, b) {
+    for (const polygon of [a, b]) {
+        for (let index = 0; index < polygon.length; index++) {
+            const start = polygon[index];
+            const end = polygon[(index + 1) % polygon.length];
+            const axis = [-(end[1] - start[1]), end[0] - start[0]];
+            const axisLength = Math.hypot(axis[0], axis[1]);
+            if (axisLength <= 1e-9)
+                continue;
+            const unit = [axis[0] / axisLength, axis[1] / axisLength];
+            const project = (point) => point[0] * unit[0] + point[1] * unit[1];
+            const aProjection = a.map(project);
+            const bProjection = b.map(project);
+            const overlap = Math.min(Math.max(...aProjection), Math.max(...bProjection)) -
+                Math.max(Math.min(...aProjection), Math.min(...bProjection));
+            if (overlap <= CLEARANCE)
+                return false;
+        }
+    }
+    return true;
+}
+function leanToFootprintsOverlap(a, aWall, b, bWall, nodes) {
+    const aBuilding = ancestorBuilding(aWall, nodes);
+    const bBuilding = ancestorBuilding(bWall, nodes);
+    const aFacets = leanToPlanFootprintFacets(a, aWall).map((facet) => transformFacet(facet, aBuilding));
+    const bFacets = leanToPlanFootprintFacets(b, bWall).map((facet) => transformFacet(facet, bBuilding));
+    return aFacets.some((aFacet) => bFacets.some((bFacet) => convexFacetsOverlap(aFacet, bFacet)));
+}
+function ancestorBuilding(node, nodes) {
+    let current = node;
+    const seen = new Set();
+    while (current?.parentId && !seen.has(current.id)) {
+        seen.add(current.id);
+        const parent = nodes[current.parentId];
+        if (parent?.type === 'building')
+            return parent;
+        current = parent;
+    }
+    return undefined;
+}
+function transformBounds(bounds, building) {
+    const rotation = building?.rotation[1] ?? 0;
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    const points = [
+        [bounds.minX, bounds.minZ],
+        [bounds.minX, bounds.maxZ],
+        [bounds.maxX, bounds.minZ],
+        [bounds.maxX, bounds.maxZ],
+    ].map(([x, z]) => [
+        (building?.position[0] ?? 0) + x * cos + z * sin,
+        (building?.position[2] ?? 0) - x * sin + z * cos,
+    ]);
+    return {
+        minX: Math.min(...points.map((point) => point[0])),
+        maxX: Math.max(...points.map((point) => point[0])),
+        minZ: Math.min(...points.map((point) => point[1])),
+        maxZ: Math.max(...points.map((point) => point[1])),
+    };
+}
+function transformPoint(point, building) {
+    const rotation = building?.rotation[1] ?? 0;
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    return [
+        (building?.position[0] ?? 0) + point[0] * cos + point[1] * sin,
+        (building?.position[2] ?? 0) - point[0] * sin + point[1] * cos,
+    ];
+}
+function pointSegmentDistance(point, start, end) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const lengthSq = dx * dx + dz * dz;
+    if (lengthSq <= 1e-12)
+        return Math.hypot(point[0] - start[0], point[1] - start[1]);
+    const t = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / lengthSq));
+    return Math.hypot(point[0] - (start[0] + dx * t), point[1] - (start[1] + dz * t));
+}
+function segmentDistance(a, b, c, d) {
+    const orientation = (p, q, r) => (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]);
+    const abC = orientation(a, b, c);
+    const abD = orientation(a, b, d);
+    const cdA = orientation(c, d, a);
+    const cdB = orientation(c, d, b);
+    if (abC * abD <= 0 && cdA * cdB <= 0)
+        return 0;
+    return Math.min(pointSegmentDistance(a, c, d), pointSegmentDistance(b, c, d), pointSegmentDistance(c, a, b), pointSegmentDistance(d, a, b));
+}
+function leanToEndEdges(leanTo, wall, building) {
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const length = Math.max(1e-6, Math.hypot(dx, dz));
+    const along = [dx / length, dz / length];
+    const normal = [-along[1], along[0]];
+    const side = Math.cos(leanTo.rotation[1]) >= 0 ? 1 : -1;
+    const outward = [normal[0] * side, normal[1] * side];
+    const center = [
+        wall.start[0] + along[0] * leanTo.position[0] + normal[0] * leanTo.position[2],
+        wall.start[1] + along[1] * leanTo.position[0] + normal[1] * leanTo.position[2],
+    ];
+    const edge = (alongOffset) => [
+        transformPoint([
+            center[0] + along[0] * alongOffset - outward[0] * leanTo.highOverhang,
+            center[1] + along[1] * alongOffset - outward[1] * leanTo.highOverhang,
+        ], building),
+        transformPoint([
+            center[0] + along[0] * alongOffset + outward[0] * (leanTo.projection + leanTo.lowOverhang),
+            center[1] + along[1] * alongOffset + outward[1] * (leanTo.projection + leanTo.lowOverhang),
+        ], building),
+    ];
+    return {
+        left: edge(-leanTo.span / 2 - leanTo.leftOverhang),
+        right: edge(leanTo.span / 2 + leanTo.rightOverhang),
+    };
+}
+function wallEndHits(edges, wall, building) {
+    const start = transformPoint([wall.start[0], wall.start[1]], building);
+    const end = transformPoint([wall.end[0], wall.end[1]], building);
+    const tolerance = Math.max(CLEARANCE, (wall.thickness ?? 0.1) / 2 + CLEARANCE);
+    return {
+        left: segmentDistance(edges.left[0], edges.left[1], start, end) <= tolerance,
+        right: segmentDistance(edges.right[0], edges.right[1], start, end) <= tolerance,
+    };
+}
+function adjacentBuildingEndHits(leanTo, wall, nodes) {
+    const hostBuilding = ancestorBuilding(wall, nodes);
+    const edges = leanToEndEdges(leanTo, wall, hostBuilding);
+    let left = false;
+    let right = false;
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'wall')
+            continue;
+        const building = ancestorBuilding(node, nodes);
+        if (!(building && hostBuilding && building.id !== hostBuilding.id))
+            continue;
+        const hits = wallEndHits(edges, node, building);
+        left ||= hits.left;
+        right ||= hits.right;
+    }
+    return { left, right };
+}
+export function resolveLeanToEndAbutments(leanTo, wall, nodes) {
+    const hits = adjacentBuildingEndHits(leanTo, wall, nodes);
+    if (!hits.left && !hits.right)
+        return leanTo;
+    return {
+        ...leanTo,
+        leftEndCondition: hits.left ? 'wall-abutment' : leanTo.leftEndCondition,
+        rightEndCondition: hits.right ? 'wall-abutment' : leanTo.rightEndCondition,
+        downspoutPosition: hits.left && hits.right ? 0 : hits.right ? -1 : 1,
+    };
+}
+function wallWorldBounds(wall, building) {
+    const half = Math.max(CLEARANCE, (wall.thickness ?? 0.1) / 2);
+    return transformBounds({
+        minX: Math.min(wall.start[0], wall.end[0]) - half,
+        maxX: Math.max(wall.start[0], wall.end[0]) + half,
+        minZ: Math.min(wall.start[1], wall.end[1]) - half,
+        maxZ: Math.max(wall.start[1], wall.end[1]) + half,
+    }, building);
+}
+function roofSegmentWorldBounds(roof, segment, building) {
+    const points = roofSegmentLevelPoints(roof, segment);
+    return transformBounds({
+        minX: Math.min(...points.map((point) => point[0])),
+        maxX: Math.max(...points.map((point) => point[0])),
+        minZ: Math.min(...points.map((point) => point[1])),
+        maxZ: Math.max(...points.map((point) => point[1])),
+    }, building);
+}
+function roofSegmentLevelPoints(roof, segment) {
+    const halfX = segment.width / 2 + segment.overhang;
+    const halfZ = segment.depth / 2 + segment.overhang;
+    const segmentCos = Math.cos(segment.rotation);
+    const segmentSin = Math.sin(segment.rotation);
+    const roofCos = Math.cos(roof.rotation);
+    const roofSin = Math.sin(roof.rotation);
+    return [
+        [-halfX, -halfZ],
+        [-halfX, halfZ],
+        [halfX, -halfZ],
+        [halfX, halfZ],
+    ].map(([x, z]) => {
+        const sx = segment.position[0] + x * segmentCos + z * segmentSin;
+        const sz = segment.position[2] - x * segmentSin + z * segmentCos;
+        return [
+            roof.position[0] + sx * roofCos + sz * roofSin,
+            roof.position[2] - sx * roofSin + sz * roofCos,
+        ];
+    });
+}
+function hostRoofIntrudesBeyondConnection(leanTo, wall, roof, segment) {
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const length = Math.max(1e-6, Math.hypot(dx, dz));
+    const along = [dx / length, dz / length];
+    const side = Math.cos(leanTo.rotation[1]) >= 0 ? 1 : -1;
+    const outward = [-along[1] * side, along[0] * side];
+    const origin = [
+        wall.start[0] + along[0] * leanTo.position[0],
+        wall.start[1] + along[1] * leanTo.position[0],
+    ];
+    const furthestOutward = Math.max(...roofSegmentLevelPoints(roof, segment).map(([x, z]) => (x - origin[0]) * outward[0] + (z - origin[1]) * outward[1]));
+    return furthestOutward > leanTo.connectionInset + CLEARANCE + COMPARISON_EPSILON;
+}
+export function leanToPlacementConflicts(leanTo, wall, nodes) {
+    const conflicts = [];
+    for (const childId of wall.children ?? []) {
+        const child = nodes[childId];
+        if (!child || child.id === leanTo.id)
+            continue;
+        if (child.type === 'lean-to-extension' &&
+            Math.cos(child.rotation[1]) * Math.cos(leanTo.rotation[1]) > 0 &&
+            leanToSpansOverlap(leanTo, child)) {
+            conflicts.push(`lean-to extension ${child.id}`);
+        }
+    }
+    const candidateBounds = planBounds(leanTo, wall);
+    const hostBuilding = ancestorBuilding(wall, nodes);
+    const candidateWorldBounds = transformBounds(candidateBounds, hostBuilding);
+    const permittedEndHits = adjacentBuildingEndHits(leanTo, wall, nodes);
+    const endEdges = leanToEndEdges(leanTo, wall, hostBuilding);
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'lean-to-extension' || node.id === leanTo.id || node.parentId === wall.id)
+            continue;
+        const host = node.parentId ? nodes[node.parentId] : undefined;
+        const supportedCornerJoint = host?.type === 'wall' &&
+            Object.values(resolveLeanToCornerJoints(leanTo, wall, nodes)).some((joint) => joint?.neighborId === node.id);
+        if (host?.type === 'wall' &&
+            !supportedCornerJoint &&
+            boundsOverlap(candidateWorldBounds, transformBounds(planBounds(node, host), ancestorBuilding(host, nodes))) &&
+            leanToFootprintsOverlap(leanTo, wall, node, host, nodes)) {
+            conflicts.push(`adjacent extension ${node.id}`);
+        }
+    }
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'wall' || node.id === wall.id)
+            continue;
+        const building = ancestorBuilding(node, nodes);
+        if (!(building && hostBuilding && building.id !== hostBuilding.id))
+            continue;
+        if (boundsOverlap(candidateWorldBounds, wallWorldBounds(node, building))) {
+            const wallHits = wallEndHits(endEdges, node, building);
+            if ((wallHits.left && permittedEndHits.left && leanTo.leftEndCondition === 'wall-abutment') ||
+                (wallHits.right && permittedEndHits.right && leanTo.rightEndCondition === 'wall-abutment')) {
+                continue;
+            }
+            conflicts.push(`adjacent building ${building.id}`);
+            break;
+        }
+    }
+    const elevations = getLevelElevations(nodes);
+    const wallLevelY = wall.parentId ? (elevations.get(wall.parentId)?.baseY ?? 0) : 0;
+    const buildingY = hostBuilding?.position[1] ?? 0;
+    const candidateMinY = buildingY + wallLevelY + leanTo.position[1] + resolveLeanToLayout(leanTo).lowEdgeHeight;
+    const candidateMaxY = buildingY + wallLevelY + leanTo.position[1] + leanTo.highEdgeHeight + leanTo.roofThickness;
+    for (const roof of Object.values(nodes)) {
+        if (roof.type !== 'roof')
+            continue;
+        if (roof.metadata?.managedByLeanTo === leanTo.id)
+            continue;
+        const roofBuilding = ancestorBuilding(roof, nodes);
+        if (roofBuilding?.id !== hostBuilding?.id)
+            continue;
+        const roofLevelY = roof.parentId ? (elevations.get(roof.parentId)?.baseY ?? 0) : 0;
+        const isSameHostLevel = roof.parentId === wall.parentId;
+        for (const childId of roof.children) {
+            const segment = nodes[childId];
+            if (segment?.type !== 'roof-segment')
+                continue;
+            if (segment.id === leanTo.hostRoofSegmentId) {
+                if (hostRoofIntrudesBeyondConnection(leanTo, wall, roof, segment)) {
+                    conflicts.push(`host roof/eave ${segment.id}`);
+                }
+                continue;
+            }
+            if (!isSameHostLevel)
+                continue;
+            if (!boundsOverlap(candidateWorldBounds, roofSegmentWorldBounds(roof, segment, roofBuilding)))
+                continue;
+            const roofMinY = buildingY + roofLevelY + roof.position[1] + segment.position[1];
+            const roofMaxY = roofMinY + segment.wallHeight + getActiveRoofHeight(segment) + segment.deckThickness;
+            if (candidateMinY < roofMaxY - CLEARANCE && candidateMaxY > roofMinY + CLEARANCE) {
+                conflicts.push(`roof/eave ${segment.id}`);
+            }
+        }
+    }
+    return conflicts;
+}

package/dist/lean-to-extension/placement.d.ts

@@ -0,0 +1,59 @@
+import { type AnyNode, type AnyNodeId, LeanToExtensionNode, type SlabNode, type WallNode } from '@pascal-app/core';
+import { type LeanToCornerSide } from './corner-joint';
+export type LeanToPlanPlacementTarget = {
+    node: LeanToExtensionNode;
+    valid: boolean;
+    wall?: WallNode;
+};
+export declare function resolveLeanToCommitTarget<T>(visibleTarget: T | null, clickTarget: T | null): T | null;
+/** Apply transient corner data so the placement ghost matches the committed assembly. */
+export declare function resolveLeanToPreviewNode(node: LeanToExtensionNode, wall: WallNode | undefined, nodes: Record<AnyNodeId, AnyNode>): LeanToExtensionNode;
+export declare function resolveLeanToWallPlanTarget(wall: WallNode, localX: number, side: 'front' | 'back', nodes: Record<AnyNodeId, AnyNode>): LeanToPlanPlacementTarget | null;
+export declare const LEAN_TO_RUN_MAGNETIC_SNAP_RADIUS = 0.5;
+export declare const LEAN_TO_RUN_CONNECT_SNAP_RADIUS = 0.5;
+export declare function nextLeanToPlacementRotation(current: number, key: string, hasShortcutModifier?: boolean): number;
+export declare function resolveLeanToPlanPosition(node: LeanToExtensionNode, point: readonly [number, number]): LeanToExtensionNode['position'];
+export declare function resolveLeanToFreestandingPlacement(levelId: string, point: readonly [number, number], rotationY?: number, canopyForm?: LeanToExtensionNode['canopyForm']): LeanToExtensionNode;
+export declare function resolveLeanToFreestandingRunPlacement(levelId: string, start: readonly [number, number], end: readonly [number, number], flipProjection?: boolean, canopyForm?: LeanToExtensionNode['canopyForm']): LeanToExtensionNode | null;
+export type LeanToFreestandingRunEndpointSnap = {
+    nodeId: string;
+    point: [number, number];
+    side: LeanToCornerSide;
+};
+export declare function resolveLeanToFreestandingRunEndpointSnap({ activeLevelId, canopyForm, flipProjection, maxDistance, nodes, proposedEnd, start, }: {
+    activeLevelId: AnyNodeId;
+    canopyForm?: LeanToExtensionNode['canopyForm'];
+    flipProjection?: boolean;
+    maxDistance?: number;
+    nodes: Record<AnyNodeId, AnyNode>;
+    proposedEnd: readonly [number, number];
+    start: readonly [number, number];
+}): LeanToFreestandingRunEndpointSnap | null;
+export declare function resolveLeanToFreestandingRunTarget({ activeLevelId, canopyForm, end, flipProjection, nodes, start, }: {
+    activeLevelId: AnyNodeId;
+    canopyForm?: LeanToExtensionNode['canopyForm'];
+    end: readonly [number, number];
+    flipProjection?: boolean;
+    nodes: Record<AnyNodeId, AnyNode>;
+    start: readonly [number, number];
+}): LeanToPlanPlacementTarget | null;
+export declare function resolveLeanToPlanPlacement({ activeLevelId, freestandingPoint, freestandingRotationY, freestandingCanopyForm, nodes, point, }: {
+    activeLevelId: AnyNodeId;
+    freestandingPoint: readonly [number, number];
+    freestandingRotationY?: number;
+    freestandingCanopyForm?: LeanToExtensionNode['canopyForm'];
+    nodes: Record<AnyNodeId, AnyNode>;
+    point: readonly [number, number];
+}): LeanToPlanPlacementTarget;
+export declare function nextLeanToCanopyForm(current: LeanToExtensionNode['canopyForm'], key: string): LeanToExtensionNode['canopyForm'];
+export declare function resolveLeanToSlabEdgePlacement({ activeLevelId, edgeIndex, edgeT, nodes, slab, }: {
+    activeLevelId: string;
+    edgeIndex: number;
+    edgeT: number;
+    nodes: Record<AnyNodeId, AnyNode>;
+    slab: SlabNode;
+}): LeanToExtensionNode | null;
+export declare function findLeanToSlabEdgePlacement(point: readonly [number, number], nodes: Record<AnyNodeId, AnyNode>, activeLevelId: string, maxDistance?: number): LeanToExtensionNode | null;
+export declare function reconcileLeanToSlabEdgePlacement(node: LeanToExtensionNode, nodes: Record<AnyNodeId, AnyNode>): LeanToExtensionNode;
+export declare function moveLeanToAlongSlabEdge(node: LeanToExtensionNode, point: readonly [number, number], nodes: Record<AnyNodeId, AnyNode>): LeanToExtensionNode | null;
+//# sourceMappingURL=placement.d.ts.map

package/dist/lean-to-extension/placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placement.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/placement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAEd,mBAAmB,EACnB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAOzB,OAAO,EAEL,KAAK,gBAAgB,EAGtB,MAAM,gBAAgB,CAAA;AAgBvB,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE,mBAAmB,CAAA;IACzB,KAAK,EAAE,OAAO,CAAA;IACd,IAAI,CAAC,EAAE,QAAQ,CAAA;CAChB,CAAA;AAED,wBAAgB,yBAAyB,CAAC,CAAC,EACzC,aAAa,EAAE,CAAC,GAAG,IAAI,EACvB,WAAW,EAAE,CAAC,GAAG,IAAI,GACpB,CAAC,GAAG,IAAI,CAEV;AAED,yFAAyF;AACzF,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,mBAAmB,EACzB,IAAI,EAAE,QAAQ,GAAG,SAAS,EAC1B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,mBAAmB,CAcrB;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,OAAO,GAAG,MAAM,EACtB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,yBAAyB,GAAG,IAAI,CAqBlC;AAGD,eAAO,MAAM,gCAAgC,MAAM,CAAA;AAInD,eAAO,MAAM,+BAA+B,MAAmC,CAAA;AAE/E,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,mBAAmB,UAAQ,GAC1B,MAAM,CAKR;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,mBAAmB,CAAC,UAAU,CAAC,CAUjC;AAED,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,SAAS,SAAI,EACb,UAAU,GAAE,mBAAmB,CAAC,YAAY,CAAU,GACrD,mBAAmB,CA0BrB;AAED,wBAAgB,qCAAqC,CACnD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,GAAG,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,cAAc,UAAQ,EACtB,UAAU,GAAE,mBAAmB,CAAC,YAAY,CAAU,GACrD,mBAAmB,GAAG,IAAI,CAiB5B;AAED,MAAM,MAAM,iCAAiC,GAAG;IAC9C,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvB,IAAI,EAAE,gBAAgB,CAAA;CACvB,CAAA;AAeD,wBAAgB,wCAAwC,CAAC,EACvD,aAAa,EACb,UAAmB,EACnB,cAAsB,EACtB,WAA8C,EAC9C,KAAK,EACL,WAAW,EACX,KAAK,GACN,EAAE;IACD,aAAa,EAAE,SAAS,CAAA;IACxB,UAAU,CAAC,EAAE,mBAAmB,CAAC,YAAY,CAAC,CAAA;IAC9C,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACjC,GAAG,iCAAiC,GAAG,IAAI,CAgD3C;AAED,wBAAgB,kCAAkC,CAAC,EACjD,aAAa,EACb,UAAmB,EACnB,GAAG,EACH,cAAsB,EACtB,KAAK,EACL,KAAK,GACN,EAAE;IACD,aAAa,EAAE,SAAS,CAAA;IACxB,UAAU,CAAC,EAAE,mBAAmB,CAAC,YAAY,CAAC,CAAA;IAC9C,GAAG,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACjC,GAAG,yBAAyB,GAAG,IAAI,CAanC;AAED,wBAAgB,0BAA0B,CAAC,EACzC,aAAa,EACb,iBAAiB,EACjB,qBAAyB,EACzB,sBAA+B,EAC/B,KAAK,EACL,KAAK,GACN,EAAE;IACD,aAAa,EAAE,SAAS,CAAA;IACxB,iBAAiB,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5C,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,sBAAsB,CAAC,EAAE,mBAAmB,CAAC,YAAY,CAAC,CAAA;IAC1D,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACjC,GAAG,yBAAyB,CAmB5B;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,mBAAmB,CAAC,YAAY,CAAC,EAC1C,GAAG,EAAE,MAAM,GACV,mBAAmB,CAAC,YAAY,CAAC,CAGnC;AAED,wBAAgB,8BAA8B,CAAC,EAC7C,aAAa,EACb,SAAS,EACT,KAAK,EACL,KAAK,EACL,IAAI,GACL,EAAE;IACD,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,IAAI,EAAE,QAAQ,CAAA;CACf,GAAG,mBAAmB,GAAG,IAAI,CAgD7B;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,aAAa,EAAE,MAAM,EACrB,WAAW,SAAO,GACjB,mBAAmB,GAAG,IAAI,CA8B5B;AAED,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,mBAAmB,CAoCrB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,mBAAmB,GAAG,IAAI,CAkB5B"}