@woosh/meep-engine 3.60.6 → 3.60.7

package/package.json

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

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":"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"}
+{"version":3,"file":"BitSet.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BitSet.js"],"names":[],"mappings":"AAiEA;;;;;;;;;;;;;;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

@@ -4,6 +4,7 @@ import { min2 } from "../math/min2.js";
 import { align_32 } from "./align_32.js";
 import { ctz32 } from "./ctz32.js";
 import { bitCount } from "./operations/bitCount.js";
+import { msb_32 } from "./msb_32.js";
 
 /**
  * Used for overallocating space when bit set needs to grow
@@ -324,7 +325,7 @@ export class BitSet {
 
             if (word !== 0) {
                 // index of the highest set bit within the word
-                return word_index * 32 + (31 - Math.clz32(word >>> 0));
+                return word_index * 32 + msb_32(word);
             }
 
             word_index--;

package/src/{format/image/avif/av1/util → core/binary/operations}/ceil_log2.d.ts

@@ -1,6 +1,6 @@
 /**
- * `CeilLog2( x )` from the AV1 specification: the number of bits needed to code a value in the
- * range `0 .. x - 1`. Defined to be `0` for `x < 2`.
+ * `ceil(log2(x))` in integers: the number of bits needed to code a value in the range `0 .. x - 1`.
+ * Defined to be `0` for `x < 2`. The AV1 specification's `CeilLog2( x )`.
  *
  * @param {number} x 32-bit unsigned integer, `>= 0`
  * @returns {number}

package/src/core/binary/operations/ceil_log2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceil_log2.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/operations/ceil_log2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,6BAPW,MAAM,GACJ,MAAM,CAYlB"}

package/src/{format/image/avif/av1/util → core/binary/operations}/ceil_log2.js

@@ -1,18 +1,18 @@
-/**
- * `CeilLog2( x )` from the AV1 specification: the number of bits needed to code a value in the
- * range `0 .. x - 1`. Defined to be `0` for `x < 2`.
- *
- * @param {number} x 32-bit unsigned integer, `>= 0`
- * @returns {number}
- * @see AV1 spec 4.7 "Mathematical functions"
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function ceil_log2(x) {
-    if (x < 2) {
-        return 0;
-    }
-
-    return 32 - Math.clz32(x - 1);
-}
+/**
+ * `ceil(log2(x))` in integers: the number of bits needed to code a value in the range `0 .. x - 1`.
+ * Defined to be `0` for `x < 2`. The AV1 specification's `CeilLog2( x )`.
+ *
+ * @param {number} x 32-bit unsigned integer, `>= 0`
+ * @returns {number}
+ * @see AV1 spec 4.7 "Mathematical functions"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function ceil_log2(x) {
+    if (x < 2) {
+        return 0;
+    }
+
+    return 32 - Math.clz32(x - 1);
+}

package/src/core/binary/zstd/ZstdReverseBitReader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ZstdReverseBitReader.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/zstd/ZstdReverseBitReader.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;GAiBG;AACH;IA0BI;;;;;;;;;OASG;IACH,WAPW,UAAU,eACV,MAAM,eACN,MAAM,GACJ,oBAAoB,CAgChC;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;;;;OAOG;IACH,4BAEC;IAED;;;;;;;;;;OAUG;IACH,YAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,eAFW,MAAM,QAIhB;IAED;;;;;;;;OAQG;IACH,YAHW,MAAM,GACJ,MAAM,CA+ClB;;CAuBJ"}
+{"version":3,"file":"ZstdReverseBitReader.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/zstd/ZstdReverseBitReader.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;GAiBG;AACH;IA0BI;;;;;;;;;OASG;IACH,WAPW,UAAU,eACV,MAAM,eACN,MAAM,GACJ,oBAAoB,CAgChC;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;;;;OAOG;IACH,4BAEC;IAED;;;;;;;;;;OAUG;IACH,YAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,eAFW,MAAM,QAIhB;IAED;;;;;;;;OAQG;IACH,YAHW,MAAM,GACJ,MAAM,CA+ClB;;CAuBJ"}

package/src/core/binary/zstd/ZstdReverseBitReader.js

@@ -1,223 +1,225 @@
-/**
- * Most bits one {@link ZstdReverseBitReader#read} can take in a single extraction.
- *
- * A read is served by a four-byte window shifted by up to seven bits, so twenty-five bits are
- * reachable; twenty-four keeps the shift inside the range where JavaScript's bitwise operators are
- * exact. Wider reads are split.
- *
- * @readonly
- * @type {number}
- */
-const MAX_SINGLE_READ = 24;
-
-/**
- * A backward bit cursor, which is how every entropy-coded stream in Zstandard is read.
- *
- * **Backward is not the same as reversed.** The encoder writes bits forward and the decoder consumes
- * them from the end, but the bits themselves keep their order — so the first bit a decoder sees is
- * the *last* one written, and a value of several bits comes out with the first-read bit as its most
- * significant. Finite State Entropy requires this: its state carries from symbol to symbol, so
- * decoding has to run opposite to encoding.
- *
- * **The stream says where it ends by where its padding stops.** The encoder writes a single set bit
- * after the last useful one and zero-fills the rest of the byte, so the highest set bit of the final
- * byte is a marker rather than data, and a final byte of zero is malformed. Finding that bit is how
- * the reader knows which bit to start on.
- *
- * @see RFC 8878, sections 4.1 and 4.2.2
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class ZstdReverseBitReader {
-    /**
-     * Bytes being read. Not owned.
-     * @type {Uint8Array}
-     */
-    #data = null;
-
-    /**
-     * Index into {@link #data} of the first readable byte.
-     * @type {number}
-     */
-    #start = 0;
-
-    /**
-     * Index into {@link #data} one past the last readable byte.
-     * @type {number}
-     */
-    #end = 0;
-
-    /**
-     * Index of the next bit to read, counted in bits from {@link #start} and *decreasing* as the
-     * stream is consumed. Negative once the stream is spent.
-     * @type {number}
-     */
-    #bit = 0;
-
-    /**
-     * Point the reader at a range and skip its padding.
-     *
-     * @param {Uint8Array} data
-     * @param {number} byte_offset
-     * @param {number} byte_length
-     * @returns {ZstdReverseBitReader} this
-     * @throws {Error} for an empty range, or one whose last byte is zero and so carries no padding
-     * marker
-     */
-    init(data, byte_offset, byte_length) {
-        if (byte_length <= 0) {
-            throw new Error("zstd: an entropy-coded stream cannot be empty");
-        }
-
-        const last = data[byte_offset + byte_length - 1];
-
-        if (last === 0) {
-            throw new Error(
-                "zstd: an entropy-coded stream ends in a zero byte, which cannot happen — the"
-                + " encoder writes a set bit after the last useful one, so the final byte always has"
-                + " one"
-            );
-        }
-
-        this.#data = data;
-        this.#start = byte_offset;
-        this.#end = byte_offset + byte_length;
-
-        /*
-         The highest set bit of the last byte is the padding marker. Everything above it is zero fill
-         and the marker itself is not data, so reading starts just below it.
-        */
-        const highest = 31 - Math.clz32(last);
-
-        this.#bit = byte_length * 8 - (8 - highest) - 1;
-
-        return this;
-    }
-
-    /**
-     * Bits left, including the one about to be read.
-     *
-     * @returns {number}
-     */
-    get remaining() {
-        return this.#bit + 1;
-    }
-
-    /**
-     * Whether the stream has been consumed exactly.
-     *
-     * A well-formed stream ends here; one that stops short or overruns is corrupt, which is a check
-     * the callers make rather than this reader, since only they know how many symbols were due.
-     *
-     * @returns {boolean}
-     */
-    get is_exhausted() {
-        return this.#bit === -1;
-    }
-
-    /**
-     * Read `count` bits, the first read becoming the most significant.
-     *
-     * **Past the start of the stream reads zeros.** That is the format's rule rather than leniency:
-     * a Finite State Entropy decoder is expected to keep going when the bits run out, and the
-     * specification says outright that the missing bits are taken as zero. Whether the stream ended
-     * where it should is a question the caller answers from {@link is_exhausted}.
-     *
-     * @param {number} count `0` to `32`
-     * @returns {number}
-     */
-    read(count) {
-        const value = this.peek(count);
-
-        this.#bit -= count;
-
-        return value;
-    }
-
-    /**
-     * Drop `count` bits without reading them.
-     *
-     * @param {number} count
-     */
-    consume(count) {
-        this.#bit -= count;
-    }
-
-    /**
-     * Look at the next `count` bits without consuming them.
-     *
-     * Huffman decoding needs this: the table is indexed by the widest code, so a lookup reads more
-     * bits than the code turned out to use and gives the rest back.
-     *
-     * @param {number} count `0` to `32`
-     * @returns {number}
-     */
-    peek(count) {
-        if (count === 0) {
-            return 0;
-        }
-
-        if (count > MAX_SINGLE_READ) {
-            // split, keeping the first-read half the more significant one
-            const high = count - MAX_SINGLE_READ;
-
-            const upper = this.peek(high);
-
-            this.#bit -= high;
-
-            const lower = this.peek(MAX_SINGLE_READ);
-
-            this.#bit += high;
-
-            return upper * (2 ** MAX_SINGLE_READ) + lower;
-        }
-
-        const low_bit = this.#bit - count + 1;
-
-        if (low_bit + count <= 0) {
-            // entirely past the start
-            return 0;
-        }
-
-        let byte = this.#start + (low_bit >> 3);
-
-        let shift = low_bit & 7;
-
-        if (low_bit < 0) {
-            /*
-             Straddling the start. The bits below it are zero by the rule above, so the window is
-             taken from the first real byte and shifted up to put them there.
-            */
-            byte = this.#start;
-            shift = 0;
-
-            const value = this.#window(byte) << -low_bit;
-
-            return value & ((1 << count) - 1);
-        }
-
-        return (this.#window(byte) >>> shift) & ((1 << count) - 1);
-    }
-
-    /**
-     * Four bytes from `byte` as a little-endian value, zero past the end of the range.
-     *
-     * @param {number} byte
-     * @returns {number}
-     */
-    #window(byte) {
-        let value = 0;
-
-        for (let i = 0; i < 4; i++) {
-            const at = byte + i;
-
-            if (at >= this.#end || at < this.#start) {
-                continue;
-            }
-
-            value |= this.#data[at] << (i * 8);
-        }
-
-        return value >>> 0;
-    }
-}
+import { msb_32 } from "../msb_32.js";
+
+/**
+ * Most bits one {@link ZstdReverseBitReader#read} can take in a single extraction.
+ *
+ * A read is served by a four-byte window shifted by up to seven bits, so twenty-five bits are
+ * reachable; twenty-four keeps the shift inside the range where JavaScript's bitwise operators are
+ * exact. Wider reads are split.
+ *
+ * @readonly
+ * @type {number}
+ */
+const MAX_SINGLE_READ = 24;
+
+/**
+ * A backward bit cursor, which is how every entropy-coded stream in Zstandard is read.
+ *
+ * **Backward is not the same as reversed.** The encoder writes bits forward and the decoder consumes
+ * them from the end, but the bits themselves keep their order — so the first bit a decoder sees is
+ * the *last* one written, and a value of several bits comes out with the first-read bit as its most
+ * significant. Finite State Entropy requires this: its state carries from symbol to symbol, so
+ * decoding has to run opposite to encoding.
+ *
+ * **The stream says where it ends by where its padding stops.** The encoder writes a single set bit
+ * after the last useful one and zero-fills the rest of the byte, so the highest set bit of the final
+ * byte is a marker rather than data, and a final byte of zero is malformed. Finding that bit is how
+ * the reader knows which bit to start on.
+ *
+ * @see RFC 8878, sections 4.1 and 4.2.2
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ZstdReverseBitReader {
+    /**
+     * Bytes being read. Not owned.
+     * @type {Uint8Array}
+     */
+    #data = null;
+
+    /**
+     * Index into {@link #data} of the first readable byte.
+     * @type {number}
+     */
+    #start = 0;
+
+    /**
+     * Index into {@link #data} one past the last readable byte.
+     * @type {number}
+     */
+    #end = 0;
+
+    /**
+     * Index of the next bit to read, counted in bits from {@link #start} and *decreasing* as the
+     * stream is consumed. Negative once the stream is spent.
+     * @type {number}
+     */
+    #bit = 0;
+
+    /**
+     * Point the reader at a range and skip its padding.
+     *
+     * @param {Uint8Array} data
+     * @param {number} byte_offset
+     * @param {number} byte_length
+     * @returns {ZstdReverseBitReader} this
+     * @throws {Error} for an empty range, or one whose last byte is zero and so carries no padding
+     * marker
+     */
+    init(data, byte_offset, byte_length) {
+        if (byte_length <= 0) {
+            throw new Error("zstd: an entropy-coded stream cannot be empty");
+        }
+
+        const last = data[byte_offset + byte_length - 1];
+
+        if (last === 0) {
+            throw new Error(
+                "zstd: an entropy-coded stream ends in a zero byte, which cannot happen — the"
+                + " encoder writes a set bit after the last useful one, so the final byte always has"
+                + " one"
+            );
+        }
+
+        this.#data = data;
+        this.#start = byte_offset;
+        this.#end = byte_offset + byte_length;
+
+        /*
+         The highest set bit of the last byte is the padding marker. Everything above it is zero fill
+         and the marker itself is not data, so reading starts just below it.
+        */
+        const highest = msb_32(last);
+
+        this.#bit = byte_length * 8 - (8 - highest) - 1;
+
+        return this;
+    }
+
+    /**
+     * Bits left, including the one about to be read.
+     *
+     * @returns {number}
+     */
+    get remaining() {
+        return this.#bit + 1;
+    }
+
+    /**
+     * Whether the stream has been consumed exactly.
+     *
+     * A well-formed stream ends here; one that stops short or overruns is corrupt, which is a check
+     * the callers make rather than this reader, since only they know how many symbols were due.
+     *
+     * @returns {boolean}
+     */
+    get is_exhausted() {
+        return this.#bit === -1;
+    }
+
+    /**
+     * Read `count` bits, the first read becoming the most significant.
+     *
+     * **Past the start of the stream reads zeros.** That is the format's rule rather than leniency:
+     * a Finite State Entropy decoder is expected to keep going when the bits run out, and the
+     * specification says outright that the missing bits are taken as zero. Whether the stream ended
+     * where it should is a question the caller answers from {@link is_exhausted}.
+     *
+     * @param {number} count `0` to `32`
+     * @returns {number}
+     */
+    read(count) {
+        const value = this.peek(count);
+
+        this.#bit -= count;
+
+        return value;
+    }
+
+    /**
+     * Drop `count` bits without reading them.
+     *
+     * @param {number} count
+     */
+    consume(count) {
+        this.#bit -= count;
+    }
+
+    /**
+     * Look at the next `count` bits without consuming them.
+     *
+     * Huffman decoding needs this: the table is indexed by the widest code, so a lookup reads more
+     * bits than the code turned out to use and gives the rest back.
+     *
+     * @param {number} count `0` to `32`
+     * @returns {number}
+     */
+    peek(count) {
+        if (count === 0) {
+            return 0;
+        }
+
+        if (count > MAX_SINGLE_READ) {
+            // split, keeping the first-read half the more significant one
+            const high = count - MAX_SINGLE_READ;
+
+            const upper = this.peek(high);
+
+            this.#bit -= high;
+
+            const lower = this.peek(MAX_SINGLE_READ);
+
+            this.#bit += high;
+
+            return upper * (2 ** MAX_SINGLE_READ) + lower;
+        }
+
+        const low_bit = this.#bit - count + 1;
+
+        if (low_bit + count <= 0) {
+            // entirely past the start
+            return 0;
+        }
+
+        let byte = this.#start + (low_bit >> 3);
+
+        let shift = low_bit & 7;
+
+        if (low_bit < 0) {
+            /*
+             Straddling the start. The bits below it are zero by the rule above, so the window is
+             taken from the first real byte and shifted up to put them there.
+            */
+            byte = this.#start;
+            shift = 0;
+
+            const value = this.#window(byte) << -low_bit;
+
+            return value & ((1 << count) - 1);
+        }
+
+        return (this.#window(byte) >>> shift) & ((1 << count) - 1);
+    }
+
+    /**
+     * Four bytes from `byte` as a little-endian value, zero past the end of the range.
+     *
+     * @param {number} byte
+     * @returns {number}
+     */
+    #window(byte) {
+        let value = 0;
+
+        for (let i = 0; i < 4; i++) {
+            const at = byte + i;
+
+            if (at >= this.#end || at < this.#start) {
+                continue;
+            }
+
+            value |= this.#data[at] << (i * 8);
+        }
+
+        return value >>> 0;
+    }
+}

package/src/core/binary/zstd/zstd_fse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zstd_fse.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/zstd/zstd_fse.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,6CATW,UAAU,GAAC,MAAM,EAAE,gBACnB,MAAM,gBACN,MAAM,GACJ,YAAY,CAgFxB;AAED;;;;;;;;;;;;;GAaG;AACH,0CARW,UAAU,UACV,MAAM,OACN,MAAM,cACN,MAAM,oBACN,MAAM,GACJ;IAAC,KAAK,EAAE,YAAY,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAkItD;AAED;;;;;GAKG;AACH,0CAHW,MAAM,GACJ,YAAY,CASxB;;;;;;;;;;;;kBAjQa,MAAM;;;;YAEN,UAAU;;;;UACV,UAAU;;;;cACV,WAAW"}
+{"version":3,"file":"zstd_fse.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/zstd/zstd_fse.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,6CATW,UAAU,GAAC,MAAM,EAAE,gBACnB,MAAM,gBACN,MAAM,GACJ,YAAY,CAgFxB;AAED;;;;;;;;;;;;;GAaG;AACH,0CARW,UAAU,UACV,MAAM,OACN,MAAM,cACN,MAAM,oBACN,MAAM,GACJ;IAAC,KAAK,EAAE,YAAY,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAkItD;AAED;;;;;GAKG;AACH,0CAHW,MAAM,GACJ,YAAY,CASxB;;;;;;;;;;;;kBAjQa,MAAM;;;;YAEN,UAAU;;;;UACV,UAAU;;;;cACV,WAAW"}