@woosh/meep-engine 3.14.6 → 3.16.0

package/src/core/model/node-graph/visual/layout/NodeGraphLayoutOptions.js

@@ -0,0 +1,175 @@
+/**
+ * Every number the layout is allowed to be tuned by.
+ *
+ * They live in one place because they are not independent: the room a channel has for tracks is set
+ * by `layer_gap`, the room a wire lane has is set by `wire_gap`, and a router told to bend for less
+ * than it costs to go around will do neither well. Somebody changing one of these needs to see the
+ * others.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class NodeGraphLayoutOptions {
+
+    /**
+     * Horizontal gap between one column of boxes and the next.
+     *
+     * This is the width of the channel every edge crossing that boundary has to share, so it is
+     * also what limits how many wires can run side by side without one of them having to detour.
+     *
+     * @type {number}
+     */
+    layer_gap = 140;
+
+    /**
+     * Vertical gap between two node boxes sharing a column.
+     * @type {number}
+     */
+    node_gap = 44;
+
+    /**
+     * Vertical room reserved for one wire passing through a column it does not stop at.
+     *
+     * An edge spanning several columns gets a lane of this height in each one it crosses, which is
+     * what keeps a long edge from being drawn over the boxes it passes.
+     *
+     * @type {number}
+     */
+    wire_gap = 20;
+
+    /**
+     * How far outside a box the router runs alongside it, and how far a wire leaves its port before
+     * it is allowed to turn.
+     *
+     * It is one number because it is one line: the grid's line around a box is where a wire
+     * alongside it runs, and it is also the first place a wire leaving a port can turn. A wire on
+     * the box boundary reads as touching it, and a wire that turns the moment it leaves a port
+     * makes it hard to see which port it belongs to.
+     *
+     * @type {number}
+     */
+    clearance = 24;
+
+    /**
+     * Routing tracks placed across each channel, on top of the lines the boxes themselves induce.
+     *
+     * A channel with no tracks can only be crossed at the x of some box edge, and every wire
+     * turning in that channel has to turn at the same place. Eight is enough for the graphs seen in
+     * practice and cheap — a track is one column of grid vertices.
+     *
+     * @type {number}
+     */
+    channel_tracks = 8;
+
+    /**
+     * What a ninety degree turn costs the router, in the same units as length.
+     *
+     * The router minimises length plus bends, and the ratio between them is the whole character of
+     * the result: at zero it produces staircases, and at a very large value it produces long
+     * detours to save a corner. This is roughly a quarter of a channel — a wire will go a third of
+     * the way across a channel to avoid a bend, and no further.
+     *
+     * @type {number}
+     */
+    bend_penalty = 40;
+
+    /**
+     * Rounds of rip-up and reroute.
+     *
+     * The loop stops as soon as nothing is shared, and each round after the first only asks the
+     * wires still in an argument, so on a graph whose wires mostly fit this costs very little.
+     * Congestion that survives six rounds is congestion the placement created and the router cannot
+     * fix.
+     *
+     * This is the number to lower on a graph where every wire is fighting — hundreds of them
+     * through one channel, which is what a node with a hundred consumers produces. There the whole
+     * set is re-routed every round and the work is rounds times wires times the size of the grid.
+     *
+     * @type {number}
+     */
+    congestion_iterations = 6;
+
+    /**
+     * What a wire pays, per round, for standing on a vertex another wire is already using.
+     *
+     * It starts low deliberately. A first round that already forbids sharing routes every wire
+     * around whatever was routed before it, and the order wires happen to be visited in then
+     * decides the drawing. Starting cheap lets every wire take the route it actually wants, and
+     * raising the price each round makes the ones that want it least give way first.
+     *
+     * @type {number}
+     */
+    present_cost = 8;
+
+    /**
+     * Factor the present cost is multiplied by after each round.
+     * @type {number}
+     */
+    present_growth = 2;
+
+    /**
+     * What a vertex remembers, per round, about having been fought over.
+     *
+     * Present cost alone oscillates: two wires swap places every round, each taking the route the
+     * other just left. History is what breaks the tie — a vertex that has been contested stays
+     * expensive even once it is free, so the pair separates instead of trading.
+     *
+     * @type {number}
+     */
+    history_rate = 4;
+
+    /**
+     * Largest radius a corner of a route is rounded by when it becomes a curve.
+     *
+     * The actual radius is this or half the shorter of the two legs, whichever is smaller, so a
+     * short jog becomes a single smooth S and a long run stays straight until it turns.
+     *
+     * @type {number}
+     */
+    corner_radius = 30;
+
+    /**
+     * Ordering passes over the layers.
+     * @type {number}
+     */
+    order_sweeps = 8;
+
+    /**
+     * Ceiling on the routing grid, in vertices.
+     *
+     * The grid is the product of two coordinate lists, so it grows as the square of the graph. Past
+     * this the port lines are dropped and wires reach their ports by a stub instead — a slightly
+     * worse drawing, rather than a layout that takes a minute.
+     *
+     * @type {number}
+     */
+    max_grid_vertices = 1 << 18;
+
+    /**
+     * Ceiling on the states one route may expand before it gives up and takes a direct path.
+     *
+     * A route that cannot be found is not worth an unbounded search; the graph it is in is one the
+     * router has already failed to make readable.
+     *
+     * @type {number}
+     */
+    max_route_expansions = 200000;
+
+    /**
+     * @param {Partial<NodeGraphLayoutOptions>} [overrides]
+     * @returns {NodeGraphLayoutOptions}
+     */
+    static from(overrides) {
+        const r = new NodeGraphLayoutOptions();
+
+        if (overrides !== undefined) {
+            for (const key in overrides) {
+                if (key in r) {
+                    r[key] = overrides[key];
+                }
+            }
+        }
+
+        return r;
+    }
+}

package/src/core/model/node-graph/visual/layout/RouteGrid.d.ts

@@ -0,0 +1,137 @@
+/**
+ * The space wires are allowed to occupy.
+ *
+ * A **sparse grid**: not a fine mesh over the drawing, but the few horizontal and vertical lines
+ * that are actually worth travelling along — the edges of the boxes and a margin around them, the
+ * heights the ports sit at, the lanes the layout reserved for wires passing through a column, and a
+ * handful of tracks across each channel. Every route that is worth having runs along some of these
+ * and turns where two of them meet, so a grid made of only these has every good route in it and is
+ * a hundredth the size of a mesh fine enough to hold them.
+ *
+ * This is the Hanan grid of the obstacles, which is the standard construction: for a set of
+ * rectangles, an optimal rectilinear route between any two points on it exists on the grid their
+ * own edges induce, so nothing is lost by refusing to leave it.
+ *
+ * **Obstacles block edges, not vertices.** A wire crosses a box by travelling along a line that
+ * passes through it, and whether that is possible is a property of the line between two grid
+ * points rather than of the points themselves — both ends of a line straddling a box are outside
+ * it. Marking the crossing itself is what makes a box solid, and it is also what lets the grid stay
+ * sparse: a grid that had to make every crossing land on a blocked vertex would need a line at
+ * every box edge, and there are four of those per box.
+ *
+ * **Occupancy is per edge as well**, for the same reason: two wires sharing a length of line
+ * overlap and are drawn on top of each other, and two wires meeting at a point merely cross, which
+ * is legal and costs the reader nothing. Counting points would make the router pay to avoid a
+ * crossing and then take a detour to do it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class RouteGrid {
+    /**
+     * Index of the grid line at or immediately below `value`.
+     *
+     * Clamped rather than reported as absent: a point off the end of the grid belongs to the line at
+     * that end, which is what every caller here wants and what a bare lower bound does not say.
+     *
+     * @param {Float64Array} axis
+     * @param {number} value
+     * @returns {number}
+     */
+    static floor_index(axis: Float64Array, value: number): number;
+    /**
+     * Index of the grid line nearest `value`.
+     *
+     * @param {Float64Array} axis
+     * @param {number} value
+     * @returns {number}
+     */
+    static nearest_index(axis: Float64Array, value: number): number;
+    /**
+     * @param {Float64Array} xs ascending, distinct
+     * @param {Float64Array} ys ascending, distinct
+     */
+    constructor(xs: Float64Array, ys: Float64Array);
+    /**
+     * Ascending, distinct.
+     * @type {Float64Array}
+     */
+    xs: Float64Array;
+    /**
+     * @type {Float64Array}
+     */
+    ys: Float64Array;
+    /**
+     * @type {number}
+     */
+    nx: number;
+    /**
+     * @type {number}
+     */
+    ny: number;
+    /**
+     * @type {number}
+     */
+    vertex_count: number;
+    /**
+     * Whether the line from vertex `v` to the vertex right of it passes through a box.
+     * @type {BitSet}
+     */
+    blocked_h: BitSet;
+    /**
+     * Whether the line from vertex `v` to the vertex below it passes through a box.
+     * @type {BitSet}
+     */
+    blocked_v: BitSet;
+    /**
+     * Wires currently occupying each rightward line.
+     * @type {Int32Array}
+     */
+    use_h: Int32Array;
+    /**
+     * @type {Int32Array}
+     */
+    use_v: Int32Array;
+    /**
+     * What each rightward line remembers about having been fought over. See
+     * {@link NodeGraphLayoutOptions#history_rate}.
+     * @type {Float32Array}
+     */
+    history_h: Float32Array;
+    /**
+     * @type {Float32Array}
+     */
+    history_v: Float32Array;
+    /**
+     * Forget every route, keeping the obstacles and everything the grid has learned about
+     * congestion. This is what a round of rip-up and reroute starts with.
+     * @returns {void}
+     */
+    clear_use(): void;
+    /**
+     * @param {number} x
+     * @returns {number}
+     */
+    nearest_x(x: number): number;
+    /**
+     * @param {number} y
+     * @returns {number}
+     */
+    nearest_y(y: number): number;
+    /**
+     * Mark every line crossing the given rectangle as impassable.
+     *
+     * A line is impassable when it enters the rectangle's interior. Lines running exactly along an
+     * edge of it are left alone: the rectangle handed here is already the box grown by its
+     * clearance, so its edges are where a wire is meant to run.
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     * @returns {void}
+     */
+    block_rectangle(x0: number, y0: number, x1: number, y1: number): void;
+}
+import { BitSet } from "../../../../binary/BitSet.js";
+//# sourceMappingURL=RouteGrid.d.ts.map

package/src/core/model/node-graph/visual/layout/RouteGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouteGrid.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/RouteGrid.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAmGI;;;;;;;;;OASG;IACH,yBAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;OAMG;IACH,2BAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAUlB;IApED;;;OAGG;IACH,gBAHW,YAAY,MACZ,YAAY,EAsBtB;IArFD;;;OAGG;IACH,IAFU,YAAY,CAEnB;IAEH;;OAEG;IACH,IAFU,YAAY,CAEnB;IAEH;;OAEG;IACH,IAFU,MAAM,CAET;IAEP;;OAEG;IACH,IAFU,MAAM,CAET;IAEP;;OAEG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,OAFU,UAAU,CAEd;IAEN;;OAEG;IACH,OAFU,UAAU,CAEd;IAEN;;;;OAIG;IACH,WAFU,YAAY,CAEZ;IAEV;;OAEG;IACH,WAFU,YAAY,CAEZ;IA4BV;;;;OAIG;IACH,aAFa,IAAI,CAKhB;IAoCD;;;OAGG;IACH,aAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;OAYG;IACH,oBANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CA6ChB;CACJ;uBAjPsB,8BAA8B"}

package/src/core/model/node-graph/visual/layout/RouteGrid.js

@@ -0,0 +1,242 @@
+import { BitSet } from "../../../../binary/BitSet.js";
+import { binarySearchLowIndex } from "../../../../collection/array/binarySearchLowIndex.js";
+import { isValueBetween } from "../../../../math/interval/isValueBetween.js";
+import { overlap1D } from "../../../../math/interval/overlap1D.js";
+import { number_compare_ascending } from "../../../../primitives/numbers/number_compare_ascending.js";
+
+/**
+ * The space wires are allowed to occupy.
+ *
+ * A **sparse grid**: not a fine mesh over the drawing, but the few horizontal and vertical lines
+ * that are actually worth travelling along — the edges of the boxes and a margin around them, the
+ * heights the ports sit at, the lanes the layout reserved for wires passing through a column, and a
+ * handful of tracks across each channel. Every route that is worth having runs along some of these
+ * and turns where two of them meet, so a grid made of only these has every good route in it and is
+ * a hundredth the size of a mesh fine enough to hold them.
+ *
+ * This is the Hanan grid of the obstacles, which is the standard construction: for a set of
+ * rectangles, an optimal rectilinear route between any two points on it exists on the grid their
+ * own edges induce, so nothing is lost by refusing to leave it.
+ *
+ * **Obstacles block edges, not vertices.** A wire crosses a box by travelling along a line that
+ * passes through it, and whether that is possible is a property of the line between two grid
+ * points rather than of the points themselves — both ends of a line straddling a box are outside
+ * it. Marking the crossing itself is what makes a box solid, and it is also what lets the grid stay
+ * sparse: a grid that had to make every crossing land on a blocked vertex would need a line at
+ * every box edge, and there are four of those per box.
+ *
+ * **Occupancy is per edge as well**, for the same reason: two wires sharing a length of line
+ * overlap and are drawn on top of each other, and two wires meeting at a point merely cross, which
+ * is legal and costs the reader nothing. Counting points would make the router pay to avoid a
+ * crossing and then take a detour to do it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class RouteGrid {
+
+    /**
+     * Ascending, distinct.
+     * @type {Float64Array}
+     */
+    xs;
+
+    /**
+     * @type {Float64Array}
+     */
+    ys;
+
+    /**
+     * @type {number}
+     */
+    nx = 0;
+
+    /**
+     * @type {number}
+     */
+    ny = 0;
+
+    /**
+     * @type {number}
+     */
+    vertex_count = 0;
+
+    /**
+     * Whether the line from vertex `v` to the vertex right of it passes through a box.
+     * @type {BitSet}
+     */
+    blocked_h = new BitSet();
+
+    /**
+     * Whether the line from vertex `v` to the vertex below it passes through a box.
+     * @type {BitSet}
+     */
+    blocked_v = new BitSet();
+
+    /**
+     * Wires currently occupying each rightward line.
+     * @type {Int32Array}
+     */
+    use_h;
+
+    /**
+     * @type {Int32Array}
+     */
+    use_v;
+
+    /**
+     * What each rightward line remembers about having been fought over. See
+     * {@link NodeGraphLayoutOptions#history_rate}.
+     * @type {Float32Array}
+     */
+    history_h;
+
+    /**
+     * @type {Float32Array}
+     */
+    history_v;
+
+    /**
+     * @param {Float64Array} xs ascending, distinct
+     * @param {Float64Array} ys ascending, distinct
+     */
+    constructor(xs, ys) {
+        this.xs = xs;
+        this.ys = ys;
+
+        this.nx = xs.length;
+        this.ny = ys.length;
+
+        this.vertex_count = this.nx * this.ny;
+
+        this.blocked_h.preventShrink();
+        this.blocked_v.preventShrink();
+
+        this.blocked_h.setCapacity(this.vertex_count);
+        this.blocked_v.setCapacity(this.vertex_count);
+
+        this.use_h = new Int32Array(this.vertex_count);
+        this.use_v = new Int32Array(this.vertex_count);
+
+        this.history_h = new Float32Array(this.vertex_count);
+        this.history_v = new Float32Array(this.vertex_count);
+    }
+
+    /**
+     * Forget every route, keeping the obstacles and everything the grid has learned about
+     * congestion. This is what a round of rip-up and reroute starts with.
+     * @returns {void}
+     */
+    clear_use() {
+        this.use_h.fill(0);
+        this.use_v.fill(0);
+    }
+
+    /**
+     * Index of the grid line at or immediately below `value`.
+     *
+     * Clamped rather than reported as absent: a point off the end of the grid belongs to the line at
+     * that end, which is what every caller here wants and what a bare lower bound does not say.
+     *
+     * @param {Float64Array} axis
+     * @param {number} value
+     * @returns {number}
+     */
+    static floor_index(axis, value) {
+        const found = binarySearchLowIndex(axis, value, number_compare_ascending);
+
+        // below every line
+        return found === -1 ? 0 : found;
+    }
+
+    /**
+     * Index of the grid line nearest `value`.
+     *
+     * @param {Float64Array} axis
+     * @param {number} value
+     * @returns {number}
+     */
+    static nearest_index(axis, value) {
+        const low = RouteGrid.floor_index(axis, value);
+
+        if (low + 1 >= axis.length) {
+            return low;
+        }
+
+        return value - axis[low] <= axis[low + 1] - value ? low : low + 1;
+    }
+
+    /**
+     * @param {number} x
+     * @returns {number}
+     */
+    nearest_x(x) {
+        return RouteGrid.nearest_index(this.xs, x);
+    }
+
+    /**
+     * @param {number} y
+     * @returns {number}
+     */
+    nearest_y(y) {
+        return RouteGrid.nearest_index(this.ys, y);
+    }
+
+    /**
+     * Mark every line crossing the given rectangle as impassable.
+     *
+     * A line is impassable when it enters the rectangle's interior. Lines running exactly along an
+     * edge of it are left alone: the rectangle handed here is already the box grown by its
+     * clearance, so its edges are where a wire is meant to run.
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     * @returns {void}
+     */
+    block_rectangle(x0, y0, x1, y1) {
+        const xs = this.xs;
+        const ys = this.ys;
+
+        const nx = this.nx;
+
+        // rightward lines: the line from column i covers [xs[i], xs[i+1]], and enters the rectangle
+        // when that overlaps (x0, x1) while its own height is strictly inside (y0, y1)
+        const column_first = RouteGrid.floor_index(xs, x0);
+        const row_first = RouteGrid.floor_index(ys, y0);
+        const column_last = RouteGrid.floor_index(xs, x1);
+        const row_last = RouteGrid.floor_index(ys, y1);
+
+        for (let j = row_first; j <= row_last && j < this.ny; j++) {
+            if (!isValueBetween(ys[j], y0, y1)) {
+                // the line runs along or outside an edge, which is where a wire is meant to be
+                continue;
+            }
+
+            const row = j * nx;
+
+            for (let i = column_first; i <= column_last && i + 1 < nx; i++) {
+                if (!overlap1D(xs[i], xs[i + 1], x0, x1)) {
+                    continue;
+                }
+
+                this.blocked_h.set(row + i, true);
+            }
+        }
+
+        for (let i = column_first; i <= column_last && i < nx; i++) {
+            if (!isValueBetween(xs[i], x0, x1)) {
+                continue;
+            }
+
+            for (let j = row_first; j <= row_last && j + 1 < this.ny; j++) {
+                if (!overlap1D(ys[j], ys[j + 1], y0, y1)) {
+                    continue;
+                }
+
+                this.blocked_v.set(j * nx + i, true);
+            }
+        }
+    }
+}

package/src/core/model/node-graph/visual/layout/RouteSearch.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Travelling along a line of constant y.
+ * @type {number}
+ */
+export const ROUTE_AXIS_H: number;
+/**
+ * Travelling along a line of constant x.
+ * @type {number}
+ */
+export const ROUTE_AXIS_V: number;
+/**
+ * One wire's path through the grid, found by A*.
+ *
+ * **A state is a vertex together with the direction the wire arrived in**, not a vertex alone.
+ * Turning costs something here — it has to, or the shortest route is a staircase and the drawing
+ * is unreadable — and a cost that depends on how you arrived is a cost the search cannot see
+ * unless arriving is part of what it searches over. Two states per vertex is the whole price of
+ * that: the wire cares which axis it is on, not which of the two ways along it.
+ *
+ * **The scratch outlives the search.** A route is found several hundred times over one layout — once
+ * per wire, once per round of rip-up — and the arrays it needs are the size of the grid. Clearing
+ * them each time costs more than the search does, so the scores carry a stamp instead and a score
+ * left over from a previous route reads as absent rather than as a very good one.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class RouteSearch {
+    /**
+     * @param {RouteGrid} grid
+     */
+    constructor(grid: RouteGrid);
+    /**
+     * @type {RouteGrid}
+     */
+    grid: RouteGrid;
+    /**
+     * @type {Uint32Heap}
+     */
+    open: Uint32Heap;
+    /**
+     * @type {BitSet}
+     */
+    closed: BitSet;
+    /**
+     * Cost to reach each state, meaningful only where `stamp` matches the current search.
+     * @type {Float64Array}
+     */
+    score: Float64Array;
+    /**
+     * @type {Int32Array}
+     */
+    stamp: Int32Array;
+    /**
+     * @type {Int32Array}
+     */
+    came_from: Int32Array;
+    /**
+     * @type {number}
+     */
+    generation: number;
+    /**
+     * Vertices of the route just found, from start to goal.
+     * @type {Int32Array}
+     */
+    path: Int32Array;
+    /**
+     * @type {number}
+     */
+    path_length: number;
+    /**
+     * Find a wire's way from one vertex to another.
+     *
+     * The cost being minimised is length, plus a fixed price per turn, plus what the grid charges
+     * for lines other wires are already on. The estimate driving the search is the straight
+     * rectilinear distance remaining, which never exceeds what the route will actually cost — turns
+     * and congestion only ever add — so the first route found is the cheapest one.
+     *
+     * @param {number} start vertex
+     * @param {number} start_axis the axis the wire is already travelling on as it arrives here,
+     *        one of {@link ROUTE_AXIS_H}, {@link ROUTE_AXIS_V}
+     * @param {number} goal vertex
+     * @param {number} goal_axis the axis the wire must be on to meet the port it is heading for
+     * @param {NodeGraphLayoutOptions} options
+     * @returns {boolean} whether a route was found. The route is left in {@link path}.
+     */
+    find(start: number, start_axis: number, goal: number, goal_axis: number, options: NodeGraphLayoutOptions): boolean;
+    /**
+     * @param {number} from state
+     * @param {number} from_cost
+     * @param {number} from_axis
+     * @param {number} vertex being moved to
+     * @param {number} axis being moved along
+     * @param {number} goal
+     * @param {number} goal_axis
+     * @param {number} bend
+     * @param {NodeGraphLayoutOptions} options
+     * @param {number} step what the move itself costs
+     * @param {number} remaining estimate from `vertex` to the goal
+     * @param {number} generation
+     * @returns {void}
+     * @private
+     */
+    private __relax;
+    /**
+     * @param {number} state the goal, reached
+     * @returns {boolean}
+     * @private
+     */
+    private __unwind;
+}
+import { Uint32Heap } from "../../../../collection/heap/Uint32Heap.js";
+import { BitSet } from "../../../../binary/BitSet.js";
+//# sourceMappingURL=RouteSearch.d.ts.map

package/src/core/model/node-graph/visual/layout/RouteSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouteSearch.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/RouteSearch.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,2BAFU,MAAM,CAEc;AAE9B;;;GAGG;AACH,2BAFU,MAAM,CAEc;AAE9B;;;;;;;;;;;;;;;;GAgBG;AACH;IAiDI;;OAEG;IACH,6BAeC;IAjED;;OAEG;IACH,gBAAY;IAEZ;;OAEG;IACH,MAFU,UAAU,CAEQ;IAE5B;;OAEG;IACH,QAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,OAFU,YAAY,CAEhB;IAEN;;OAEG;IACH,OAFU,UAAU,CAEd;IAEN;;OAEG;IACH,WAFU,UAAU,CAEV;IAEV;;OAEG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,MAFU,UAAU,CAEf;IAEL;;OAEG;IACH,aAFU,MAAM,CAEA;IAsBhB;;;;;;;;;;;;;;;OAeG;IACH,YARW,MAAM,cACN,MAAM,QAEN,MAAM,aACN,MAAM,oCAEJ,OAAO,CAyGnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBA8BC;IAED;;;;OAIG;IACH,iBAuBC;CACJ;2BA1S0B,2CAA2C;uBAD/C,8BAA8B"}