@woosh/meep-engine 2.169.6 → 2.170.0

package/src/engine/network/diagnostics/ReplayLog.js

@@ -1,137 +1,132 @@
-import { assert } from "../../../core/assert.js";
-import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
-
-/**
- * Append-only record of action bytes per frame. Useful for offline replay,
- * bug reproduction, and demos.
- *
- * Each entry stores a copy of the action bytes for one frame. The bytes
- * typically come from the per-frame `ActionLog` buffer (the action portion
- * after `Replicator.pack_for_peer` strips prior-state). The format on the wire
- * is the same one `Replicator.unpack_from_peer` consumes, so a recorded
- * session can be replayed by feeding the bytes back through a peer.
- *
- * Persistence to disk / IndexedDB / network is left to the application —
- * `serialize_to_buffer` produces a single contiguous `BinaryBuffer` snapshot.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class ReplayLog {
-    #entries;
-
-
-    constructor() {
-        /**
-         * @type {{frame: number, bytes: Uint8Array}[]}
-         * @private
-         */
-        this.#entries = [];
-    }
-
-    /**
-     * Append a frame's bytes. The source array is copied; caller may reuse it.
-     *
-     * @param {number} frame
-     * @param {Uint8Array} bytes
-     * @param {number} length
-     */
-    record(frame, bytes, length) {
-        assert.isNonNegativeInteger(frame, 'frame');
-        assert.isNonNegativeInteger(length, 'length');
-        const copy = new Uint8Array(length);
-        copy.set(bytes.subarray(0, length));
-        this.#entries.push({ frame, bytes: copy });
-    }
-
-    /**
-     * @returns {number}
-     */
-    size() {
-        return this.#entries.length;
-    }
-
-    /**
-     * Iterate frames in `[start_frame, end_frame]` (inclusive).
-     * @param {number} start_frame
-     * @param {number} end_frame
-     * @param {function(number, Uint8Array): void} callback receives (frame, bytes)
-     */
-    for_each_in_range(start_frame, end_frame, callback) {
-        assert.isNonNegativeInteger(start_frame, 'start_frame');
-        assert.isNonNegativeInteger(end_frame, 'end_frame');
-        assert.isFunction(callback, 'callback');
-        for (let i = 0; i < this.#entries.length; i++) {
-            const e = this.#entries[i];
-            if (e.frame >= start_frame && e.frame <= end_frame) {
-                callback(e.frame, e.bytes);
-            }
-        }
-    }
-
-    /**
-     * Drop all entries.
-     */
-    clear() {
-        this.#entries.length = 0;
-    }
-
-    /**
-     * Frame number of the first entry, or -1 if empty.
-     */
-    earliest_frame() {
-        return this.#entries.length === 0 ? -1 : this.#entries[0].frame;
-    }
-
-    /**
-     * Frame number of the last entry, or -1 if empty.
-     */
-    latest_frame() {
-        return this.#entries.length === 0 ? -1 : this.#entries[this.#entries.length - 1].frame;
-    }
-
-    /**
-     * Serialize the entire log to a fresh buffer. Format:
-     * ```
-     *   varint:    entry_count
-     *   loop:
-     *     varint:  frame
-     *     varint:  bytes_length
-     *     bytes:   payload
-     * ```
-     *
-     * @param {BinaryBuffer} [buffer] if provided, written into; otherwise a fresh one is created
-     * @returns {BinaryBuffer}
-     */
-    serialize_to_buffer(buffer) {
-        const buf = buffer === undefined ? new BinaryBuffer() : buffer;
-        buf.writeUintVar(this.#entries.length);
-        for (let i = 0; i < this.#entries.length; i++) {
-            const e = this.#entries[i];
-            buf.writeUintVar(e.frame);
-            buf.writeUintVar(e.bytes.length);
-            buf.writeBytes(e.bytes, 0, e.bytes.length);
-        }
-        return buf;
-    }
-
-    /**
-     * Build a ReplayLog from a previously-serialized buffer. Reads from the
-     * buffer's current position; advances the position past the consumed bytes.
-     *
-     * @param {BinaryBuffer} buffer
-     * @returns {ReplayLog}
-     */
-    static deserialize_from_buffer(buffer) {
-        const log = new ReplayLog();
-        const count = buffer.readUintVar();
-        for (let i = 0; i < count; i++) {
-            const frame = buffer.readUintVar();
-            const length = buffer.readUintVar();
-            const bytes = new Uint8Array(length);
-            buffer.readUint8Array(bytes, 0, length);
-            log.#entries.push({ frame, bytes });
-        }
-        return log;
-    }
-}
+import { assert } from "../../../core/assert.js";
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+
+/**
+ * Append-only record of action bytes per frame. Useful for offline replay,
+ * bug reproduction, and demos.
+ *
+ * Each entry stores a copy of the action bytes for one frame. The bytes
+ * typically come from the per-frame `ActionLog` buffer (the action portion
+ * after `Replicator.pack_for_peer` strips prior-state). The format on the wire
+ * is the same one `Replicator.unpack_from_peer` consumes, so a recorded
+ * session can be replayed by feeding the bytes back through a peer.
+ *
+ * Persistence to disk / IndexedDB / network is left to the application —
+ * `serialize_to_buffer` produces a single contiguous `BinaryBuffer` snapshot.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ReplayLog {
+    /**
+     * @type {{frame: number, bytes: Uint8Array}[]}
+     * @private
+     */
+    #entries = [];
+
+    /**
+     * Append a frame's bytes. The source array is copied; caller may reuse it.
+     *
+     * @param {number} frame
+     * @param {Uint8Array} bytes
+     * @param {number} length
+     */
+    record(frame, bytes, length) {
+        assert.isNonNegativeInteger(frame, 'frame');
+        assert.isNonNegativeInteger(length, 'length');
+        const copy = new Uint8Array(length);
+        copy.set(bytes.subarray(0, length));
+        this.#entries.push({ frame, bytes: copy });
+    }
+
+    /**
+     * @returns {number}
+     */
+    size() {
+        return this.#entries.length;
+    }
+
+    /**
+     * Iterate frames in `[start_frame, end_frame]` (inclusive).
+     * @param {number} start_frame
+     * @param {number} end_frame
+     * @param {function(number, Uint8Array): void} callback receives (frame, bytes)
+     */
+    for_each_in_range(start_frame, end_frame, callback) {
+        assert.isNonNegativeInteger(start_frame, 'start_frame');
+        assert.isNonNegativeInteger(end_frame, 'end_frame');
+        assert.isFunction(callback, 'callback');
+        for (let i = 0; i < this.#entries.length; i++) {
+            const e = this.#entries[i];
+            if (e.frame >= start_frame && e.frame <= end_frame) {
+                callback(e.frame, e.bytes);
+            }
+        }
+    }
+
+    /**
+     * Drop all entries.
+     */
+    clear() {
+        this.#entries.length = 0;
+    }
+
+    /**
+     * Frame number of the first entry, or -1 if empty.
+     */
+    earliest_frame() {
+        return this.#entries.length === 0 ? -1 : this.#entries[0].frame;
+    }
+
+    /**
+     * Frame number of the last entry, or -1 if empty.
+     */
+    latest_frame() {
+        return this.#entries.length === 0 ? -1 : this.#entries[this.#entries.length - 1].frame;
+    }
+
+    /**
+     * Serialize the entire log to a fresh buffer. Format:
+     * ```
+     *   varint:    entry_count
+     *   loop:
+     *     varint:  frame
+     *     varint:  bytes_length
+     *     bytes:   payload
+     * ```
+     *
+     * @param {BinaryBuffer} [buffer] if provided, written into; otherwise a fresh one is created
+     * @returns {BinaryBuffer}
+     */
+    serialize_to_buffer(buffer) {
+        const buf = buffer === undefined ? new BinaryBuffer() : buffer;
+        buf.writeUintVar(this.#entries.length);
+        for (let i = 0; i < this.#entries.length; i++) {
+            const e = this.#entries[i];
+            buf.writeUintVar(e.frame);
+            buf.writeUintVar(e.bytes.length);
+            buf.writeBytes(e.bytes, 0, e.bytes.length);
+        }
+        return buf;
+    }
+
+    /**
+     * Build a ReplayLog from a previously-serialized buffer. Reads from the
+     * buffer's current position; advances the position past the consumed bytes.
+     *
+     * @param {BinaryBuffer} buffer
+     * @returns {ReplayLog}
+     */
+    static deserialize_from_buffer(buffer) {
+        const log = new ReplayLog();
+        const count = buffer.readUintVar();
+        for (let i = 0; i < count; i++) {
+            const frame = buffer.readUintVar();
+            const length = buffer.readUintVar();
+            const bytes = new Uint8Array(length);
+            buffer.readUint8Array(bytes, 0, length);
+            log.#entries.push({ frame, bytes });
+        }
+        return log;
+    }
+}

package/src/engine/network/diagnostics/SyncTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SyncTest.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/diagnostics/SyncTest.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,4HAHW,YAAY,GACV,MAAM,CAmClB;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH;IAMI;;;;;OAKG;IACH,2CALW;QACV,KAAS,yBAAyB;QAClC,kBAAsB,8BAA8B;KACjD,EAoBH;IAdG,qCAAqC;IACrC,8BAAkB;IAElB,0CAA0C;IAC1C,gDAA4C;IAYhD;;;OAGG;IACH,mBAGC;IAED;;OAEG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;;;;;;;OAUG;IACH,6EAHW,MAAM,gBACN,MAAM,QAahB;;CACJ;6BArJ4B,sCAAsC"}
+{"version":3,"file":"SyncTest.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/diagnostics/SyncTest.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,4HAHW,YAAY,GACV,MAAM,CAmClB;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH;IAOI;;;;;OAKG;IACH,2CALW;QACV,KAAS,yBAAyB;QAClC,kBAAsB,8BAA8B;KACjD,EAcH;IARG,qCAAqC;IACrC,8BAAkB;IAElB,0CAA0C;IAC1C,gDAA4C;IAMhD;;;OAGG;IACH,mBAGC;IAED;;OAEG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;;;;;;;OAUG;IACH,6EAHW,MAAM,gBACN,MAAM,QAahB;;CACJ;6BAhJ4B,sCAAsC"}

package/src/engine/network/diagnostics/SyncTest.js

@@ -1,151 +1,146 @@
-import { assert } from "../../../core/assert.js";
-import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
-
-/**
- * Compute a 32-bit fingerprint of every replicated component on every entity
- * in the world. Used by `SyncTest` and as a general "did the world state change?"
- * primitive.
- *
- * The hash is FNV-1a — fast, stable, no dependencies. Not cryptographic.
- *
- * Iteration order: entities in the order yielded by `world` (the
- * EntityComponentDataset's iterator), then components in `type_id` order.
- * As long as both sides iterate identically, the fingerprint is comparable.
- *
- * @param {EntityComponentDataset} world
- * @param {ReplicatedComponentRegistry} component_registry
- * @param {BinaryBuffer} [scratch] optional reusable scratch; resets to position 0 each call
- * @returns {number} 32-bit unsigned hash
- */
-export function fingerprint_world(world, component_registry, scratch) {
-    assert.ok(world, 'world required');
-    assert.ok(component_registry, 'component_registry required');
-
-    const buffer = scratch === undefined ? new BinaryBuffer() : scratch;
-    let h = 0x811c9dc5; // FNV-1a 32-bit offset basis
-
-    const type_count = component_registry.type_count();
-    for (const entity of world) {
-        for (let type_id = 0; type_id < type_count; type_id++) {
-            const klass = component_registry.class_of(type_id);
-            if (!world.hasComponent(entity, klass)) continue;
-
-            const adapter = component_registry.adapter_for_id(type_id);
-            buffer.position = 0;
-            adapter.serialize(buffer, world.getComponent(entity, klass));
-
-            // Mix entity_id and type_id into the hash so structurally-identical
-            // components on different entities/types produce different prints.
-            h = __fnv_byte(h, entity & 0xFF);
-            h = __fnv_byte(h, (entity >> 8) & 0xFF);
-            h = __fnv_byte(h, (entity >> 16) & 0xFF);
-            h = __fnv_byte(h, (entity >> 24) & 0xFF);
-            h = __fnv_byte(h, type_id);
-
-            const bytes = buffer.raw_bytes;
-            const len = buffer.position;
-            for (let i = 0; i < len; i++) {
-                h = __fnv_byte(h, bytes[i]);
-            }
-        }
-    }
-    return h >>> 0;
-}
-
-/**
- * @private
- */
-function __fnv_byte(h, byte) {
-    h ^= byte;
-    return Math.imul(h, 0x01000193) >>> 0;
-}
-
-/**
- * Diagnostic harness for catching rewind / replay bugs.
- *
- * Usage:
- *   - `harness.checkpoint()` — records the current world fingerprint.
- *   - … run tick logic …
- *   - `harness.assert_recoverable_to_checkpoint(rewind_engine, current_frame, target_frame)`
- *     rewinds and asserts the world's fingerprint matches the checkpoint.
- *
- * For full nondeterminism detection (GGPO-style "save → advance → load →
- * advance → diff"), the application's tick logic must be re-runnable; that
- * coordination is left to the caller. This harness provides the fingerprint +
- * compare primitives and the assertion shape.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class SyncTest {
-    #scratch;
-    #checkpoint_hash;
-    #has_checkpoint;
-
-
-    /**
-     * @param {{
-     *   world: EntityComponentDataset,
-     *   component_registry: ReplicatedComponentRegistry,
-     * }} options
-     */
-    constructor({ world, component_registry }) {
-        assert.ok(world, 'world required');
-        assert.ok(component_registry, 'component_registry required');
-
-        /** @type {EntityComponentDataset} */
-        this.world = world;
-
-        /** @type {ReplicatedComponentRegistry} */
-        this.component_registry = component_registry;
-
-        /** Reused scratch for fingerprint serialization. */
-        this.#scratch = new BinaryBuffer();
-
-        /** @type {number} @private */
-        this.#checkpoint_hash = 0;
-
-        /** @type {boolean} @private */
-        this.#has_checkpoint = false;
-    }
-
-    /**
-     * Capture the current world state as the reference point for the next
-     * `assert_recoverable_to_checkpoint` call.
-     */
-    checkpoint() {
-        this.#checkpoint_hash = fingerprint_world(this.world, this.component_registry, this.#scratch);
-        this.#has_checkpoint = true;
-    }
-
-    /**
-     * @returns {number}
-     */
-    current_fingerprint() {
-        return fingerprint_world(this.world, this.component_registry, this.#scratch);
-    }
-
-    /**
-     * Rewind from `current_frame` back to `target_frame` (typically the frame
-     * at which `checkpoint()` was called) and assert the resulting world state
-     * matches the checkpoint.
-     *
-     * Throws on mismatch with a diagnostic message including both fingerprints.
-     *
-     * @param {RewindEngine} rewind_engine
-     * @param {number} current_frame
-     * @param {number} target_frame
-     */
-    assert_recoverable_to_checkpoint(rewind_engine, current_frame, target_frame) {
-        assert.ok(this.#has_checkpoint, 'SyncTest: no checkpoint() taken before assertion');
-        rewind_engine.rewind_to(current_frame, target_frame);
-        const after = fingerprint_world(this.world, this.component_registry, this.#scratch);
-        if (after !== this.#checkpoint_hash) {
-            throw new Error(
-                `SyncTest: world fingerprint after rewind (${after.toString(16)}) ` +
-                `does not match checkpoint (${this.#checkpoint_hash.toString(16)}) ` +
-                `— rewind is non-deterministic or did not fully restore state`
-            );
-        }
-    }
-}
+import { assert } from "../../../core/assert.js";
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+
+/**
+ * Compute a 32-bit fingerprint of every replicated component on every entity
+ * in the world. Used by `SyncTest` and as a general "did the world state change?"
+ * primitive.
+ *
+ * The hash is FNV-1a — fast, stable, no dependencies. Not cryptographic.
+ *
+ * Iteration order: entities in the order yielded by `world` (the
+ * EntityComponentDataset's iterator), then components in `type_id` order.
+ * As long as both sides iterate identically, the fingerprint is comparable.
+ *
+ * @param {EntityComponentDataset} world
+ * @param {ReplicatedComponentRegistry} component_registry
+ * @param {BinaryBuffer} [scratch] optional reusable scratch; resets to position 0 each call
+ * @returns {number} 32-bit unsigned hash
+ */
+export function fingerprint_world(world, component_registry, scratch) {
+    assert.ok(world, 'world required');
+    assert.ok(component_registry, 'component_registry required');
+
+    const buffer = scratch === undefined ? new BinaryBuffer() : scratch;
+    let h = 0x811c9dc5; // FNV-1a 32-bit offset basis
+
+    const type_count = component_registry.type_count();
+    for (const entity of world) {
+        for (let type_id = 0; type_id < type_count; type_id++) {
+            const klass = component_registry.class_of(type_id);
+            if (!world.hasComponent(entity, klass)) continue;
+
+            const adapter = component_registry.adapter_for_id(type_id);
+            buffer.position = 0;
+            adapter.serialize(buffer, world.getComponent(entity, klass));
+
+            // Mix entity_id and type_id into the hash so structurally-identical
+            // components on different entities/types produce different prints.
+            h = __fnv_byte(h, entity & 0xFF);
+            h = __fnv_byte(h, (entity >> 8) & 0xFF);
+            h = __fnv_byte(h, (entity >> 16) & 0xFF);
+            h = __fnv_byte(h, (entity >> 24) & 0xFF);
+            h = __fnv_byte(h, type_id);
+
+            const bytes = buffer.raw_bytes;
+            const len = buffer.position;
+            for (let i = 0; i < len; i++) {
+                h = __fnv_byte(h, bytes[i]);
+            }
+        }
+    }
+    return h >>> 0;
+}
+
+/**
+ * @private
+ */
+function __fnv_byte(h, byte) {
+    h ^= byte;
+    return Math.imul(h, 0x01000193) >>> 0;
+}
+
+/**
+ * Diagnostic harness for catching rewind / replay bugs.
+ *
+ * Usage:
+ *   - `harness.checkpoint()` — records the current world fingerprint.
+ *   - … run tick logic …
+ *   - `harness.assert_recoverable_to_checkpoint(rewind_engine, current_frame, target_frame)`
+ *     rewinds and asserts the world's fingerprint matches the checkpoint.
+ *
+ * For full nondeterminism detection (GGPO-style "save → advance → load →
+ * advance → diff"), the application's tick logic must be re-runnable; that
+ * coordination is left to the caller. This harness provides the fingerprint +
+ * compare primitives and the assertion shape.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class SyncTest {
+    #scratch;
+    /** @type {number} @private */
+    #checkpoint_hash = 0;
+    /** @type {boolean} @private */
+    #has_checkpoint = false;
+
+    /**
+     * @param {{
+     *   world: EntityComponentDataset,
+     *   component_registry: ReplicatedComponentRegistry,
+     * }} options
+     */
+    constructor({ world, component_registry }) {
+        assert.ok(world, 'world required');
+        assert.ok(component_registry, 'component_registry required');
+
+        /** @type {EntityComponentDataset} */
+        this.world = world;
+
+        /** @type {ReplicatedComponentRegistry} */
+        this.component_registry = component_registry;
+
+        /** Reused scratch for fingerprint serialization. */
+        this.#scratch = new BinaryBuffer();
+    }
+
+    /**
+     * Capture the current world state as the reference point for the next
+     * `assert_recoverable_to_checkpoint` call.
+     */
+    checkpoint() {
+        this.#checkpoint_hash = fingerprint_world(this.world, this.component_registry, this.#scratch);
+        this.#has_checkpoint = true;
+    }
+
+    /**
+     * @returns {number}
+     */
+    current_fingerprint() {
+        return fingerprint_world(this.world, this.component_registry, this.#scratch);
+    }
+
+    /**
+     * Rewind from `current_frame` back to `target_frame` (typically the frame
+     * at which `checkpoint()` was called) and assert the resulting world state
+     * matches the checkpoint.
+     *
+     * Throws on mismatch with a diagnostic message including both fingerprints.
+     *
+     * @param {RewindEngine} rewind_engine
+     * @param {number} current_frame
+     * @param {number} target_frame
+     */
+    assert_recoverable_to_checkpoint(rewind_engine, current_frame, target_frame) {
+        assert.ok(this.#has_checkpoint, 'SyncTest: no checkpoint() taken before assertion');
+        rewind_engine.rewind_to(current_frame, target_frame);
+        const after = fingerprint_world(this.world, this.component_registry, this.#scratch);
+        if (after !== this.#checkpoint_hash) {
+            throw new Error(
+                `SyncTest: world fingerprint after rewind (${after.toString(16)}) ` +
+                `does not match checkpoint (${this.#checkpoint_hash.toString(16)}) ` +
+                `— rewind is non-deterministic or did not fully restore state`
+            );
+        }
+    }
+}

package/src/engine/network/orchestrator/NetworkPeer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkPeer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/NetworkPeer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"NetworkPeer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/NetworkPeer.js"],"names":[],"mappings":";;;;;gCAmCU,MAAM;;;;;;;;;;;;;;;;;;;iCAoGI,MAAM;AAF1B;;;GAGG;AACH;;;;;IAKI;;;;;OAKG;;GAEJ;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IA6BI;;;;;;;;;;;;OAYG;IACH;;;+BAT4B,UAAU;wBACjB,UAAU;;wCACmB,MAAM,cAAc,MAAM,GAAG,OAAO;;yBAChE,MAAM;8BACD,MAAM;0BACV,cAAc,GAAC,IAAI;+BACd,MAAM;OAyNjC;IAtMG,qCAAqC;IACrC,8BAAkB;IAElB,0CAA0C;IAC1C,oBADW,2BAA2B,CACoC;IAK1E,gCAAgC;IAChC,iBADW,iBAAiB,CACkB;IAK9C,mCAAmC;IACnC,YADW,oBAAoB,CACa;IAE5C,wBAAwB;IACxB,YADW,SAAS,CACoD;IAExE;;;;;;;;OAQG;IACH,iBAFU,cAAc,GAAC,IAAI,CAES;IAatC,gCAAgC;IAChC,UADW,iBAAiB,CAQ1B;IAEF,yBAAyB;IACzB,YADW,UAAU,CAOnB;IAEF,uBAAuB;IACvB,UADW,QAAQ,CACW;IAgC9B;;;;;;OAMG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;OAMG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,cAFU,MAAM,CAEgB;IAEhC;;;;;;;;OAQG;IACH,aAFU,MAAM,CAEe;IAE/B;;;;OAIG;IACH,wBAFU,MAAM,CAE0B;IAE1C;;;;;;OAMG;IACH,eAFU,MAAM,CAEiB;IAEjC;;;;;;;OAOG;IACH,eAFU,MAAM,CAEiB;IAEjC;;;;OAIG;IACH,gBAFU,MAAM,CAEkB;IAElC;;;;OAIG;IACH,gBAFU,MAAM,CAEkB;IAElC;;;;;OAKG;IACH,oBAFU,MAAM,CAEsB;IAEtC;;;;;;;;;;;;;OAaG;IACH,mBAFU,MAAM,CAEqB;IAGzC;;;;;;;OAOG;IACH,sBAHW,MAAM;oBACQ,UAAU,UAAU,MAAM,GAAG,IAAI;mBAAa,GAAG;aA0OzE;IAED;;;OAGG;IACH,yBAFW,MAAM,QAgChB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,6BAFa,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,OAAO,GAAC,SAAS,CAK7B;IAED;;;;;;;OAOG;IACH,yBAFW,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,iBAkBC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,8BAFW,MAAM,QAkEhB;IA2CD;;;;;;;;;;;;OAYG;IACH,+BAJW,MAAM,cACN,MAAM,YACN,MAAM,QAchB;IAED;;;;;;;;;;;;;OAaG;IACH,oCAJW,MAAM,cACN,MAAM,YACN,MAAM,QA8ChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBALW,MAAM,gBACN,MAAM,cACN,MAAM,mBACG,YAAY,KAAG,IAAI,QAgBtC;IAED;;;;;;;;;OASG;IACH,2BALW,MAAM,iBACN,UAAU,gBACV,MAAM,mBACG,YAAY,KAAG,IAAI,QAiBtC;IAED;;;;;;;OAOG;IACH,2BALW,MAAM,iBACN,MAAM,oBACN,MAAM,iBACN,UAAU,QAiBpB;IAED;;;OAGG;IACH,4BAFW,MAAM,QAUhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,eACN,MAAM,QAYhB;IAED;;;;;;OAMG;IACH,yBAHW,MAAM,iBACN,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,qCAHW,MAAM,gBACN,MAAM,QAgBhB;IAED;;;;;;;;;;;;;;OAcG;IACH,+BALW,MAAM,WACN,UAAU,UACV,MAAM,GACJ,MAAM,CAUlB;;CACJ;4CAzqC2C,uCAAuC;kCAEjD,6BAA6B;qCAK1B,kCAAkC;0BAR7C,qBAAqB;+BAOhB,4BAA4B;kCALzB,6BAA6B;2BAJpC,8BAA8B;yBAOhC,sBAAsB;mBAV5B,uCAAuC;wBAclC,yBAAyB;6BAfpB,sCAAsC"}