@woosh/meep-engine 3.14.6 → 3.16.0

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

@@ -0,0 +1,288 @@
+import { assert } from "../../../../assert.js";
+
+/**
+ * A box standing for a node of the graph.
+ * @type {number}
+ */
+export const LAYOUT_BOX_NODE = 0;
+
+/**
+ * A box standing for one column's worth of a wire that is only passing through.
+ *
+ * It is not drawn. Its whole purpose is to occupy room in a column so that the ordering and
+ * coordinate stages leave a lane for the wire, rather than packing the boxes tight and letting the
+ * wire be drawn across them.
+ *
+ * @type {number}
+ */
+export const LAYOUT_BOX_LANE = 1;
+
+/**
+ * The placement problem, flat.
+ *
+ * Boxes and the links between them, and nothing about node graphs: no ports, no data types, no
+ * connection identity. Every placement stage — cycles, layers, ordering, coordinates — reads and
+ * writes this and only this, which is what keeps them testable against a hand-written graph and
+ * reusable for anything else that needs boxes arranged in columns.
+ *
+ * A **link** is one column boundary crossed by one wire. An edge of the source graph that spans
+ * several columns is several links joined by lane boxes, so every link here connects boxes in
+ * adjacent columns and every stage can assume that.
+ *
+ * Links carry the height *within* each box at which they attach, because that is where the wire is
+ * actually drawn and it is not the middle: a node twelve ports tall is joined near its top by one
+ * edge and near its bottom by another, and lining up the two boxes' middles lines up nothing a
+ * reader can see.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class LayoutBoxGraph {
+
+    /**
+     * @type {number}
+     */
+    box_count = 0;
+
+    /**
+     * Left edge of each box. Written by the coordinate stage.
+     * @type {Float64Array}
+     */
+    box_x;
+
+    /**
+     * Top edge of each box. Written by the coordinate stage.
+     * @type {Float64Array}
+     */
+    box_y;
+
+    /**
+     * @type {Float64Array}
+     */
+    box_w;
+
+    /**
+     * @type {Float64Array}
+     */
+    box_h;
+
+    /**
+     * Column each box sits in. Written by the layering stage.
+     * @type {Int32Array}
+     */
+    box_layer;
+
+    /**
+     * One of {@link LAYOUT_BOX_NODE}, {@link LAYOUT_BOX_LANE}.
+     * @type {Uint8Array}
+     */
+    box_kind;
+
+    /**
+     * @type {number}
+     */
+    link_count = 0;
+
+    /**
+     * @type {Int32Array}
+     */
+    link_from;
+
+    /**
+     * @type {Int32Array}
+     */
+    link_to;
+
+    /**
+     * Offset down the source box at which the link leaves it.
+     * @type {Float64Array}
+     */
+    link_from_y;
+
+    /**
+     * Offset down the target box at which the link arrives.
+     * @type {Float64Array}
+     */
+    link_to_y;
+
+    /**
+     * Start of each box's outgoing links in {@link out_link}. Length `box_count + 1`.
+     * @type {Int32Array}
+     */
+    out_offset;
+
+    /**
+     * @type {Int32Array}
+     */
+    out_link;
+
+    /**
+     * @type {Int32Array}
+     */
+    in_offset;
+
+    /**
+     * @type {Int32Array}
+     */
+    in_link;
+
+    /**
+     * @param {number} box_count
+     * @param {number} link_count
+     */
+    constructor(box_count = 0, link_count = 0) {
+        this.resize(box_count, link_count);
+    }
+
+    /**
+     * Give the graph a new size, keeping whatever fits.
+     *
+     * Growing happens exactly once, when the number of lane boxes becomes known — the layering
+     * stage settles it, and until then it cannot be predicted. Everything else works in place.
+     *
+     * @param {number} box_count
+     * @param {number} link_count
+     * @returns {void}
+     */
+    resize(box_count, link_count) {
+        assert.isNonNegativeInteger(box_count, 'box_count');
+        assert.isNonNegativeInteger(link_count, 'link_count');
+
+        this.box_x = grow(this.box_x, box_count, Float64Array);
+        this.box_y = grow(this.box_y, box_count, Float64Array);
+        this.box_w = grow(this.box_w, box_count, Float64Array);
+        this.box_h = grow(this.box_h, box_count, Float64Array);
+        this.box_layer = grow(this.box_layer, box_count, Int32Array);
+        this.box_kind = grow(this.box_kind, box_count, Uint8Array);
+
+        this.link_from = grow(this.link_from, link_count, Int32Array);
+        this.link_to = grow(this.link_to, link_count, Int32Array);
+        this.link_from_y = grow(this.link_from_y, link_count, Float64Array);
+        this.link_to_y = grow(this.link_to_y, link_count, Float64Array);
+
+        this.box_count = box_count;
+        this.link_count = link_count;
+
+        // adjacency describes a size that no longer holds
+        this.out_offset = undefined;
+        this.in_offset = undefined;
+    }
+
+    /**
+     * @param {number} index
+     * @param {number} width
+     * @param {number} height
+     * @param {number} kind
+     * @returns {void}
+     */
+    set_box(index, width, height, kind) {
+        this.box_w[index] = width;
+        this.box_h[index] = height;
+        this.box_kind[index] = kind;
+    }
+
+    /**
+     * @param {number} index
+     * @param {number} from box
+     * @param {number} to box
+     * @param {number} from_y offset down `from`
+     * @param {number} to_y offset down `to`
+     * @returns {void}
+     */
+    set_link(index, from, to, from_y, to_y) {
+        this.link_from[index] = from;
+        this.link_to[index] = to;
+        this.link_from_y[index] = from_y;
+        this.link_to_y[index] = to_y;
+    }
+
+    /**
+     * Rebuild the adjacency indices from the link arrays.
+     *
+     * Called after anything that changes the links, and by the stages that walk them. Counting
+     * sort, so it is one pass to count and one to fill and it allocates nothing beyond the two
+     * pairs of arrays it hands back.
+     *
+     * @returns {void}
+     */
+    build_adjacency() {
+        const box_count = this.box_count;
+        const link_count = this.link_count;
+
+        const out_offset = grow(this.out_offset, box_count + 1, Int32Array);
+        const in_offset = grow(this.in_offset, box_count + 1, Int32Array);
+
+        out_offset.fill(0, 0, box_count + 1);
+        in_offset.fill(0, 0, box_count + 1);
+
+        for (let i = 0; i < link_count; i++) {
+            out_offset[this.link_from[i] + 1]++;
+            in_offset[this.link_to[i] + 1]++;
+        }
+
+        for (let i = 0; i < box_count; i++) {
+            out_offset[i + 1] += out_offset[i];
+            in_offset[i + 1] += in_offset[i];
+        }
+
+        const out_link = grow(this.out_link, link_count, Int32Array);
+        const in_link = grow(this.in_link, link_count, Int32Array);
+
+        // cursors, restored to offsets afterwards
+        const out_cursor = out_offset.slice(0, box_count);
+        const in_cursor = in_offset.slice(0, box_count);
+
+        for (let i = 0; i < link_count; i++) {
+            out_link[out_cursor[this.link_from[i]]++] = i;
+            in_link[in_cursor[this.link_to[i]]++] = i;
+        }
+
+        this.out_offset = out_offset;
+        this.out_link = out_link;
+        this.in_offset = in_offset;
+        this.in_link = in_link;
+    }
+
+    /**
+     * @param {number} box
+     * @returns {number}
+     */
+    out_degree(box) {
+        return this.out_offset[box + 1] - this.out_offset[box];
+    }
+
+    /**
+     * @param {number} box
+     * @returns {number}
+     */
+    in_degree(box) {
+        return this.in_offset[box + 1] - this.in_offset[box];
+    }
+}
+
+/**
+ * A typed array of at least `length`, keeping whatever the old one held.
+ *
+ * Every collection in the tree that grows a typed array carries its own version of this — see
+ * `Uint32Heap.__capacity_grow` and `Uint32Map` — and there is no shared one to call. This is the
+ * same three lines, written once here rather than once per array.
+ *
+ * @template {Float64Array|Int32Array|Uint8Array} T
+ * @param {T|undefined} source
+ * @param {number} length
+ * @param {function(new: T, number)} Type
+ * @returns {T}
+ */
+function grow(source, length, Type) {
+    if (source !== undefined && source.length >= length) {
+        return source;
+    }
+
+    const result = new Type(length);
+
+    if (source !== undefined) {
+        result.set(source);
+    }
+
+    return result;
+}

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

@@ -0,0 +1,109 @@
+/**
+ * Which edge of a box a point on it belongs to.
+ *
+ * Taken from the geometry rather than from the port's declared direction, because the two can
+ * disagree and it is the geometry that decides where the wire has to arrive from. A port drawn
+ * along the bottom of a node is reached from below whatever the graph calls it.
+ *
+ * @param {number} dx offset from the box's left edge
+ * @param {number} dy offset from the box's top edge
+ * @param {number} width
+ * @param {number} height
+ * @returns {number} one of the `LAYOUT_SIDE_*` values
+ */
+export function layout_side_of(dx: number, dy: number, width: number, height: number): number;
+/**
+ * Port on the left edge of its box — a wire reaches it travelling right.
+ * @type {number}
+ */
+export const LAYOUT_SIDE_LEFT: number;
+/**
+ * @type {number}
+ */
+export const LAYOUT_SIDE_RIGHT: number;
+/**
+ * @type {number}
+ */
+export const LAYOUT_SIDE_TOP: number;
+/**
+ * @type {number}
+ */
+export const LAYOUT_SIDE_BOTTOM: number;
+/**
+ * Everything one run of the layout works on, flat.
+ *
+ * Two things live here that the placement stages have no use for and the router cannot do without:
+ * the **connections**, which are what actually gets drawn, and where on its box each of them
+ * attaches. The placement stages see only {@link LayoutBoxGraph}, which is boxes and links between
+ * them and nothing else; a connection spanning four columns is four links there, and a connection
+ * from a node to itself is no link at all. Neither is something the router can draw.
+ *
+ * Connections are held in ascending order of their id rather than in whatever order the graph
+ * happened to hand them over. The router visits them in that order and its result depends on the
+ * order, so this is what makes the same graph produce the same drawing twice.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class LayoutProblem {
+    /**
+     * @type {LayoutBoxGraph}
+     */
+    boxes: LayoutBoxGraph;
+    /**
+     * Boxes standing for real nodes. They are the first `node_count` of `boxes`; everything past
+     * them is a lane and is not drawn.
+     * @type {number}
+     */
+    node_count: number;
+    /**
+     * Node id of each of the first `node_count` boxes.
+     * @type {Int32Array}
+     */
+    node_of_box: Int32Array;
+    /**
+     * @type {number}
+     */
+    connection_count: number;
+    /**
+     * @type {Int32Array}
+     */
+    connection_id: Int32Array;
+    /**
+     * Box the connection leaves.
+     * @type {Int32Array}
+     */
+    from_box: Int32Array;
+    /**
+     * @type {Int32Array}
+     */
+    to_box: Int32Array;
+    /**
+     * Where on its box the connection leaves, as an offset from the box's top left corner. Held
+     * relative rather than absolute because placement moves the boxes afterwards.
+     * @type {Float64Array}
+     */
+    from_dx: Float64Array;
+    /**
+     * @type {Float64Array}
+     */
+    from_dy: Float64Array;
+    /**
+     * @type {Float64Array}
+     */
+    to_dx: Float64Array;
+    /**
+     * @type {Float64Array}
+     */
+    to_dy: Float64Array;
+    /**
+     * Which edge of its box the connection leaves by, one of the `LAYOUT_SIDE_*` values.
+     * @type {Uint8Array}
+     */
+    from_side: Uint8Array;
+    /**
+     * @type {Uint8Array}
+     */
+    to_side: Uint8Array;
+}
+//# sourceMappingURL=LayoutProblem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LayoutProblem.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/LayoutProblem.js"],"names":[],"mappings":"AAgHA;;;;;;;;;;;;GAYG;AACH,mCANW,MAAM,MACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,MAAM,CAiBlB;AA5ID;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;GAEG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;GAEG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;GAEG;AACH,iCAFU,MAAM,CAEoB;AAEpC;;;;;;;;;;;;;;;GAeG;AACH;IAEI;;OAEG;IACH,sBAAa;IAEb;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,aAFU,UAAU,CAED;IAEnB;;OAEG;IACH,kBAFU,MAAM,CAEK;IAErB;;OAEG;IACH,eAFU,UAAU,CAEC;IAErB;;;OAGG;IACH,UAFU,UAAU,CAEJ;IAEhB;;OAEG;IACH,QAFU,UAAU,CAEN;IAEd;;;;OAIG;IACH,SAFU,YAAY,CAEP;IAEf;;OAEG;IACH,SAFU,YAAY,CAEP;IAEf;;OAEG;IACH,OAFU,YAAY,CAET;IAEb;;OAEG;IACH,OAFU,YAAY,CAET;IAEb;;;OAGG;IACH,WAFU,UAAU,CAEH;IAEjB;;OAEG;IACH,SAFU,UAAU,CAEL;CAClB"}

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

@@ -0,0 +1,141 @@
+/**
+ * Port on the left edge of its box — a wire reaches it travelling right.
+ * @type {number}
+ */
+export const LAYOUT_SIDE_LEFT = 0;
+
+/**
+ * @type {number}
+ */
+export const LAYOUT_SIDE_RIGHT = 1;
+
+/**
+ * @type {number}
+ */
+export const LAYOUT_SIDE_TOP = 2;
+
+/**
+ * @type {number}
+ */
+export const LAYOUT_SIDE_BOTTOM = 3;
+
+/**
+ * Everything one run of the layout works on, flat.
+ *
+ * Two things live here that the placement stages have no use for and the router cannot do without:
+ * the **connections**, which are what actually gets drawn, and where on its box each of them
+ * attaches. The placement stages see only {@link LayoutBoxGraph}, which is boxes and links between
+ * them and nothing else; a connection spanning four columns is four links there, and a connection
+ * from a node to itself is no link at all. Neither is something the router can draw.
+ *
+ * Connections are held in ascending order of their id rather than in whatever order the graph
+ * happened to hand them over. The router visits them in that order and its result depends on the
+ * order, so this is what makes the same graph produce the same drawing twice.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class LayoutProblem {
+
+    /**
+     * @type {LayoutBoxGraph}
+     */
+    boxes = null;
+
+    /**
+     * Boxes standing for real nodes. They are the first `node_count` of `boxes`; everything past
+     * them is a lane and is not drawn.
+     * @type {number}
+     */
+    node_count = 0;
+
+    /**
+     * Node id of each of the first `node_count` boxes.
+     * @type {Int32Array}
+     */
+    node_of_box = null;
+
+    /**
+     * @type {number}
+     */
+    connection_count = 0;
+
+    /**
+     * @type {Int32Array}
+     */
+    connection_id = null;
+
+    /**
+     * Box the connection leaves.
+     * @type {Int32Array}
+     */
+    from_box = null;
+
+    /**
+     * @type {Int32Array}
+     */
+    to_box = null;
+
+    /**
+     * Where on its box the connection leaves, as an offset from the box's top left corner. Held
+     * relative rather than absolute because placement moves the boxes afterwards.
+     * @type {Float64Array}
+     */
+    from_dx = null;
+
+    /**
+     * @type {Float64Array}
+     */
+    from_dy = null;
+
+    /**
+     * @type {Float64Array}
+     */
+    to_dx = null;
+
+    /**
+     * @type {Float64Array}
+     */
+    to_dy = null;
+
+    /**
+     * Which edge of its box the connection leaves by, one of the `LAYOUT_SIDE_*` values.
+     * @type {Uint8Array}
+     */
+    from_side = null;
+
+    /**
+     * @type {Uint8Array}
+     */
+    to_side = null;
+}
+
+/**
+ * Which edge of a box a point on it belongs to.
+ *
+ * Taken from the geometry rather than from the port's declared direction, because the two can
+ * disagree and it is the geometry that decides where the wire has to arrive from. A port drawn
+ * along the bottom of a node is reached from below whatever the graph calls it.
+ *
+ * @param {number} dx offset from the box's left edge
+ * @param {number} dy offset from the box's top edge
+ * @param {number} width
+ * @param {number} height
+ * @returns {number} one of the `LAYOUT_SIDE_*` values
+ */
+export function layout_side_of(dx, dy, width, height) {
+    // How near an edge a port has to be for that edge to be the one it belongs to, rather than the
+    // nearer of left and right. Ports are drawn on the edge they belong to, so this only has to be
+    // wide enough to survive the port's own radius.
+    const EDGE_BAND = 4;
+
+    if (dy <= EDGE_BAND && dx > EDGE_BAND && dx < width - EDGE_BAND) {
+        return LAYOUT_SIDE_TOP;
+    }
+
+    if (dy >= height - EDGE_BAND && dx > EDGE_BAND && dx < width - EDGE_BAND) {
+        return LAYOUT_SIDE_BOTTOM;
+    }
+
+    return dx * 2 <= width ? LAYOUT_SIDE_LEFT : LAYOUT_SIDE_RIGHT;
+}

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

@@ -0,0 +1,149 @@
+/**
+ * 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 {
+    /**
+     * @param {Partial<NodeGraphLayoutOptions>} [overrides]
+     * @returns {NodeGraphLayoutOptions}
+     */
+    static from(overrides?: Partial<NodeGraphLayoutOptions>): 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: number;
+    /**
+     * Vertical gap between two node boxes sharing a column.
+     * @type {number}
+     */
+    node_gap: number;
+    /**
+     * 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: number;
+    /**
+     * 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: number;
+    /**
+     * 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: number;
+    /**
+     * 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: number;
+    /**
+     * 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: number;
+    /**
+     * 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: number;
+    /**
+     * Factor the present cost is multiplied by after each round.
+     * @type {number}
+     */
+    present_growth: number;
+    /**
+     * 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: number;
+    /**
+     * 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: number;
+    /**
+     * Ordering passes over the layers.
+     * @type {number}
+     */
+    order_sweeps: number;
+    /**
+     * 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: number;
+    /**
+     * 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: number;
+}
+//# sourceMappingURL=NodeGraphLayoutOptions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NodeGraphLayoutOptions.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/NodeGraphLayoutOptions.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH;IAkJI;;;OAGG;IACH,wBAHW,QAAQ,sBAAsB,CAAC,GAC7B,sBAAsB,CAclC;IAhKD;;;;;;;OAOG;IACH,WAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,MAAM,CAEF;IAEd;;;;;;;OAOG;IACH,UAFU,MAAM,CAEF;IAEd;;;;;;;;;;OAUG;IACH,WAFU,MAAM,CAED;IAEf;;;;;;;;OAQG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;;;;;;OASG;IACH,cAFU,MAAM,CAEE;IAElB;;;;;;;;;;;;;OAaG;IACH,uBAFU,MAAM,CAEU;IAE1B;;;;;;;;;OASG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;;;;;OAQG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;;;OAOG;IACH,eAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEY;IAE5B;;;;;;;OAOG;IACH,sBAFU,MAAM,CAEc;CAmBjC"}