@woosh/meep-engine 3.21.0 → 3.22.0

package/editor/view/library/MeshLibraryView.js

@@ -23,8 +23,9 @@ const CELL_GAP_Y = 8;
 class MeshAssetView extends View {
     /**
      *
-     * @param {string} url
-     * @param {Promise<ModelThumbnailSource>} thumbnails
+     * @param {Object} options
+     * @param {string} options.url
+     * @param {Promise<ModelThumbnailSource>} options.thumbnails
      * @constructor
      */
     constructor({ url, thumbnails }) {

package/editor/view/node-graph/NodeIconView.d.ts

@@ -17,9 +17,12 @@ export class NodeIconView extends View {
     /**
      * @param {string} icon SVG path data, see {@link NodeDescription#icon}. Several sub-paths in
      *        one string are fine — that is one `d` attribute, and how most glyphs here are drawn.
-     * @param {string[]} [classList]
+     * @param {Object} [options]
+     * @param {string[]} [options.classList]
      */
-    constructor(icon: string, { classList }?: string[]);
+    constructor(icon: string, { classList }?: {
+        classList?: string[];
+    });
     el: SVGSVGElement;
 }
 /**

package/editor/view/node-graph/NodeIconView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeIconView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/NodeIconView.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;;OAIG;IACH,kBAJW,MAAM,kBAEN,MAAM,EAAE,EAsBlB;IAJG,kBAAa;CAKpB;AAED;;;;;GAKG;AACH,4BAFU,MAAM,CAEyB;iBApDxB,2BAA2B"}
+{"version":3,"file":"NodeIconView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/NodeIconView.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;;;OAKG;IACH,kBALW,MAAM;QAGa,SAAS,GAA5B,MAAM,EAAE;OAsBlB;IAJG,kBAAa;CAKpB;AAED;;;;;GAKG;AACH,4BAFU,MAAM,CAEyB;iBArDxB,2BAA2B"}

package/editor/view/node-graph/NodeIconView.js

@@ -20,7 +20,8 @@ export class NodeIconView extends View {
     /**
      * @param {string} icon SVG path data, see {@link NodeDescription#icon}. Several sub-paths in
      *        one string are fine — that is one `d` attribute, and how most glyphs here are drawn.
-     * @param {string[]} [classList]
+     * @param {Object} [options]
+     * @param {string[]} [options.classList]
      */
     constructor(icon, { classList = [] } = {}) {
         super();

package/editor/view/node-graph/PortView.d.ts

@@ -14,11 +14,16 @@
 export class PortView extends View {
     /**
      *
-     * @param {Port} port
-     * @param {PortVisualData} visual
-     * @param {NodeGraphVisualData} visualData
+     * @param {Object} options
+     * @param {Port} options.port
+     * @param {PortVisualData} options.visual
+     * @param {NodeGraphVisualData} options.visualData
      */
-    constructor({ port, visual, visualData }: Port);
+    constructor({ port, visual, visualData }: {
+        port: Port;
+        visual: PortVisualData;
+        visualData: NodeGraphVisualData;
+    });
     el: HTMLDivElement;
     /**
      * The dot itself. What a wire is drawn to, and what {@link NodeView#measure} measures.

package/editor/view/node-graph/PortView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PortView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/PortView.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH;IAgBI;;;;;OAKG;IACH,gDAyCC;IA9DD,mBAAmC;IAEnC;;;;OAIG;IACH,iBAFU,WAAW,CAEd;IAEP;;;OAGG;IACH,UAFU,WAAS,IAAI,CAEP;IAiBZ;;;OAGG;IACH,WAAgB;IAChB;;;OAGG;IACH,uBAAoB;IACpB;;;OAGG;IACH,gCAA4B;IAoBhC;;;;;;;;;;OAUG;IACH,sCAsBC;CACJ;iBAvHgB,2BAA2B"}
+{"version":3,"file":"PortView.d.ts","sourceRoot":"","sources":["../../../../editor/view/node-graph/PortView.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH;IAgBI;;;;;;OAMG;IACH;QAJyB,IAAI;QACM,MAAM;QACD,UAAU;OA2CjD;IA/DD,mBAAmC;IAEnC;;;;OAIG;IACH,iBAFU,WAAW,CAEd;IAEP;;;OAGG;IACH,UAFU,WAAS,IAAI,CAEP;IAkBZ;;;OAGG;IACH,WAAgB;IAChB;;;OAGG;IACH,uBAAoB;IACpB;;;OAGG;IACH,gCAA4B;IAoBhC;;;;;;;;;;OAUG;IACH,sCAsBC;CACJ;iBAxHgB,2BAA2B"}

package/editor/view/node-graph/PortView.js

@@ -37,9 +37,10 @@ export class PortView extends View {
 
     /**
      *
-     * @param {Port} port
-     * @param {PortVisualData} visual
-     * @param {NodeGraphVisualData} visualData
+     * @param {Object} options
+     * @param {Port} options.port
+     * @param {PortVisualData} options.visual
+     * @param {NodeGraphVisualData} options.visualData
      */
     constructor({ port, visual, visualData }) {
         super();

package/editor/view/particles/ColorLutGradientView.d.ts

@@ -7,10 +7,14 @@
 export class ColorLutGradientView extends View {
     /**
      *
-     * @param {ParameterLookupTable} lut
-     * @param {number} [width]
+     * @param {Object} options
+     * @param {ParameterLookupTable} options.lut
+     * @param {number} [options.width]
      */
-    constructor({ lut, width }: ParameterLookupTable);
+    constructor({ lut, width }: {
+        lut: ParameterLookupTable;
+        width?: number;
+    });
     el: HTMLDivElement;
     render(): void;
     #private;

package/editor/view/particles/ColorLutGradientView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ColorLutGradientView.d.ts","sourceRoot":"","sources":["../../../../editor/view/particles/ColorLutGradientView.js"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH;IA+BI;;;;OAIG;IACH,kDAwCC;IAnCG,mBAAuC;IA+K3C,eA+CC;;CACJ;iBAjSgB,2BAA2B"}
+{"version":3,"file":"ColorLutGradientView.d.ts","sourceRoot":"","sources":["../../../../editor/view/particles/ColorLutGradientView.js"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH;IA+BI;;;;;OAKG;IACH;QAHyC,GAAG;QAChB,KAAK,GAAtB,MAAM;OA0ChB;IAnCG,mBAAuC;IA+K3C,eA+CC;;CACJ;iBAlSgB,2BAA2B"}

package/editor/view/particles/ColorLutGradientView.js

@@ -57,8 +57,9 @@ export class ColorLutGradientView extends View {
 
     /**
      *
-     * @param {ParameterLookupTable} lut
-     * @param {number} [width]
+     * @param {Object} options
+     * @param {ParameterLookupTable} options.lut
+     * @param {number} [options.width]
      */
     constructor({ lut, width = 220 }) {
         super();

package/editor/view/particles/ScalarLutCurveView.d.ts

@@ -6,11 +6,16 @@
 export class ScalarLutCurveView extends View {
     /**
      *
-     * @param {ParameterLookupTable} lut
-     * @param {number} [width]
-     * @param {number} [height]
+     * @param {Object} options
+     * @param {ParameterLookupTable} options.lut
+     * @param {number} [options.width]
+     * @param {number} [options.height]
      */
-    constructor({ lut, width, height }: ParameterLookupTable);
+    constructor({ lut, width, height }: {
+        lut: ParameterLookupTable;
+        width?: number;
+        height?: number;
+    });
     el: HTMLDivElement;
     render(): void;
     #private;

package/editor/view/particles/ScalarLutCurveView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScalarLutCurveView.d.ts","sourceRoot":"","sources":["../../../../editor/view/particles/ScalarLutCurveView.js"],"names":[],"mappings":"AAUA;;;;GAIG;AACH;IA4BI;;;;;OAKG;IACH,0DA6BC;IAxBG,mBAAuC;IAiL3C,eA8CC;;CACJ;iBApRgB,2BAA2B"}
+{"version":3,"file":"ScalarLutCurveView.d.ts","sourceRoot":"","sources":["../../../../editor/view/particles/ScalarLutCurveView.js"],"names":[],"mappings":"AAUA;;;;GAIG;AACH;IA4BI;;;;;;OAMG;IACH;QAJyC,GAAG;QAChB,KAAK,GAAtB,MAAM;QACW,MAAM,GAAvB,MAAM;OA+BhB;IAxBG,mBAAuC;IAiL3C,eA8CC;;CACJ;iBArRgB,2BAA2B"}

package/editor/view/particles/ScalarLutCurveView.js

@@ -43,9 +43,10 @@ export class ScalarLutCurveView extends View {
 
     /**
      *
-     * @param {ParameterLookupTable} lut
-     * @param {number} [width]
-     * @param {number} [height]
+     * @param {Object} options
+     * @param {ParameterLookupTable} options.lut
+     * @param {number} [options.width]
+     * @param {number} [options.height]
      */
     constructor({ lut, width = 220, height = 90 }) {
         super();

package/editor/view/particles/effect/ParticleEmitterInspectorView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleEmitterInspectorView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleEmitterInspectorView.js"],"names":[],"mappings":"AAyEA;IAkDI;;;OAGG;IACH;QAFyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;OAqC9F;IAhCG,mBAAuC;IAIvC;;OAEG;IACH,QAFU,OAAO,qDAAqD,EAAE,sBAAsB,CAE1E;IA2BxB;;;;;;OAMG;IACH,gBAiBC;;CAiZJ;iBAnkBgB,8BAA8B"}
+{"version":3,"file":"ParticleEmitterInspectorView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleEmitterInspectorView.js"],"names":[],"mappings":"AAwEA;IAkDI;;;OAGG;IACH;QAFyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;OAqC9F;IAhCG,mBAAuC;IAIvC;;OAEG;IACH,QAFU,OAAO,qDAAqD,EAAE,sBAAsB,CAE1E;IA2BxB;;;;;;OAMG;IACH,gBAiBC;;CAiZJ;iBAlkBgB,8BAA8B"}

package/editor/view/particles/effect/ParticleEmitterInspectorView.js

@@ -62,7 +62,6 @@ const NUMERIC_FIELDS = [
 const FLAG_FIELDS = [
     { key: "lighting", label: "lighting", help: "Forward-shade the billboards with scene lighting." },
     { key: "soft_depth", label: "soft depth", help: "Fade against scene depth instead of cutting into it." },
-    { key: "sort", label: "sort", help: "Depth-sort this emitter's particles." },
     {
         key: "cull",
         label: "cull",

package/editor/view/tools/ToolView.d.ts

@@ -2,11 +2,15 @@ export default ToolView;
 declare class ToolView extends View {
     /**
      *
-     * @param {Tool} tool
-     * @param {Editor} editor
+     * @param {Object} options
+     * @param {Tool} options.tool
+     * @param {Editor} options.editor
      * @constructor
      */
-    constructor({ tool, editor }: Tool);
+    constructor({ tool, editor }: {
+        tool: Tool;
+        editor: Editor;
+    });
     el: Element;
 }
 import View from "../../../src/view/View.js";

package/editor/view/tools/ToolView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolView.d.ts","sourceRoot":"","sources":["../../../../editor/view/tools/ToolView.js"],"names":[],"mappings":";AAKA;IACI;;;;;OAKG;IACH,oCAmCC;IAzBG,YAAkB;CA0BzB;iBA7CgB,2BAA2B"}
+{"version":3,"file":"ToolView.d.ts","sourceRoot":"","sources":["../../../../editor/view/tools/ToolView.js"],"names":[],"mappings":";AAKA;IACI;;;;;;OAMG;IACH;QAJyB,IAAI;QACF,MAAM;OAsChC;IAzBG,YAAkB;CA0BzB;iBA9CgB,2BAA2B"}

package/editor/view/tools/ToolView.js

@@ -6,8 +6,9 @@ import View from "../../../src/view/View.js";
 class ToolView extends View {
     /**
      *
-     * @param {Tool} tool
-     * @param {Editor} editor
+     * @param {Object} options
+     * @param {Tool} options.tool
+     * @param {Editor} options.editor
      * @constructor
      */
     constructor({ tool, editor }) {

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.21.0",
+  "version": "3.22.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",
@@ -59,6 +59,7 @@
     "@rollup/plugin-strip": "3.0.4",
     "@rollup/plugin-terser": "1.0.0",
     "@vitest/coverage-v8": "^5.0.0",
+    "@webgpu/types": "0.1.72",
     "jsdom": "^30.0.1",
     "rollup": "4.63.1",
     "typescript": "5.4.5",

package/src/core/binary/allocator/OffsetAllocator.d.ts

@@ -120,7 +120,30 @@ export class OffsetAllocator {
      */
     free(allocation: Allocation): void;
     /**
-     * Drop all allocations, effectively deallocating everything and restoring allocator into initial state
+     * Enlarge the arena in place. Every live allocation keeps the offset it was given.
+     *
+     * `[old size, new_size)` joins the free list as one node, linked as the neighbour-next of
+     * whichever node ends the arena, so offsets handed out before the call stay valid and freeing one
+     * of those allocations still coalesces across the seam. A free tail is re-filed at its new size
+     * rather than given a neighbour, so a run of growths costs no nodes at all.
+     *
+     * Does NOT raise {@link maxAllocs}, and asserts rather than exceed it. The node table cannot be
+     * grown in place ({@link reset} leaves `nodes.length` at 0 and {@link RowFirstTable#setCapacity}
+     * copies `length` rows, so it would drop every node), and the allocation count a caller needs
+     * does not follow from the arena's size anyway. Only a used tail costs a node. With assertions
+     * stripped that check is gone and the freelist pop underflows, so size {@link maxAllocs} for the
+     * allocation count you intend to reach.
+     *
+     * Growing by exactly N does not promise an allocation of N now fits: the bins round free runs
+     * down and requests up, up to 9/8 apart. Grow by `required * 9 / 8` before allocating `required`.
+     *
+     * @param {number} new_size new total number of contiguous elements, must be >= the current size
+     * @see reset
+     */
+    grow(new_size: number): void;
+    /**
+     * Drop all allocations, effectively deallocating everything and restoring allocator into initial state.
+     * The arena that comes back is the current {@link size}, which {@link grow} may have enlarged.
      */
     reset(): void;
     /**

package/src/core/binary/allocator/OffsetAllocator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OffsetAllocator.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/allocator/OffsetAllocator.js"],"names":[],"mappings":"AAaA,4CAA6C;AAoC7C;;;;;;;;GAQG;AACH;IAII;;;;;OAKG;IACH,oBAJW,MAAM,YACN,MAAM,GACL,UAAU,CASrB;IAED;;;OAGG;IACH,yBAFU,UAAU,CAEoE;IAtBxF,eAA4B;IAC5B,iBAA8B;CAsBjC;AA6BD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAwDI;;;;OAIG;IACH,kBAHW,MAAM,cACN,MAAM,EAYhB;IAtED;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,UAAU,CAEoB;IAExC;;;OAGG;IACH,YAFU,WAAW,CAEuB;IAE5C;;;OAGG;IACH,OAFU,aAAa,CAEmB;IAE1C;;OAEG;IACH,WAFU,WAAW,CAEX;IAEV;;;OAGG;IACH,YAFU,MAAM,CAED;IAmBf;;;;OAIG;IACH,eAHW,MAAM,GACJ,UAAU,CAkGtB;IAED;;;;;;;OAOG;IACH,sBAHW,MAAM,QAqFhB;IAED;;;OAGG;IACH,iBAHW,UAAU,QAUpB;IAqID;;OAEG;IACH,cA4BC;IAED;;;OAGG;IACH,iBAFY,aAAa,CA2BxB;;CACJ;8BA/lB6B,yCAAyC;AAqGvE;IACI,uBAAkB;IAClB,0BAAqB;CACxB"}
+{"version":3,"file":"OffsetAllocator.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/allocator/OffsetAllocator.js"],"names":[],"mappings":"AAaA,4CAA6C;AAoC7C;;;;;;;;GAQG;AACH;IAII;;;;;OAKG;IACH,oBAJW,MAAM,YACN,MAAM,GACL,UAAU,CASrB;IAED;;;OAGG;IACH,yBAFU,UAAU,CAEoE;IAtBxF,eAA4B;IAC5B,iBAA8B;CAsBjC;AA6BD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAoEI;;;;OAIG;IACH,kBAHW,MAAM,cACN,MAAM,EAYhB;IAlFD;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,UAAU,CAEoB;IAExC;;;OAGG;IACH,YAFU,WAAW,CAEuB;IAE5C;;;OAGG;IACH,OAFU,aAAa,CAEmB;IAE1C;;OAEG;IACH,WAFU,WAAW,CAEX;IAEV;;;OAGG;IACH,YAFU,MAAM,CAED;IA+Bf;;;;OAIG;IACH,eAHW,MAAM,GACJ,UAAU,CAkGtB;IAED;;;;;;;OAOG;IACH,sBAHW,MAAM,QAqFhB;IAED;;;OAGG;IACH,iBAHW,UAAU,QAUpB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,eAHW,MAAM,QA8DhB;IA0ID;;;OAGG;IACH,cA4BC;IAED;;;OAGG;IACH,iBAFY,aAAa,CA2BxB;;CACJ;8BAnsB6B,yCAAyC;AAqGvE;IACI,uBAAkB;IAClB,0BAAqB;CACxB"}

package/src/core/binary/allocator/OffsetAllocator.js

@@ -187,6 +187,18 @@ export class OffsetAllocator {
      */
     freeOffset = 0;
 
+    /**
+     * The one node whose neighbour-next is {@link NODE_UNUSED}, so the one describing the arena's
+     * end. {@link OffsetAllocator#grow} needs it in O(1) and has nothing to walk the chain from.
+     *
+     * Maintained by `#insertNodeIntoBin`, which is the only place a node's end offset is ever set:
+     * `allocate` only shrinks the node it hands out, and `free_node` re-inserts every merged region
+     * through that same method.
+     * uint32
+     * @type {number}
+     */
+    #tail_node = NODE_UNUSED;
+
     /**
      *
      * @param {number} size amount of contiguous elements managed by this allocator (typically bytes)
@@ -412,6 +424,88 @@ export class OffsetAllocator {
         this.free_node(node_index);
     }
 
+    /**
+     * Enlarge the arena in place. Every live allocation keeps the offset it was given.
+     *
+     * `[old size, new_size)` joins the free list as one node, linked as the neighbour-next of
+     * whichever node ends the arena, so offsets handed out before the call stay valid and freeing one
+     * of those allocations still coalesces across the seam. A free tail is re-filed at its new size
+     * rather than given a neighbour, so a run of growths costs no nodes at all.
+     *
+     * Does NOT raise {@link maxAllocs}, and asserts rather than exceed it. The node table cannot be
+     * grown in place ({@link reset} leaves `nodes.length` at 0 and {@link RowFirstTable#setCapacity}
+     * copies `length` rows, so it would drop every node), and the allocation count a caller needs
+     * does not follow from the arena's size anyway. Only a used tail costs a node. With assertions
+     * stripped that check is gone and the freelist pop underflows, so size {@link maxAllocs} for the
+     * allocation count you intend to reach.
+     *
+     * Growing by exactly N does not promise an allocation of N now fits: the bins round free runs
+     * down and requests up, up to 9/8 apart. Grow by `required * 9 / 8` before allocating `required`.
+     *
+     * @param {number} new_size new total number of contiguous elements, must be >= the current size
+     * @see reset
+     */
+    grow(new_size) {
+        assert.isNonNegativeInteger(new_size, 'new_size');
+        assert.greaterThanOrEqual(new_size, this.size, 'new_size, an arena never shrinks');
+
+        const old_size = this.size;
+        const delta = new_size - old_size;
+
+        if (delta === 0) {
+            // nothing to append, and a zero-sized node would spend a node to describe no space
+            return;
+        }
+
+        // an allocation handed out at ALLOCATOR_NO_SPACE would be indistinguishable from a failure.
+        // Checked past the no-op above, an arena already at the limit still grows to itself
+        assert.lessThan(new_size, ALLOCATOR_NO_SPACE, 'new_size');
+
+        const nodes = this.nodes;
+        const tail_node = this.#tail_node;
+
+        assert.notEqual(tail_node, NODE_UNUSED, 'tail node, the arena end is always described');
+
+        const tail_is_free = (nodes.readCellValue(tail_node, NODE_FIELD_FLAGS) & NODE_FLAGS_USED) === 0;
+
+        if (!tail_is_free) {
+            // checked before anything is mutated, so a failed grow leaves the allocator untouched
+            assert.greaterThan(
+                this.freeOffset, 0,
+                `grow(${new_size}) needs a node to describe [${old_size}, ${new_size}) and all ${this.maxAllocs} are in use. grow does not raise maxAllocs, construct the allocator with a higher one`
+            );
+        }
+
+        // moved before either insert, #insertNodeIntoBin reads it to spot the node that now ends the arena
+        this.size = new_size;
+
+        if (tail_is_free) {
+            // The arena already ended in free space, so stretch that run rather than give it a
+            // neighbour. Re-filing it is what puts it in the bin its new size belongs to.
+            const tail_offset = nodes.readCellValue(tail_node, NODE_FIELD_DATA_OFFSET);
+            const tail_size = nodes.readCellValue(tail_node, NODE_FIELD_DATA_SIZE);
+            const tail_neighbour_prev = nodes.readCellValue(tail_node, NODE_FIELD_NEIGHBOR_PREV);
+
+            this.#removeNodeFromBin(tail_node);
+
+            // the freelist is a stack, so this pops back the node just pushed, but don't rely on it
+            const grown_node = this.#insertNodeIntoBin(tail_size + delta, tail_offset);
+
+            if (tail_neighbour_prev !== NODE_UNUSED) {
+                nodes.writeCellValue(grown_node, NODE_FIELD_NEIGHBOR_PREV, tail_neighbour_prev);
+                nodes.writeCellValue(tail_neighbour_prev, NODE_FIELD_NEIGHBOR_NEXT, grown_node);
+            }
+
+            return;
+        }
+
+        // The arena ends inside a live allocation, the appended region needs a node of its own
+        const appended_node = this.#insertNodeIntoBin(delta, old_size);
+
+        nodes.writeCellValue(appended_node, NODE_FIELD_NEIGHBOR_PREV, tail_node);
+        nodes.writeCellValue(tail_node, NODE_FIELD_NEIGHBOR_NEXT, appended_node);
+    }
+
     /**
      *
      * @param {number} size
@@ -470,6 +564,11 @@ export class OffsetAllocator {
             console.log(`Free storage: ${this.freeStorage} (+${size}) (insertNodeIntoBin)`);
         }
 
+        if (data_offset + size === this.size) {
+            // this node is the one that now ends the arena
+            this.#tail_node = node_index;
+        }
+
         return node_index;
     }
 
@@ -544,7 +643,8 @@ export class OffsetAllocator {
     }
 
     /**
-     * Drop all allocations, effectively deallocating everything and restoring allocator into initial state
+     * Drop all allocations, effectively deallocating everything and restoring allocator into initial state.
+     * The arena that comes back is the current {@link size}, which {@link grow} may have enlarged.
      */
     reset() {
         this.freeStorage = 0;

package/src/core/binary/type/Field.d.ts

@@ -1,4 +1,8 @@
 export default Field;
+export type Type = import("./Type.js").default;
+/**
+ * @typedef {import("./Type.js").default} Type
+ */
 declare class Field {
     /**
      *
@@ -11,7 +15,7 @@ declare class Field {
     initial: any;
     observed: boolean;
     name: string;
-    type: Type;
+    type: import("./Type.js").default;
     multiplicity: number;
 }
 import MultiplicityType from "./MultiplicityType.js";

package/src/core/binary/type/Field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Field.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/type/Field.js"],"names":[],"mappings":";AAGA;IAII;;;;;;OAMG;IACH,qDAHW,gBAAgB,EAS1B;IAhBD,aAAe;IACf,kBAAgB;IAYZ,aAAgB;IAChB,WAAgB;IAChB,qBAAgC;CAEvC;6BApB4B,uBAAuB"}
+{"version":3,"file":"Field.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/type/Field.js"],"names":[],"mappings":";mBAIa,OAAO,WAAW,EAAE,OAAO;AADxC;;GAEG;AAEH;IAII;;;;;;OAMG;IACH,gCAJW,IAAI,iBACJ,gBAAgB,EAS1B;IAhBD,aAAe;IACf,kBAAgB;IAYZ,aAAgB;IAChB,kCAAgB;IAChB,qBAAgC;CAEvC;6BAxB4B,uBAAuB"}

package/src/core/binary/type/Field.js

@@ -1,6 +1,10 @@
 import { assert } from "../../assert.js";
 import MultiplicityType from "./MultiplicityType.js";
 
+/**
+ * @typedef {import("./Type.js").default} Type
+ */
+
 class Field {
     initial = null;
     observed = true;

package/src/core/binary/type/Type.d.ts

@@ -1,4 +1,8 @@
 export default Type;
+export type Field = import("./Field.js").default;
+/**
+ * @typedef {import("./Field.js").default} Field
+ */
 declare class Type {
     /**
      *

package/src/core/binary/type/Type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Type.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/type/Type.js"],"names":[],"mappings":";AAGA;IAmBI;;;;OAIG;IACH,0BAQC;IA/BD;;;OAGG;IACH,QAFU,YAAa,CAEX;IAEZ;;;OAGG;IACH,aAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,eAFU,OAAO,CAEK;IAUlB;;;OAGG;IACH,aAAgB;IAGpB;;;;OAIG;IACH,8BAFa,QAAM,IAAI,CAatB;IAED;;;;;OAKG;IACH,6BAHW,IAAI,SAYd;IAED;;;OAGG;IACH,SAFa,IAAI,CAMhB;CACJ"}
+{"version":3,"file":"Type.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/type/Type.js"],"names":[],"mappings":";oBAIa,OAAO,YAAY,EAAE,OAAO;AADzC;;GAEG;AAEH;IAmBI;;;;OAIG;IACH,0BAQC;IA/BD;;;OAGG;IACH,QAFU,MAAO,KAAK,CAAC,CAEX;IAEZ;;;OAGG;IACH,aAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,eAFU,OAAO,CAEK;IAUlB;;;OAGG;IACH,aAAgB;IAGpB;;;;OAIG;IACH,8BAFa,KAAK,GAAC,IAAI,CAatB;IAED;;;;;OAKG;IACH,6BAHW,IAAI,GACF,KAAK,CAWjB;IAED;;;OAGG;IACH,SAFa,IAAI,CAMhB;CACJ"}

package/src/core/binary/type/Type.js

@@ -1,6 +1,10 @@
 import { assert } from "../../assert.js";
 import BinaryField from "./Field.js";
 
+/**
+ * @typedef {import("./Field.js").default} Field
+ */
+
 class Type {
     /**
      *

package/src/core/cache/Cache.d.ts

@@ -22,15 +22,23 @@ export class Cache<Key, Value> {
     /**
      * Note: setting {@link maxWeight} to 0 is pointless, as the cache will not be able to hold even a single element.
      *
-     * @param {number} [maxWeight=Number.POSITIVE_INFINITY] capacity of the cache, measure in "weight"; The weight is computed by summing key and value weights.
-     * @param {(key: Key) => number} [keyWeigher= key=>0] function to compute weight of a key
-     * @param {(value: Value) => number} [valueWeigher= value=>1] function to compute weight of a value
-     * @param {function(Key):number} [keyHashFunction]
-     * @param {function(Key, Key):boolean} [keyEqualityFunction]
-     * @param {number} [capacity] initial capacity for the cache, helps prevent early resizing
+     * @param {Object} [options]
+     * @param {number} [options.maxWeight=Number.POSITIVE_INFINITY] capacity of the cache, measure in "weight"; The weight is computed by summing key and value weights.
+     * @param {(key: Key) => number} [options.keyWeigher= key=>0] function to compute weight of a key
+     * @param {(value: Value) => number} [options.valueWeigher= value=>1] function to compute weight of a value
+     * @param {function(Key):number} [options.keyHashFunction]
+     * @param {function(Key, Key):boolean} [options.keyEqualityFunction]
+     * @param {number} [options.capacity] initial capacity for the cache, helps prevent early resizing
      * @constructor
      */
-    constructor({ maxWeight, keyWeigher, valueWeigher, keyHashFunction, keyEqualityFunction, capacity }?: number);
+    constructor({ maxWeight, keyWeigher, valueWeigher, keyHashFunction, keyEqualityFunction, capacity }?: {
+        maxWeight?: number;
+        keyWeigher?: (key: Key) => number;
+        valueWeigher?: (value: Value) => number;
+        keyHashFunction?: (arg0: Key) => number;
+        keyEqualityFunction?: (arg0: Key, arg1: Key) => boolean;
+        capacity?: number;
+    });
     /**
      *
      * @type {CacheElement<Key,Value>|null}

package/src/core/cache/Cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/Cache.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA8BI;;;;;;;;;;OAUG;IACH,sGARW,MAAM,EA4EhB;IA7FD;;;;OAIG;IACH,gBAAe;IAEf;;;;OAIG;IACH,eAAc;IAsCV;;;;OAIG;IACH,mBAA4B;IAE5B;;;;OAIG;IACH,qBAAgC;IAEhC;;;;OAIG;IACH,aAIE;IAEF;;;;OAIG;IACH,eAA6B;IAE7B;;;OAGG;IACH,eAA6B;IAE7B;;;OAGG;IACH,WAAyB;IAG7B;;;;;OAKG;IACH;;;;;;;;;;;;OAYG;IACH,kBAqBC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;OAGG;IACH,8BAeC;IAED,wBAEC;IAED;;;;OAIG;IACH,wBAaC;IAED;;;;;;OAMG;IACH,yBAHW,GAAG,GACD,OAAO,CAgCnB;IAED;;;;;OAKG;IACH,6BAUC;IAED;;;OAGG;IACH,sBAFa,aAAa,GAAG,EAAC,KAAK,CAAC,GAAC,IAAI,CAIxC;IAED;;;OAGG;IACH,YAFa,OAAO,CAkBnB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,SAHW,GAAG,SACH,KAAK,QA+Ef;IAED;;;;OAIG;IACH,cAHW,GAAG,GACD,OAAO,CAInB;IAED;;;;OAIG;IACH,SAHW,GAAG,GACD,KAAK,GAAC,IAAI,CAYtB;IAGD;;;;;;OAMG;IACH,kBALW,GAAG,kBACM,GAAG,KAAE,KAAK,0BAElB,KAAK,CAchB;IAED;;;;OAIG;IACH,wBAqBC;IAED;;;;OAIG;IACH,YAHW,GAAG,GACD,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,kBAHW,GAAG,GACD,OAAO,CAanB;IAED;;;;OAIG;IACH,cAcC;IAED;;;OAGG;IACH,aAOC;IAED;;;;;OAKG;IACH,mBAJW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,kBAE/C,OAAO,CAMnB;IAGL;;;OAGG;IACH,6CAAmB;IAEnB;;;OAGG;IACH,+BA9FiB,OAAO,CA8FF;IAEtB;;;OAGG;IACH,4BAhLiB,OAAO,CAgLL;;CAlBlB;6BAhlB4B,mBAAmB"}
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/Cache.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA8BI;;;;;;;;;;;OAWG;IACH;QAR4B,SAAS,GAA1B,MAAM;QACyB,UAAU,GAAzC,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM;QACe,YAAY,GAA/C,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM;QACO,eAAe,UAArC,GAAG,KAAE,MAAM;QACiB,mBAAmB,UAA/C,GAAG,QAAE,GAAG,KAAE,OAAO;QACT,QAAQ,GAAzB,MAAM;OAuEhB;IA9FD;;;;OAIG;IACH,gBAAe;IAEf;;;;OAIG;IACH,eAAc;IAuCV;;;;OAIG;IACH,mBAA4B;IAE5B;;;;OAIG;IACH,qBAAgC;IAEhC;;;;OAIG;IACH,aAIE;IAEF;;;;OAIG;IACH,eAA6B;IAE7B;;;OAGG;IACH,eAA6B;IAE7B;;;OAGG;IACH,WAAyB;IAG7B;;;;;OAKG;IACH;;;;;;;;;;;;OAYG;IACH,kBAqBC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;OAGG;IACH,8BAeC;IAED,wBAEC;IAED;;;;OAIG;IACH,wBAaC;IAED;;;;;;OAMG;IACH,yBAHW,GAAG,GACD,OAAO,CAgCnB;IAED;;;;;OAKG;IACH,6BAUC;IAED;;;OAGG;IACH,sBAFa,aAAa,GAAG,EAAC,KAAK,CAAC,GAAC,IAAI,CAIxC;IAED;;;OAGG;IACH,YAFa,OAAO,CAkBnB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,SAHW,GAAG,SACH,KAAK,QA+Ef;IAED;;;;OAIG;IACH,cAHW,GAAG,GACD,OAAO,CAInB;IAED;;;;OAIG;IACH,SAHW,GAAG,GACD,KAAK,GAAC,IAAI,CAYtB;IAGD;;;;;;OAMG;IACH,kBALW,GAAG,kBACM,GAAG,KAAE,KAAK,0BAElB,KAAK,CAchB;IAED;;;;OAIG;IACH,wBAqBC;IAED;;;;OAIG;IACH,YAHW,GAAG,GACD,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,kBAHW,GAAG,GACD,OAAO,CAanB;IAED;;;;OAIG;IACH,cAcC;IAED;;;OAGG;IACH,aAOC;IAED;;;;;OAKG;IACH,mBAJW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,kBAE/C,OAAO,CAMnB;IAGL;;;OAGG;IACH,6CAAmB;IAEnB;;;OAGG;IACH,+BA9FiB,OAAO,CA8FF;IAEtB;;;OAGG;IACH,4BAhLiB,OAAO,CAgLL;;CAlBlB;6BAjlB4B,mBAAmB"}

package/src/core/cache/Cache.js

@@ -61,12 +61,13 @@ export class Cache {
     /**
      * Note: setting {@link maxWeight} to 0 is pointless, as the cache will not be able to hold even a single element.
      *
-     * @param {number} [maxWeight=Number.POSITIVE_INFINITY] capacity of the cache, measure in "weight"; The weight is computed by summing key and value weights.
-     * @param {(key: Key) => number} [keyWeigher= key=>0] function to compute weight of a key
-     * @param {(value: Value) => number} [valueWeigher= value=>1] function to compute weight of a value
-     * @param {function(Key):number} [keyHashFunction]
-     * @param {function(Key, Key):boolean} [keyEqualityFunction]
-     * @param {number} [capacity] initial capacity for the cache, helps prevent early resizing
+     * @param {Object} [options]
+     * @param {number} [options.maxWeight=Number.POSITIVE_INFINITY] capacity of the cache, measure in "weight"; The weight is computed by summing key and value weights.
+     * @param {(key: Key) => number} [options.keyWeigher= key=>0] function to compute weight of a key
+     * @param {(value: Value) => number} [options.valueWeigher= value=>1] function to compute weight of a value
+     * @param {function(Key):number} [options.keyHashFunction]
+     * @param {function(Key, Key):boolean} [options.keyEqualityFunction]
+     * @param {number} [options.capacity] initial capacity for the cache, helps prevent early resizing
      * @constructor
      */
     constructor({

package/src/core/cache/wtinylfu/CacheRegionWTinylfu.d.ts

@@ -1,9 +1,12 @@
 export class CacheRegionWTinylfu {
     /**
      *
-     * @param {number} maxWeight
+     * @param {Object} [options]
+     * @param {number} options.maxWeight
      */
-    constructor({ maxWeight }?: number);
+    constructor({ maxWeight }?: {
+        maxWeight: number;
+    });
     /**
      * Add new element to this region
      * @param {CacheElementWTinylfu} element

package/src/core/cache/wtinylfu/CacheRegionWTinylfu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CacheRegionWTinylfu.d.ts","sourceRoot":"","sources":["../../../../../src/core/cache/wtinylfu/CacheRegionWTinylfu.js"],"names":[],"mappings":"AAIA;IA8BI;;;OAGG;IACH,4BAFW,MAAM,EAWhB;IAED;;;;OAIG;IACH,aAHW,oBAAoB,WACpB,MAAM,QAmBhB;IAED;;;OAGG;IACH,eAFW,oBAAoB,QAoB9B;IAED;;;OAGG;IACH,sBAFa,gCAA+B,GAAC,IAAI,CAIhD;IAED;;;;;OAKG;IACH,wBAcC;IAED;;;;OAIG;IACH,8BAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,qBAEC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAEC;IAED;;;;;OAKG;IACH,kCAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,cAIC;;CAEJ;qCArLkC,2BAA2B"}
+{"version":3,"file":"CacheRegionWTinylfu.d.ts","sourceRoot":"","sources":["../../../../../src/core/cache/wtinylfu/CacheRegionWTinylfu.js"],"names":[],"mappings":"AAIA;IA8BI;;;;OAIG;IACH;QAF2B,SAAS,EAAzB,MAAM;OAWhB;IAED;;;;OAIG;IACH,aAHW,oBAAoB,WACpB,MAAM,QAmBhB;IAED;;;OAGG;IACH,eAFW,oBAAoB,QAoB9B;IAED;;;OAGG;IACH,sBAFa,gCAA+B,GAAC,IAAI,CAIhD;IAED;;;;;OAKG;IACH,wBAcC;IAED;;;;OAIG;IACH,8BAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,qBAEC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAEC;IAED;;;;;OAKG;IACH,kCAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,cAIC;;CAEJ;qCAtLkC,2BAA2B"}

package/src/core/cache/wtinylfu/CacheRegionWTinylfu.js

@@ -34,7 +34,8 @@ export class CacheRegionWTinylfu {
 
     /**
      *
-     * @param {number} maxWeight
+     * @param {Object} [options]
+     * @param {number} options.maxWeight
      */
     constructor({
                     maxWeight = Number.POSITIVE_INFINITY

package/src/core/cache/wtinylfu/CacheWTinylfu.d.ts

@@ -1,16 +1,26 @@
 export class CacheWTinylfu {
     /**
      *
-     * @param {number} [maxWeight=Number.POSITIVE_INFINITY] total weight budget of the cache; an element's weight is keyWeigher(key) + valueWeigher(value)
-     * @param {number} [promotionThreshold=1] frequency an item must exceed to be promoted out of Trial (Probation)
-     * @param {number} [capacityWindow=1] weight cap of the Window region (burst buffer)
-     * @param {number} [capacityProtected=1] weight cap of the Protected region (VIP segment of Main)
-     * @param {(key: Key) => number} [keyWeigher= key=>0] function to compute weight of a key
-     * @param {(value: Value) => number} [valueWeigher= value=>1] function to compute weight of a value
-     * @param {function(Key):number} [keyHashFunction]
-     * @param {function(Key, Key):boolean} [keyEqualityFunction]
-     */
-    constructor({ maxWeight, promotionThreshold, capacityWindow, capacityProtected, keyWeigher, valueWeigher, keyHashFunction, keyEqualityFunction }?: number);
+     * @param {Object} [options]
+     * @param {number} [options.maxWeight=Number.POSITIVE_INFINITY] total weight budget of the cache; an element's weight is keyWeigher(key) + valueWeigher(value)
+     * @param {number} [options.promotionThreshold=1] frequency an item must exceed to be promoted out of Trial (Probation)
+     * @param {number} [options.capacityWindow=1] weight cap of the Window region (burst buffer)
+     * @param {number} [options.capacityProtected=1] weight cap of the Protected region (VIP segment of Main)
+     * @param {(key: Key) => number} [options.keyWeigher= key=>0] function to compute weight of a key
+     * @param {(value: Value) => number} [options.valueWeigher= value=>1] function to compute weight of a value
+     * @param {function(Key):number} [options.keyHashFunction]
+     * @param {function(Key, Key):boolean} [options.keyEqualityFunction]
+     */
+    constructor({ maxWeight, promotionThreshold, capacityWindow, capacityProtected, keyWeigher, valueWeigher, keyHashFunction, keyEqualityFunction }?: {
+        maxWeight?: number;
+        promotionThreshold?: number;
+        capacityWindow?: number;
+        capacityProtected?: number;
+        keyWeigher?: (key: Key) => number;
+        valueWeigher?: (value: Value) => number;
+        keyHashFunction?: (arg0: Key) => number;
+        keyEqualityFunction?: (arg0: Key, arg1: Key) => boolean;
+    });
     /**
      * Dispatched when an element is added or its value replaced. send2(key, value)
      * @type {Signal}

package/src/core/cache/wtinylfu/CacheWTinylfu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CacheWTinylfu.d.ts","sourceRoot":"","sources":["../../../../../src/core/cache/wtinylfu/CacheWTinylfu.js"],"names":[],"mappings":"AAiDA;IA0FI;;;;;;;;;;OAUG;IACH,mJATW,MAAM,EA+DhB;IA1FD;;;OAGG;IACH,OAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,YAFU,MAAM,CAEU;IAqE1B;;;;OAIG;IACH,gBAGC;IAED;;;;OAIG;IACH,mBAcC;IACD;;;;OAIG;IACH,wBAsBC;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;OAKG;IACH,oBAEC;IAED;;;;;;OAMG;IACH,mCAEC;IAED;;;;;;;OAOG;IACH,wBAEC;IAED;;;;OAIG;IACH,kBAFa,OAAO,CAUnB;IAED;;;OAGG;IACH,cASC;IAED;;;;;;OAMG;IACH,+BAUC;IAED;;;;OAIG;IACH,uBAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,wBAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;OAIG;IACH,wBAIC;IAED;;;;;;;OAOG;IACH,8BAmBC;IAED;;;;;;;OAOG;IACH,0BAeC;IAED;;;;;;;OAOG;IACH,2BAwBC;IAED;;;;;;OAMG;IACH,sBAkCC;IAED;;;;OAIG;IACH,sBAGC;IAED;;;;;;OAMG;IACH,gBAQC;IAED;;;;;;;OAOG;IACH,gBASC;IAoBD;;;;OAIG;IACH,mBAOC;IAED;;;;;;;OAOG;IACH,+BAgBC;IAED;;;;;OAKG;IACH,8BAMC;IAED;;;;;;;OAOG;IACH,gCAcC;IAED;;;;OAIG;IACH,2BASC;IAED;;;;;OAKG;IACH,gCAQC;IAED;;;;;OAKG;IACH,yBAmBC;IAED;;;;OAIG;IACH,kCAkBC;IAED;;;;OAIG;IACH,eAFa,QAAM,IAAI,CAWtB;IAID;;;;;OAKG;IACH,yBAFa,eAAe,GAAC,IAAI,CAKhC;IAED;;;OAGG;IACH,kBAFa;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAQ9D;;CACJ;uBA9vBoB,+BAA+B;gCARtB,sBAAsB"}
+{"version":3,"file":"CacheWTinylfu.d.ts","sourceRoot":"","sources":["../../../../../src/core/cache/wtinylfu/CacheWTinylfu.js"],"names":[],"mappings":"AAiDA;IA0FI;;;;;;;;;;;OAWG;IACH;QAT4B,SAAS,GAA1B,MAAM;QACW,kBAAkB,GAAnC,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACyB,UAAU,GAAzC,CAAC,GAAG,KAAK,KAAK,MAAM;QACe,YAAY,GAA/C,CAAC,KAAK,OAAO,KAAK,MAAM;QACO,eAAe,kBAAhC,MAAM;QACiB,mBAAmB,6BAArC,OAAO;OAwDpC;IA3FD;;;OAGG;IACH,OAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,YAFU,MAAM,CAEU;IAsE1B;;;;OAIG;IACH,gBAGC;IAED;;;;OAIG;IACH,mBAcC;IACD;;;;OAIG;IACH,wBAsBC;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;OAKG;IACH,oBAEC;IAED;;;;;;OAMG;IACH,mCAEC;IAED;;;;;;;OAOG;IACH,wBAEC;IAED;;;;OAIG;IACH,kBAFa,OAAO,CAUnB;IAED;;;OAGG;IACH,cASC;IAED;;;;;;OAMG;IACH,+BAUC;IAED;;;;OAIG;IACH,uBAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,wBAEC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;OAIG;IACH,wBAIC;IAED;;;;;;;OAOG;IACH,8BAmBC;IAED;;;;;;;OAOG;IACH,0BAeC;IAED;;;;;;;OAOG;IACH,2BAwBC;IAED;;;;;;OAMG;IACH,sBAkCC;IAED;;;;OAIG;IACH,sBAGC;IAED;;;;;;OAMG;IACH,gBAQC;IAED;;;;;;;OAOG;IACH,gBASC;IAoBD;;;;OAIG;IACH,mBAOC;IAED;;;;;;;OAOG;IACH,+BAgBC;IAED;;;;;OAKG;IACH,8BAMC;IAED;;;;;;;OAOG;IACH,gCAcC;IAED;;;;OAIG;IACH,2BASC;IAED;;;;;OAKG;IACH,gCAQC;IAED;;;;;OAKG;IACH,yBAmBC;IAED;;;;OAIG;IACH,kCAkBC;IAED;;;;OAIG;IACH,eAFa,QAAM,IAAI,CAWtB;IAID;;;;;OAKG;IACH,yBAFa,eAAe,GAAC,IAAI,CAKhC;IAED;;;OAGG;IACH,kBAFa;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAQ9D;;CACJ;uBA/vBoB,+BAA+B;gCARtB,sBAAsB"}