@pascal-app/core 1.0.6 → 1.0.7

package/dist/spatial/usage-field/obstacles.js

@@ -0,0 +1,215 @@
+import { boxesMeet } from './pieces.js';
+export function obstacleOf(prism, index) {
+    const rings = [prism.outer, ...prism.holes];
+    let n = 0;
+    for (const ring of rings)
+        n += ring.length;
+    const edges = new Float64Array(n * 4);
+    let k = 0;
+    let x0 = Number.POSITIVE_INFINITY;
+    let z0 = Number.POSITIVE_INFINITY;
+    let x1 = Number.NEGATIVE_INFINITY;
+    let z1 = Number.NEGATIVE_INFINITY;
+    for (const ring of rings)
+        for (let i = 0; i < ring.length; i++) {
+            const a = ring[i];
+            const b = ring[(i + 1) % ring.length];
+            edges[k++] = a[0];
+            edges[k++] = a[1];
+            edges[k++] = b[0];
+            edges[k++] = b[1];
+            x0 = Math.min(x0, a[0]);
+            x1 = Math.max(x1, a[0]);
+            z0 = Math.min(z0, a[1]);
+            z1 = Math.max(z1, a[1]);
+        }
+    return { index, prism, edges, aabb: [x0, z0, x1, z1] };
+}
+/** Signed distance to a set of rings given as flat edges: exact, negative inside (even-odd). */
+export function signedDistance(edges, px, pz) {
+    let d2 = Number.POSITIVE_INFINITY;
+    let inside = false;
+    for (let k = 0; k < edges.length; k += 4) {
+        const ax = edges[k];
+        const az = edges[k + 1];
+        const bx = edges[k + 2];
+        const bz = edges[k + 3];
+        const ex = bx - ax;
+        const ez = bz - az;
+        const wx = px - ax;
+        const wz = pz - az;
+        const length2 = ex * ex + ez * ez;
+        let t = length2 > 0 ? (wx * ex + wz * ez) / length2 : 0;
+        t = Math.min(1, Math.max(0, t));
+        const dx = wx - ex * t;
+        const dz = wz - ez * t;
+        const q = dx * dx + dz * dz;
+        if (q < d2)
+            d2 = q;
+        if (az > pz !== bz > pz && px < ax + ((pz - az) * ex) / ez)
+            inside = !inside;
+    }
+    const d = Math.sqrt(d2);
+    return inside ? -d : d;
+}
+export const obstacleDistance = (o, px, pz) => signedDistance(o.edges, px, pz);
+/** The closest point of an obstacle's edges to a point, and how far. */
+export function closestOnEdges(edges, px, pz) {
+    let d2 = Number.POSITIVE_INFINITY;
+    let cx = 0;
+    let cz = 0;
+    for (let k = 0; k < edges.length; k += 4) {
+        const ax = edges[k];
+        const az = edges[k + 1];
+        const ex = edges[k + 2] - ax;
+        const ez = edges[k + 3] - az;
+        const length2 = ex * ex + ez * ez;
+        let t = length2 > 0 ? ((px - ax) * ex + (pz - az) * ez) / length2 : 0;
+        t = Math.min(1, Math.max(0, t));
+        const qx = ax + ex * t;
+        const qz = az + ez * t;
+        const q = (px - qx) ** 2 + (pz - qz) ** 2;
+        if (q < d2) {
+            d2 = q;
+            cx = qx;
+            cz = qz;
+        }
+    }
+    return { x: cx, z: cz, d: Math.sqrt(d2) };
+}
+/**
+ * The prisms a body standing in the band bumps into: those whose height range meets it, within
+ * the plan window if one is given. A prism that only touches the band's edge does not count.
+ */
+export function obstaclesInBand(prisms, band, window, skip) {
+    const out = [];
+    for (const prism of prisms) {
+        if (!(prism.z1 > band.z0 + 1e-6 && prism.z0 < band.z1 - 1e-6))
+            continue;
+        if (skip?.(prism))
+            continue;
+        const obstacle = obstacleOf(prism, out.length);
+        if (window) {
+            const [a0, b0, a1, b1] = obstacle.aabb;
+            if (a1 < window[0] || a0 > window[2] || b1 < window[1] || b0 > window[3])
+                continue;
+        }
+        out.push(obstacle);
+    }
+    return out;
+}
+/** How far a ray from a point goes before it meets an obstacle's outline, at most `max`. */
+export function rayHit(from, dir, obstacles, max) {
+    let best = max;
+    const ex = from[0] + dir[0] * max;
+    const ez = from[1] + dir[1] * max;
+    const box = [
+        Math.min(from[0], ex),
+        Math.min(from[1], ez),
+        Math.max(from[0], ex),
+        Math.max(from[1], ez),
+    ];
+    for (const o of obstacles) {
+        if (!boxesMeet(box, o.aabb))
+            continue;
+        for (let k = 0; k < o.edges.length; k += 4) {
+            const ax = o.edges[k];
+            const az = o.edges[k + 1];
+            const sx = o.edges[k + 2] - ax;
+            const sz = o.edges[k + 3] - az;
+            const den = dir[0] * sz - dir[1] * sx;
+            if (Math.abs(den) < 1e-12)
+                continue;
+            const t = ((ax - from[0]) * sz - (az - from[1]) * sx) / den;
+            const u = ((ax - from[0]) * dir[1] - (az - from[1]) * dir[0]) / den;
+            if (t >= 0 && t < best && u >= 0 && u <= 1)
+                best = t;
+        }
+    }
+    return best;
+}
+/** The exact distance between two obstacles' outlines (0 when they touch or overlap) and the two closest points. */
+export function obstacleGap(a, b) {
+    if (signedDistance(a.edges, b.edges[0], b.edges[1]) <= 0 ||
+        signedDistance(b.edges, a.edges[0], a.edges[1]) <= 0)
+        return { d: 0, pa: [b.edges[0], b.edges[1]], pb: [b.edges[0], b.edges[1]] };
+    let best = Number.POSITIVE_INFINITY;
+    let pa = [0, 0];
+    let pb = [0, 0];
+    for (const [from, to, swapped] of [
+        [a, b, false],
+        [b, a, true],
+    ])
+        for (let k = 0; k < from.edges.length; k += 4) {
+            const closest = closestOnEdges(to.edges, from.edges[k], from.edges[k + 1]);
+            if (closest.d < best) {
+                best = closest.d;
+                const here = [from.edges[k], from.edges[k + 1]];
+                const there = [closest.x, closest.z];
+                pa = swapped ? there : here;
+                pb = swapped ? here : there;
+            }
+        }
+    return { d: best, pa, pb };
+}
+/**
+ * The two obstacles that make the passage at a point: the nearest one, and the nearest one whose
+ * closest point lies on the other side of the point. The passage is their exact distance, whatever
+ * the grid said.
+ */
+export function passagePair(obstacles, px, pz, reach = 1.5) {
+    const near = obstacles
+        .filter((o) => o.aabb[0] - reach <= px &&
+        px <= o.aabb[2] + reach &&
+        o.aabb[1] - reach <= pz &&
+        pz <= o.aabb[3] + reach)
+        .map((o) => ({ o, ...closestOnEdges(o.edges, px, pz) }))
+        .sort((u, v) => u.d - v.d);
+    const first = near[0];
+    if (!first)
+        return null;
+    const second = near.find((n) => (n.x - px) * (first.x - px) + (n.z - pz) * (first.z - pz) < 0);
+    if (!second)
+        return null;
+    const gap = obstacleGap(first.o, second.o);
+    return { width: gap.d, a: first.o, b: second.o, pa: gap.pa, pb: gap.pb };
+}
+/**
+ * What bounds a width read at a point: the nearest obstacle a disc of `radius` there touches, to
+ * within `slack`, and the nearest touching one on the other side of the point, if there is one.
+ * The nearest obstacle alone when nothing else bounds the disc.
+ */
+export function boundingObstacles(obstacles, px, pz, radius, slack = 0.03) {
+    const reach = radius + slack;
+    const touching = nearestNodes(obstacles, px, pz, 6, reach).filter((o) => Math.abs(signedDistance(o.edges, px, pz)) <= reach);
+    const first = touching[0] ?? nearestNodes(obstacles, px, pz, 1)[0];
+    if (!first)
+        return [];
+    const at = closestOnEdges(first.edges, px, pz);
+    const across = touching.find((o) => {
+        const there = closestOnEdges(o.edges, px, pz);
+        return (there.x - px) * (at.x - px) + (there.z - pz) * (at.z - pz) < 0;
+    });
+    return across ? [first, across] : [first];
+}
+/** The `count` obstacles of different nodes nearest a point, nearest first. */
+export function nearestNodes(obstacles, px, pz, count, reach = 3) {
+    const seen = new Set();
+    const out = [];
+    const near = obstacles
+        .filter((o) => o.aabb[0] - reach <= px &&
+        px <= o.aabb[2] + reach &&
+        o.aabb[1] - reach <= pz &&
+        pz <= o.aabb[3] + reach)
+        .map((o) => ({ o, d: Math.abs(signedDistance(o.edges, px, pz)) }))
+        .sort((a, b) => a.d - b.d);
+    for (const { o } of near) {
+        if (seen.has(o.prism.nodeId))
+            continue;
+        seen.add(o.prism.nodeId);
+        out.push(o);
+        if (out.length === count)
+            break;
+    }
+    return out;
+}

package/dist/spatial/usage-field/openings.d.ts

@@ -0,0 +1,12 @@
+import type { DoorNode, WallNode } from '../../schema/index.js';
+import type { Prism, Ring } from './types.js';
+import { type Nodes } from './walls.js';
+/**
+ * The plan rectangle of the hole a door is walked through, across the wall's thickness: the width
+ * between its frame members, or the whole width for a frameless opening. Null for a scripted door,
+ * whose frame is not known.
+ */
+export declare function doorwayRing(wall: WallNode, door: DoorNode): Ring | null;
+/** Doors' frames and windows' frames and sills of one level, in level-local heights. */
+export declare function openingBodies(nodes: Nodes, levelId: string, walls?: WallNode[]): Prism[];
+//# sourceMappingURL=openings.d.ts.map

package/dist/spatial/usage-field/openings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openings.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/openings.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAW,QAAQ,EAAE,QAAQ,EAAc,MAAM,cAAc,CAAA;AAQ3E,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC1C,OAAO,EAAyB,KAAK,KAAK,EAAE,MAAM,SAAS,CAAA;AA6N3D;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAKvE;AAED,wFAAwF;AACxF,wBAAgB,aAAa,CAC3B,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EACf,KAAK,GAAE,QAAQ,EAA+B,GAC7C,KAAK,EAAE,CAWT"}

package/dist/spatial/usage-field/openings.js

@@ -0,0 +1,162 @@
+import { getOpeningFloorDatum } from '../../lib/opening-floor-datum.js';
+import { resolveOpeningFrameDepth } from '../../lib/opening-frame-depth.js';
+import { getWallCurveFrameAt, getWallCurveLength, isCurvedWall, } from '../../systems/wall/wall-curve.js';
+import { getWallThickness } from '../../systems/wall/wall-footprint.js';
+import { getWallBodyCenterOffset } from '../../systems/wall/wall-frame.js';
+import { isOpening, levelWalls } from './walls.js';
+function poseOf(wall, opening) {
+    const length = getWallCurveLength(wall);
+    const frame = getWallCurveFrameAt(wall, length > 1e-9 ? Math.min(1, Math.max(0, opening.position[0] / length)) : 0);
+    const across = getWallBodyCenterOffset(wall) + opening.position[2];
+    return {
+        cx: frame.point.x + frame.normal.x * across,
+        cz: frame.point.y + frame.normal.y * across,
+        tx: frame.tangent.x,
+        tz: frame.tangent.y,
+        nx: frame.normal.x,
+        nz: frame.normal.y,
+    };
+}
+/** The plan rectangle `u0..u1` along the wall and `a0..a1` across it, from the opening's centre. */
+function rect(pose, u0, u1, a0, a1) {
+    const at = (u, a) => [
+        pose.cx + pose.tx * u + pose.nx * a,
+        pose.cz + pose.tz * u + pose.nz * a,
+    ];
+    return [at(u0, a0), at(u1, a0), at(u1, a1), at(u0, a1)];
+}
+/** How far the window builder lifts the sill's top over the opening's bottom (`SILL_LIFT` there). */
+const SILL_LIFT = 0.001;
+function push(out, id, kind, z0, z1, outer, common) {
+    if (z1 - z0 > 1e-4)
+        out.push({ id, kind, z0, z1, outer, holes: [], ...common });
+}
+/**
+ * A door's frame as the door builder cuts it (`viewer/src/systems/door/door-system.tsx`, "Frame
+ * members"): two posts of `frameThickness` and a head across the width, `frameDepth` deep, centred
+ * on the wall's body; a threshold of `thresholdHeight` between the posts. The leaf is not an
+ * obstacle (a door is passed open). A frameless opening has no frame. The arch and the rounded head
+ * are left out and the door is marked approximate; a scripted door is its bounds.
+ */
+function doorFrame(wall, door, yc, out) {
+    const pose = poseOf(wall, door);
+    const half = resolveOpeningFrameDepth(door, getWallThickness(wall)) / 2;
+    const curved = isCurvedWall(wall);
+    const common = {
+        nodeId: door.id,
+        shape: curved ? 'approx' : 'exact',
+        ...(curved ? { why: 'a door on a curved wall' } : {}),
+    };
+    if (door.source) {
+        const size = scriptedBounds(door.source.manifest.bounds);
+        push(out, `${door.id}#script`, 'jamb', yc - door.height / 2, yc - door.height / 2 + size.height, rect(pose, -size.width / 2, size.width / 2, -size.depth / 2, size.depth / 2), {
+            nodeId: door.id,
+            shape: 'approx',
+            why: 'a scripted door: its bounds box',
+        });
+        return;
+    }
+    if (door.openingKind === 'opening')
+        return;
+    const w = door.width;
+    const h = door.height;
+    const ft = door.frameThickness;
+    const bottom = yc - h / 2;
+    const top = yc + h / 2;
+    const shaped = door.openingShape !== 'rectangle';
+    const approx = shaped
+        ? { ...common, shape: 'approx', why: `a ${door.openingShape} head: the posts only` }
+        : common;
+    const postTop = door.openingShape === 'arch'
+        ? Math.max(top - Math.min(Math.max(door.archHeight, 0), h) - (door.archHeight <= ft * 2 ? ft : 0), bottom + 0.01)
+        : top;
+    push(out, `${door.id}#jamb.l`, 'jamb', bottom, postTop, rect(pose, -w / 2, -w / 2 + ft, -half, half), approx);
+    push(out, `${door.id}#jamb.r`, 'jamb', bottom, postTop, rect(pose, w / 2 - ft, w / 2, -half, half), approx);
+    if (!shaped)
+        push(out, `${door.id}#head`, 'door-head', top - ft, top, rect(pose, -w / 2, w / 2, -half, half), common);
+    if (door.threshold)
+        push(out, `${door.id}#threshold`, 'threshold', bottom, bottom + door.thresholdHeight, rect(pose, -(w - 2 * ft) / 2, (w - 2 * ft) / 2, -half, half), common);
+}
+function scriptedBounds(bounds) {
+    return {
+        width: bounds.max[0] - bounds.min[0],
+        height: bounds.max[1] - bounds.min[1],
+        depth: bounds.max[2] - bounds.min[2],
+    };
+}
+/**
+ * A window as the window builder cuts it (`viewer/src/systems/window/window-system.tsx`): the frame
+ * and its glazing fill the opening, `width × height × frameDepth`, centred on the wall's body; a sill
+ * box `width + 0.4·sillDepth` wide, `sillThickness` thick, `sillDepth` deep stands under it on the
+ * side the window faces, starting on the wall face (2 mm off it when the frame is shallower than the wall). A bay or a bow
+ * projects: only its frame is drawn here and it is marked approximate. */
+function window(wall, win, yc, out) {
+    const pose = poseOf(wall, win);
+    const half = resolveOpeningFrameDepth(win, getWallThickness(wall)) / 2;
+    const w = win.width;
+    const h = win.height;
+    const curved = isCurvedWall(wall);
+    const projecting = win.windowType === 'bay' || win.windowType === 'bow';
+    const why = projecting
+        ? `a ${win.windowType} window: its projection is not drawn`
+        : curved
+            ? 'a window on a curved wall'
+            : undefined;
+    const common = {
+        nodeId: win.id,
+        shape: why ? 'approx' : 'exact',
+        ...(why ? { why } : {}),
+    };
+    if (win.source) {
+        const size = scriptedBounds(win.source.manifest.bounds);
+        push(out, `${win.id}#script`, 'window-frame', yc - h / 2, yc - h / 2 + size.height, rect(pose, -size.width / 2, size.width / 2, -size.depth / 2, size.depth / 2), {
+            nodeId: win.id,
+            shape: 'approx',
+            why: 'a scripted window: its bounds box',
+        });
+        return;
+    }
+    push(out, `${win.id}#frame`, 'window-frame', yc - h / 2, yc + h / 2, rect(pose, -w / 2, w / 2, -half, half), common);
+    if (!win.sill)
+        return;
+    // window-local +z is the wall's normal for a window turned 0, its opposite for one turned half a turn
+    const side = Math.cos(win.rotation[1]) >= 0 ? 1 : -1;
+    const faceZ = Math.max(getWallThickness(wall) / 2 - win.position[2] * Math.cos(win.rotation[1]), half);
+    // The builder stands the sill's back on the wall face when the frame runs through the wall,
+    // and 2 mm off it when the frame is shallower.
+    const from = faceZ + (faceZ > half ? 0.002 : 0);
+    const sillW = w + win.sillDepth * 0.4;
+    const [a0, a1] = side > 0 ? [from, from + win.sillDepth] : [-(from + win.sillDepth), -from];
+    push(out, `${win.id}#sill`, 'sill', yc - h / 2 - win.sillThickness + SILL_LIFT, yc - h / 2 + SILL_LIFT, rect(pose, -sillW / 2, sillW / 2, a0, a1), {
+        ...common,
+        host: { wallId: wall.id, face: side > 0 ? 'a' : 'b' },
+    });
+}
+/**
+ * The plan rectangle of the hole a door is walked through, across the wall's thickness: the width
+ * between its frame members, or the whole width for a frameless opening. Null for a scripted door,
+ * whose frame is not known.
+ */
+export function doorwayRing(wall, door) {
+    if (door.source)
+        return null;
+    const clear = door.openingKind === 'opening' ? door.width : door.width - 2 * door.frameThickness;
+    const half = getWallThickness(wall) / 2 + 0.01;
+    return rect(poseOf(wall, door), -clear / 2, clear / 2, -half, half);
+}
+/** Doors' frames and windows' frames and sills of one level, in level-local heights. */
+export function openingBodies(nodes, levelId, walls = levelWalls(nodes, levelId)) {
+    const out = [];
+    for (const wall of walls)
+        for (const id of wall.children ?? []) {
+            const opening = nodes[id];
+            if (!isOpening(opening) || opening.visible === false)
+                continue;
+            const yc = getOpeningFloorDatum(wall, opening, nodes) + opening.position[1];
+            if (opening.type === 'door')
+                doorFrame(wall, opening, yc, out);
+            else
+                window(wall, opening, yc, out);
+        }
+    return out;
+}

package/dist/spatial/usage-field/path.d.ts

@@ -0,0 +1,48 @@
+import { type BucketIndex, type Grid } from './field.js';
+/**
+ * The widest path (maximin) from the source cells over cells where `inside` holds and the clearance
+ * is positive, 4-neighbour. `B[c]` is the best bottleneck, the least clearance along the widest path
+ * to `c`; `P[c]` the cell before it.
+ */
+export declare function widestPath(g: Grid, F: Float32Array, inside: Uint8Array, sources: Iterable<number>): {
+    B: Float64Array;
+    P: Int32Array;
+};
+/** The cells of the widest path from its source to `c`, in order, and the index of its narrowest. */
+export declare function pathTo(P: Int32Array, F: Float32Array, c: number): {
+    cells: number[];
+    narrowest: number;
+};
+/** Grid Dijkstra over the passable cells, 16 neighbours: the travel distance in metres, Infinity where unreached. */
+export declare function travel(g: Grid, pass: Uint8Array, sources: Iterable<number>): Float64Array;
+export type WindowCache = Map<string, {
+    d: number;
+    at: [number, number];
+}>;
+/**
+ * The passage along a coarse widest path, to the millimetre. The grid says where the path pinches,
+ * to within half a cell; this re-solves the widest path on a grid ten times finer, with exact
+ * clearances, in a window around every path cell that is within one cell of the coarse bottleneck
+ * (centres at least `spacing` apart), and takes the narrowest result. The passage is twice that
+ * clearance.
+ */
+export declare function refinePassage(g: Grid, F: Float32Array, index: BucketIndex, path: {
+    cells: number[];
+    narrowest: number;
+}, isSource: (cell: number) => boolean, isTarget: (x: number, z: number) => boolean, { R, step, spacing, cache, roomKey, }?: {
+    R?: number;
+    step?: number;
+    spacing?: number;
+    cache?: WindowCache;
+    roomKey?: string;
+}): {
+    width: number;
+    at: [number, number];
+    windows: number;
+};
+/**
+ * The shortest way from one cell to another over the passable cells, 8 neighbours, no corner cut
+ * through a blocked cell (A*). The cells in order, or null when there is no way.
+ */
+export declare function shortestRoute(g: Grid, pass: Uint8Array, from: number, to: number): number[] | null;
+//# sourceMappingURL=path.d.ts.map

package/dist/spatial/usage-field/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAwB,KAAK,IAAI,EAAE,MAAM,SAAS,CAAA;AA2D3E;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,IAAI,EACP,CAAC,EAAE,YAAY,EACf,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,GACxB;IAAE,CAAC,EAAE,YAAY,CAAC;IAAC,CAAC,EAAE,UAAU,CAAA;CAAE,CAiCpC;AAED,qGAAqG;AACrG,wBAAgB,MAAM,CACpB,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,MAAM,GACR;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAOxC;AA8BD,qHAAqH;AACrH,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,YAAY,CAkCzF;AA8FD,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAC,CAAA;AAE1E;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAAE,IAAI,EACP,CAAC,EAAE,YAAY,EACf,KAAK,EAAE,WAAW,EAClB,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAC5C,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EACnC,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,EAC3C,EACE,CAAO,EACP,IAAY,EACZ,OAAa,EACb,KAAK,EACL,OAAY,GACb,GAAE;IAAE,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7F;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAyC1D;AAaD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAAE,IAAI,EACP,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,MAAM,EAAE,GAAG,IAAI,CAkCjB"}