@woosh/meep-engine 3.28.0 → 3.29.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.28.0",
+  "version": "3.29.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/core/binary/BitSet.d.ts

@@ -44,6 +44,14 @@ export class BitSet {
      * @private
      */
     private __data_uint32;
+    /**
+     * Number of set bits in each {@link CHUNK_BITS}-wide span of {@link __data_uint32}.
+     * A chunk reading {@link CHUNK_BITS} is entirely set and {@link nextClearBit} can step
+     * over it without looking at a single word, which is the whole point of keeping this.
+     * @type {Uint16Array}
+     * @private
+     */
+    private __chunk_population;
     /**
      * The fraction of capacity at which to trigger a shrink operation.
      * @type {number}
@@ -86,6 +94,14 @@ export class BitSet {
      * @private
      */
     private __resize;
+    /**
+     * Recomputes the whole chunk population table from the stored words.
+     * Only for the paths that write {@link __data_uint32} wholesale rather than a bit at a
+     * time; {@link set} keeps the table current on its own.
+     * @private
+     * @returns {void}
+     */
+    private __rebuildChunkPopulation;
     /**
      * Updates the internal length of the bitset after clearing bits.
      * @private

package/src/core/binary/BitSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BitSet.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BitSet.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;GAcG;AACH;IA2lBI;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAQlB;IA7lBD;;;OAGG;IACH,+BAFW,MAAM,EAyBhB;IAlCD;;;;OAIG;IACH,iBAAa;IAST;;;;;OAKG;IACH,mBAA4C;IAE5C;;;;OAIG;IACH,sBAA0D;IAE1D;;;OAGG;IACH,gBAFU,MAAM,CAE2B;IAG/C;;;;OAIG;IACH,iBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAOhB;IACD;;;;;;OAMG;IACH,uBAJW,MAAM,GAEJ,IAAI,CAUhB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAsBC;IAED;;;OAGG;IACH,uBAMC;IAED;;;;;OAKG;IACH,oBAyBC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAuClB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAuDlB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,MAAM,CAuDlB;IAED;;;;;OAKG;IACH,eAJW,MAAM,SACN,OAAO,GACL,IAAI,CAmChB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,aACN,MAAM,QAWhB;IAED;;;;OAIG;IACH,wBAHW,MAAM,aACN,MAAM,QAShB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAkBnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAQhB;IAED;;OAEG;IACH,cAgBC;IAED;;;;OAIG;IACH,eAFa,MAAM,CA+BlB;IAED;;;OAGG;IACH,YAFW,MAAM,QAoChB;CAcJ"}
+{"version":3,"file":"BitSet.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BitSet.js"],"names":[],"mappings":"AAgEA;;;;;;;;;;;;;;GAcG;AACH;IA0qBI;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAQlB;IA5qBD;;;OAGG;IACH,+BAFW,MAAM,EAkChB;IA3CD;;;;OAIG;IACH,iBAAa;IAST;;;;;OAKG;IACH,mBAA4C;IAE5C;;;;OAIG;IACH,sBAA0D;IAE1D;;;;;;OAMG;IACH,2BAAkF;IAElF;;;OAGG;IACH,gBAFU,MAAM,CAE2B;IAG/C;;;;OAIG;IACH,iBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAOhB;IACD;;;;;;OAMG;IACH,uBAJW,MAAM,GAEJ,IAAI,CAUhB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAsCC;IAED;;;;;;OAMG;IACH,iCAeC;IAED;;;OAGG;IACH,uBAMC;IAED;;;;;OAKG;IACH,oBAyBC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAwClB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAuDlB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,MAAM,CAuElB;IAED;;;;;OAKG;IACH,eAJW,MAAM,SACN,OAAO,GACL,IAAI,CAiDhB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,aACN,MAAM,QAWhB;IAED;;;;OAIG;IACH,wBAHW,MAAM,aACN,MAAM,QAShB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAkBnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAQhB;IAED;;OAEG;IACH,cAkBC;IAED;;;;OAIG;IACH,eAFa,MAAM,CAsBlB;IAED;;;OAGG;IACH,YAFW,MAAM,QA0ChB;CAcJ"}

package/src/core/binary/BitSet.js

@@ -31,6 +31,37 @@ const RESIZE_COUNT_THRESHOLD = 128;
  */
 const DEFAULT_INITIAL_CAPACITY = 64;
 
+/**
+ * Number of bits summarised by a single entry of the chunk population table.
+ * A chunk holds at most 4096 set bits, which is why a Uint16 entry is enough, and
+ * one entry per 4096 bits costs 0.39% on top of the storage it describes.
+ *
+ * The cost of a scan is one read per chunk to reach the right one, plus up to
+ * CHUNK_BITS/32 reads inside it, so the ideal chunk for a set of N bits is around
+ * sqrt(32N) - roughly 2048 at 100k bits, 8192 at 2M, 32768 at 33M. No single
+ * constant is right everywhere. 4096 is the one that stays closest to the best
+ * across the range this engine actually uses: measured over sets of 10k to 8M bits
+ * it is never worse than 2.5x off the best choice for that size, where 1024 is 4.8x
+ * off at 2M and 32768 is 4.8x off at 50k.
+ * @constant
+ * @type {number}
+ */
+const CHUNK_BITS = 4096;
+
+/**
+ * {@link CHUNK_BITS} as a shift, for turning a bit index into a chunk index
+ * @constant
+ * @type {number}
+ */
+const LOG2_CHUNK_BITS = 12;
+
+/**
+ * Number of 32-bit words in a chunk, as a shift
+ * @constant
+ * @type {number}
+ */
+const LOG2_CHUNK_WORDS = LOG2_CHUNK_BITS - 5;
+
 /**
  * A dynamically resizable bitset (bit array) implementation.
  * The bitset automatically grows and shrinks as bits are set and cleared.
@@ -77,6 +108,15 @@ export class BitSet {
          */
         this.__data_uint32 = new Uint32Array(this.__capacity >> 5);
 
+        /**
+         * Number of set bits in each {@link CHUNK_BITS}-wide span of {@link __data_uint32}.
+         * A chunk reading {@link CHUNK_BITS} is entirely set and {@link nextClearBit} can step
+         * over it without looking at a single word, which is the whole point of keeping this.
+         * @type {Uint16Array}
+         * @private
+         */
+        this.__chunk_population = new Uint16Array(Math.ceil(this.__capacity / CHUNK_BITS));
+
         /**
          * The fraction of capacity at which to trigger a shrink operation.
          * @type {number}
@@ -165,6 +205,46 @@ export class BitSet {
         this.__data_uint32 = newData;
 
         this.__capacity = uint32_capacity * 32;
+
+        // The table is only ever truncated above the highest set bit - a shrink is driven by
+        // __updateLength, and every bit at or past the new length is already clear - so the
+        // counts that survive are still right and the ones that go were zero.
+        const chunk_capacity = Math.ceil(uint32_capacity / (1 << LOG2_CHUNK_WORDS));
+
+        const oldPopulation = this.__chunk_population;
+        const newPopulation = new Uint16Array(chunk_capacity);
+
+        if (oldPopulation.length < chunk_capacity) {
+            newPopulation.set(oldPopulation);
+        } else {
+            newPopulation.set(oldPopulation.subarray(0, chunk_capacity));
+        }
+
+        this.__chunk_population = newPopulation;
+    }
+
+    /**
+     * Recomputes the whole chunk population table from the stored words.
+     * Only for the paths that write {@link __data_uint32} wholesale rather than a bit at a
+     * time; {@link set} keeps the table current on its own.
+     * @private
+     * @returns {void}
+     */
+    __rebuildChunkPopulation() {
+        const data = this.__data_uint32;
+        const population = this.__chunk_population;
+
+        population.fill(0);
+
+        const word_count = data.length;
+
+        for (let word_index = 0; word_index < word_count; word_index++) {
+            const word = data[word_index];
+
+            if (word !== 0) {
+                population[word_index >> LOG2_CHUNK_WORDS] += bitCount(word);
+            }
+        }
     }
 
     /**
@@ -222,38 +302,39 @@ export class BitSet {
 
         const index = min2(from_index, this.__length - 1);
 
+        if (index < 0) {
+            // set is empty, nothing is set at or before any index
+            return -1;
+        }
+
         let word_index = index >> 5;
-        let bit_index = index & 31; // modulo operation is slow, bitwise and is fast, this is the same as %8
+        const bit_index = index & 31; // modulo operation is slow, bitwise and is fast, this is the same as %32
 
         const data = this.__data_uint32;
 
-        let word = data[word_index];
+        // Only the starting word is partial, so it is the only one that needs masking.
+        // `1 << 32` wraps to 1 because JS shifts count modulo 32, so a full word is taken as-is.
+        let word = bit_index === 31
+            ? data[word_index]
+            : data[word_index] & ((1 << (bit_index + 1)) - 1);
 
-        //handle first byte separately due to potential partial traversal
-        for (; bit_index >= 0; bit_index--) {
-            if ((word & (1 << bit_index)) !== 0) {
-                return word_index * 32 + bit_index;
+        // Word at a time. Scanning bit by bit costs 32 iterations for every empty word,
+        // and empty words are the common case on the backward walk from {@link __updateLength}.
+        while (true) {
+
+            if (word !== 0) {
+                // index of the highest set bit within the word
+                return word_index * 32 + (31 - Math.clz32(word >>> 0));
             }
-        }
 
-        //unwind first byte
-        word_index--;
+            word_index--;
 
-        //scan the rest
-        for (; word_index >= 0; word_index--) {
+            if (word_index < 0) {
+                return -1;
+            }
 
             word = data[word_index];
-
-            for (bit_index = 31; bit_index >= 0; bit_index--) {
-
-                if ((word & (1 << bit_index)) !== 0) {
-                    return word_index * 32 + bit_index;
-                }
-
-            }
         }
-
-        return -1;
     }
 
     /**
@@ -354,18 +435,34 @@ export class BitSet {
         const set_length = this.__length;
         const word_count = (set_length + 31) >> 5; // Math.ceil(x /32)
 
-        //scan the rest
-        for (; word_index < word_count; word_index++) {
-            word = data[word_index];
+        const population = this.__chunk_population;
+
+        //scan the rest, a chunk at a time where the chunk has nothing to offer
+        while (word_index < word_count) {
 
-            if (word === 4294967295) {
-                // no 0s
+            const chunk_index = word_index >> LOG2_CHUNK_WORDS;
+
+            if (population[chunk_index] === CHUNK_BITS) {
+                // every bit in this span is set, step over the whole chunk without reading a
+                // word of it. a count below CHUNK_BITS guarantees a clear bit is in here
+                // somewhere, but it may sit past word_count, which the inner bound handles
+                word_index = (chunk_index + 1) << LOG2_CHUNK_WORDS;
                 continue;
             }
 
-            bit_index = lsb_32(~word);
-            return bit_index + word_index * 32;
+            const chunk_end = min2((chunk_index + 1) << LOG2_CHUNK_WORDS, word_count);
+
+            for (; word_index < chunk_end; word_index++) {
+                word = data[word_index];
 
+                if (word === 4294967295) {
+                    // no 0s
+                    continue;
+                }
+
+                bit_index = lsb_32(~word);
+                return bit_index + word_index * 32;
+            }
         }
 
         // Bits at or beyond __length are implicitly clear. When from_index
@@ -397,17 +494,31 @@ export class BitSet {
             const bitIndexInc = bit_index + 1;
 
             if (bitIndexInc > this.__length) {
-                // ensure capacity
+                // ensure capacity, note that this can replace both backing arrays
                 this.__setLength(bitIndexInc);
             }
 
-            //set
-            this.__data_uint32[word_offset] |= word_mask;
+            const data = this.__data_uint32;
+            const word = data[word_offset];
+
+            // the population table only moves when the bit actually changes, so the old value
+            // has to be read either way
+            if ((word & word_mask) === 0) {
+                data[word_offset] = word | word_mask;
 
+                this.__chunk_population[bit_index >> LOG2_CHUNK_BITS]++;
+            }
 
         } else if (bit_index < this.__length) {
-            //clear
-            this.__data_uint32[word_offset] &= ~word_mask;
+            const data = this.__data_uint32;
+            const word = data[word_offset];
+
+            if ((word & word_mask) !== 0) {
+                //clear
+                data[word_offset] = word & ~word_mask;
+
+                this.__chunk_population[bit_index >> LOG2_CHUNK_BITS]--;
+            }
 
             // trim down set size potentially
             this.__updateLength();
@@ -570,6 +681,8 @@ export class BitSet {
             this.__data_uint32.fill(0, 0, Math.ceil(current_length / 32));
         }
 
+        this.__chunk_population.fill(0, 0, Math.ceil(current_length / CHUNK_BITS));
+
         this.__length = 0;
     }
 
@@ -585,25 +698,16 @@ export class BitSet {
             return 0;
         }
 
-        const data = this.__data_uint32;
-        let count = 0;
+        // Every bit at or past __length is clear, so the table already holds the answer and
+        // there is no partial chunk to mask off. One read per CHUNK_BITS rather than per 32.
+        const population = this.__chunk_population;
 
-        // Number of fully utilized 32-bit words
-        const full_words = length >> 5;
+        const chunk_count = (length + (CHUNK_BITS - 1)) >> LOG2_CHUNK_BITS;
 
-        // Count bits in all complete words
-        for (let i = 0; i < full_words; i++) {
-            count += bitCount(data[i]);
-        }
-
-        // Handle any remaining bits in the partial last word
-        const remainder_bits = length & 31;
+        let count = 0;
 
-        if (remainder_bits > 0) {
-            // Create a mask to ignore any bits beyond __length
-            // e.g., if remainder is 3, mask is (1<<3)-1 = 7 (0b111)
-            const mask = (1 << remainder_bits) - 1;
-            count += bitCount(data[full_words] & mask);
+        for (let i = 0; i < chunk_count; i++) {
+            count += population[i];
         }
 
         return count;
@@ -647,6 +751,12 @@ export class BitSet {
 
             this.set(bitIndex, other.get(bitIndex));
         }
+
+        // The word loop above went straight into the storage, past the counting that set()
+        // does, so the table is stale for everything it touched. Rebuilding is the same order
+        // of work as the copy itself, and it is last so that the set() calls above cannot
+        // double count.
+        this.__rebuildChunkPopulation();
     }
 
     /**

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

@@ -116,6 +116,16 @@ export class OffsetAllocator {
      * @type {number}
      */
     freeOffset: number;
+    /**
+     * Whether {@link allocate}`(size)` would land, without allocating: exactly its refusal test —
+     * a node left to describe a remainder with, and a filed run of a bin at or above the one the
+     * request is looked up from. Node exhaustion is the shortfall no arena size answers, and a
+     * probe that ignored it would send a caller to grow for nothing.
+     *
+     * @param {number} size
+     * @returns {boolean}
+     */
+    can_allocate(size: number): boolean;
     /**
      *
      * @param {number} size
@@ -131,6 +141,44 @@ export class OffsetAllocator {
      * @see free
      */
     free_node(node_index: number): void;
+    /**
+     * The used node that starts the arena, or {@link ALLOCATOR_NO_SPACE} when nothing is used.
+     *
+     * Free nodes never adjoin (`free_node` merges both sides), so at most one free node sits
+     * before the first used one, and this is a walk of at most one link.
+     *
+     * @returns {number} node index
+     */
+    first_used_node(): number;
+    /**
+     * The used node after `node_index` in address order, or {@link ALLOCATOR_NO_SPACE} at the
+     * arena's end. At most one free node sits between two used ones, so a walk of at most two
+     * links.
+     *
+     * @param {number} node_index a used node
+     * @returns {number} node index
+     */
+    next_used_node(node_index: number): number;
+    /**
+     * Move a used range down over the free range immediately before it, in O(1).
+     *
+     * The two nodes swap places: the used node's offset drops by the free node's size, the free
+     * node's offset rises by the used node's size. The free node's size — and so its bin — is
+     * unchanged, so its bin-list membership is untouched. If the free node then adjoins a free
+     * successor the two are merged, which returns one node to the freelist; nothing here ever
+     * takes a node. The used node keeps its index, so an {@link Allocation} a caller holds for it
+     * is still its handle — the caller updates the allocation's `offset` by the returned delta,
+     * as this method does not know the object.
+     *
+     * A sliding compactor walks the used nodes in address order calling this on each: every hole
+     * passed gathers into one free node just behind the walk, and the walk ends with all free
+     * space in one run at the tail (COMPACTION_PLAN_2026_09_16 §4.2–4.3).
+     *
+     * @param {number} node_index a used node
+     * @returns {number} how far the range moved: the free predecessor's size, or 0 when the
+     *          predecessor is used or there is none
+     */
+    slide_down(node_index: number): number;
     /**
      * @param {Allocation} allocation
      * @see free_node

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":"AAgBA;;;;;;;;;;;;;;;GAeG;AACH,6CAHW,MAAM,GACJ,MAAM,CAYlB;AA7BD,4CAA6C;AAgE7C;;;;;;;;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;IAqEf;;;;OAIG;IACH,eAHW,MAAM,GACJ,UAAU,CA+EtB;IAED;;;;;;;OAOG;IACH,sBAHW,MAAM,QAqFhB;IAED;;;OAGG;IACH,iBAHW,UAAU,QAUpB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,sBAHW,MAAM,GACJ,MAAM,CA4BlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,eAHW,MAAM,QA8DhB;IA0ID;;;OAGG;IACH,cA4BC;IAED;;;OAGG;IACH,iBAFY,aAAa,CA2BxB;;CACJ;8BAlyB6B,yCAAyC;AAiIvE;IACI,uBAAkB;IAClB,0BAAqB;CACxB"}
+{"version":3,"file":"OffsetAllocator.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/allocator/OffsetAllocator.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;GAeG;AACH,6CAHW,MAAM,GACJ,MAAM,CAYlB;AA7BD,4CAA6C;AAgE7C;;;;;;;;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;IAoFI;;;;OAIG;IACH,kBAHW,MAAM,cACN,MAAM,EAYhB;IAlGD;;;;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;IAqFf;;;;;;;;OAQG;IACH,mBAHW,MAAM,GACJ,OAAO,CAMnB;IAmBD;;;;OAIG;IACH,eAHW,MAAM,GACJ,UAAU,CAwEtB;IAED;;;;;;;OAOG;IACH,sBAHW,MAAM,QAwFhB;IAED;;;;;;;OAOG;IACH,mBAFa,MAAM,CAkBlB;IAED;;;;;;;OAOG;IACH,2BAHW,MAAM,GACJ,MAAM,CAwBlB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,uBAJW,MAAM,GACJ,MAAM,CA4ElB;IAED;;;OAGG;IACH,iBAHW,UAAU,QAUpB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,sBAHW,MAAM,GACJ,MAAM,CA4BlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,eAHW,MAAM,QAiEhB;IA0ID;;;OAGG;IACH,cA4BC;IAED;;;OAGG;IACH,iBAFY,aAAa,CA2BxB;;CACJ;8BAz+B6B,yCAAyC;AAiIvE;IACI,uBAAkB;IAClB,0BAAqB;CACxB"}