@woosh/meep-engine 3.14.1 → 3.14.3

package/src/format/texture/basis/BasisBitReader.js

@@ -0,0 +1,231 @@
+/**
+ * Bits are consumed into a 32-bit accumulator; this is how many it may hold.
+ *
+ * @readonly
+ * @type {number}
+ */
+const ACCUMULATOR_CAPACITY = 32;
+
+/**
+ * LSB-first bit cursor over a byte range, with the speculative peek a Huffman decoder needs.
+ *
+ * **Why this is not {@link BitReader}.** `format/image/avif/bitstream/BitReader.js` is the other bit
+ * reader in this tree and it does not fit, for two reasons that are about the format rather than
+ * about convenience:
+ *
+ * 1. **It is MSB-first, and Basis is LSB-first.** The specification is explicit — "Huffman codes are
+ *    stored in each output byte in LSB to MSB order. (This is opposite of the JPEG format)". Bit
+ *    order is not a parameter that could be added the way {@link ByteCursor} took a byte order:
+ *    a byte order is a property of a *field*, applied once per read, while a bit order changes what
+ *    the single-bit primitive means and so changes every accessor beneath it.
+ * 2. **Huffman decoding needs peek-then-consume, which a descriptor reader has no reason to offer.**
+ *    A canonical code's length is not known until it has been looked up, so the decoder reads bits
+ *    it may not consume. `BitReader`'s `f(n)` is sequential by construction.
+ *
+ * One class doing both would be a flag on every method. So this is a second bit reader,
+ * deliberately, and it stays in `basis/` rather than moving to `core/binary/` until something other
+ * than Basis wants it — the same rule `ByteCursor` moved under, applied in the direction that says
+ * "not yet".
+ *
+ * **Peeking past the end reads zeros; consuming past it throws.** The two have to differ. A Huffman
+ * peek is speculative and legitimately runs off the end of a section — the last code in a stream is
+ * rarely flush with a byte boundary — so refusing there would refuse well-formed files. Consuming is
+ * a different claim, and a stream that runs out mid-symbol is corrupt.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class BasisBitReader {
+    /**
+     * Bytes being read. Not owned.
+     * @type {Uint8Array}
+     */
+    #data = null;
+
+    /**
+     * Index into {@link #data} of the next byte to pull into {@link #accumulator}.
+     * @type {number}
+     */
+    #byte_position = 0;
+
+    /**
+     * Index into {@link #data} one past the last readable byte.
+     * @type {number}
+     */
+    #end = 0;
+
+    /**
+     * Buffered bits, least significant first. Only the low {@link #bit_count} are meaningful.
+     * @type {number}
+     */
+    #accumulator = 0;
+
+    /**
+     * How many of {@link #accumulator}'s bits are meaningful.
+     * @type {number}
+     */
+    #bit_count = 0;
+
+    /**
+     * Bits of {@link #accumulator} that were manufactured past {@link #end} rather than read.
+     *
+     * They sit at the most significant end, since that is where a refill puts them. Consuming far
+     * enough to reach them is the overrun that throws.
+     *
+     * @type {number}
+     */
+    #phantom_bits = 0;
+
+    /**
+     * Point the reader at a byte range.
+     *
+     * @param {Uint8Array} data
+     * @param {number} [byte_offset]
+     * @param {number} [byte_length]
+     * @returns {BasisBitReader} this
+     * @throws {Error} for a range outside `data`
+     */
+    init(data, byte_offset = 0, byte_length = data.length - byte_offset) {
+        if (byte_offset < 0 || byte_length < 0 || byte_offset + byte_length > data.length) {
+            throw new Error(
+                `Basis: a bit reader range of [${byte_offset}, ${byte_offset + byte_length}) is`
+                + ` outside the ${data.length} byte buffer it was given`
+            );
+        }
+
+        this.#data = data;
+        this.#byte_position = byte_offset;
+        this.#end = byte_offset + byte_length;
+        this.#accumulator = 0;
+        this.#bit_count = 0;
+        this.#phantom_bits = 0;
+
+        return this;
+    }
+
+    /**
+     * Fill {@link #accumulator} to at least `count` meaningful bits, manufacturing zeros past the
+     * end of the range.
+     *
+     * @param {number} count
+     */
+    #fill(count) {
+        while (this.#bit_count < count) {
+            const past_end = this.#byte_position >= this.#end;
+
+            const byte = past_end ? 0 : this.#data[this.#byte_position];
+
+            if (past_end) {
+                this.#phantom_bits += 8;
+            }
+
+            this.#byte_position++;
+
+            /*
+             `<<` is a signed 32-bit shift, so a byte landing on bits 24..31 would make the
+             accumulator negative; `>>> 0` puts it back in the unsigned range the masks assume.
+            */
+            this.#accumulator = (this.#accumulator | (byte << this.#bit_count)) >>> 0;
+            this.#bit_count += 8;
+        }
+    }
+
+    /**
+     * Look at the next `count` bits without consuming them. Bits past the end of the range read as
+     * zero — see the note on the class.
+     *
+     * @param {number} count `0` to 24; the Huffman decoder's longest peek is 16
+     * @returns {number}
+     */
+    peek(count) {
+        if (count === 0) {
+            return 0;
+        }
+
+        this.#fill(count);
+
+        return this.#accumulator & ((1 << count) - 1);
+    }
+
+    /**
+     * Drop the next `count` bits.
+     *
+     * @param {number} count
+     * @throws {Error} when the bits dropped were never in the range
+     */
+    consume(count) {
+        if (count === 0) {
+            return;
+        }
+
+        this.#fill(count);
+
+        /*
+         The phantom bits sit at the top of the accumulator, so the bits being consumed are real
+         exactly when the meaningful ones below them outnumber the request.
+        */
+        if (this.#bit_count - this.#phantom_bits < count) {
+            throw new Error(
+                `Basis: the bitstream ended mid-symbol — ${count} bits were asked for and only`
+                + ` ${Math.max(this.#bit_count - this.#phantom_bits, 0)} remain in the section`
+            );
+        }
+
+        this.#accumulator = count === ACCUMULATOR_CAPACITY ? 0 : this.#accumulator >>> count;
+
+        this.#bit_count -= count;
+    }
+
+    /**
+     * Read `count` bits, least significant first.
+     *
+     * @param {number} count `0` to 24
+     * @returns {number}
+     * @throws {Error} when the range does not hold them
+     */
+    bits(count) {
+        const value = this.peek(count);
+
+        this.consume(count);
+
+        return value;
+    }
+
+    /**
+     * The specification's variable-length code: `chunk_bits` of payload plus a continuation bit,
+     * repeated until the continuation bit is clear.
+     *
+     * @param {number} chunk_bits
+     * @returns {number}
+     * @throws {Error} for a code that would not fit in 32 bits, which is a corrupt stream rather
+     * than a large number
+     * @see the specification's `decode_vlc`, section 10.2
+     */
+    vlc(chunk_bits) {
+        const chunk_size = 1 << chunk_bits;
+        const chunk_mask = chunk_size - 1;
+
+        let value = 0;
+        let offset = 0;
+
+        for (; ;) {
+            const chunk = this.bits(chunk_bits + 1);
+
+            value |= (chunk & chunk_mask) << offset;
+            offset += chunk_bits;
+
+            if ((chunk & chunk_size) === 0) {
+                break;
+            }
+
+            if (offset >= ACCUMULATOR_CAPACITY) {
+                throw new Error(
+                    `Basis: a variable-length code ran past ${ACCUMULATOR_CAPACITY} bits without`
+                    + ` terminating, which no valid stream does`
+                );
+            }
+        }
+
+        return value >>> 0;
+    }
+}

package/src/format/texture/basis/BasisHuffmanTable.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Longest code the format permits, from the specification's `cHuffmanMaxSupportedCodeSize`.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const HUFFMAN_MAX_CODE_SIZE: number;
+/**
+ * Most symbols a table may describe, from the specification's `cHuffmanMaxSyms` — `1 << 14`.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const HUFFMAN_MAX_SYMBOLS: number;
+/**
+ * A canonical Huffman decoding table, built from per-symbol code lengths.
+ *
+ * **Canonical in the Deflate sense**, which the specification says outright: codes are assigned in
+ * order of increasing length and, within a length, increasing symbol. What differs from Deflate is
+ * only where the bits come from — {@link BasisBitReader} hands them over least significant first, so
+ * a code appears in the stream with its bits reversed, and the fast table is indexed by that
+ * reversal.
+ *
+ * **Incomplete tables are legal.** The specification calls out the single-symbol case explicitly —
+ * one symbol with a one-bit code, assigned the code zero, leaving half the code space unused. So an
+ * under-full table is built rather than refused, and only a code that actually lands in the unused
+ * space throws.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class BasisHuffmanTable {
+    /**
+     * Build the table from an array of per-symbol code lengths, `0` meaning "symbol not used".
+     *
+     * @param {Uint8Array} code_lengths
+     * @returns {BasisHuffmanTable} this
+     * @throws {Error} for a length past the format's maximum, or a set of lengths that
+     * over-subscribes the code space
+     */
+    init(code_lengths: Uint8Array): BasisHuffmanTable;
+    /**
+     * Read one symbol.
+     *
+     * @param {BasisBitReader} reader
+     * @returns {number} the symbol
+     * @throws {Error} for a prefix that matches no code in the table
+     */
+    decode(reader: BasisBitReader): number;
+    #private;
+}
+import { BasisBitReader } from "./BasisBitReader.js";
+//# sourceMappingURL=BasisHuffmanTable.d.ts.map

package/src/format/texture/basis/BasisHuffmanTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BasisHuffmanTable.d.ts","sourceRoot":"","sources":["../../../../../src/format/texture/basis/BasisHuffmanTable.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,oCAFU,MAAM,CAEwB;AAExC;;;;;GAKG;AACH,kCAFU,MAAM,CAE2B;AAsB3C;;;;;;;;;;;;;;;;GAgBG;AACH;IAqCI;;;;;;;OAOG;IACH,mBALW,UAAU,GACR,iBAAiB,CAyE7B;IAiDD;;;;;;OAMG;IACH,eAJW,cAAc,GACZ,MAAM,CAuClB;;CACJ;+BAtQ8B,qBAAqB"}

package/src/format/texture/basis/BasisHuffmanTable.js

@@ -0,0 +1,263 @@
+import { BasisBitReader } from "./BasisBitReader.js";
+
+/**
+ * Longest code the format permits, from the specification's `cHuffmanMaxSupportedCodeSize`.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const HUFFMAN_MAX_CODE_SIZE = 16;
+
+/**
+ * Most symbols a table may describe, from the specification's `cHuffmanMaxSyms` — `1 << 14`.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const HUFFMAN_MAX_SYMBOLS = 1 << 14;
+
+/**
+ * Bits the fast lookup covers. A code no longer than this is decoded by one array read.
+ *
+ * Ten is the reference decoder's choice and a reasonable one: the table costs 1024 entries per
+ * Huffman table, and the codes that miss it are by construction the rare symbols.
+ *
+ * @readonly
+ * @type {number}
+ */
+const FAST_LOOKUP_BITS = 10;
+
+/**
+ * Bits of a {@link BasisHuffmanTable#fast} entry given over to the code length, which is at most
+ * {@link HUFFMAN_MAX_CODE_SIZE} and so needs five.
+ *
+ * @readonly
+ * @type {number}
+ */
+const FAST_LENGTH_BITS = 5;
+
+/**
+ * A canonical Huffman decoding table, built from per-symbol code lengths.
+ *
+ * **Canonical in the Deflate sense**, which the specification says outright: codes are assigned in
+ * order of increasing length and, within a length, increasing symbol. What differs from Deflate is
+ * only where the bits come from — {@link BasisBitReader} hands them over least significant first, so
+ * a code appears in the stream with its bits reversed, and the fast table is indexed by that
+ * reversal.
+ *
+ * **Incomplete tables are legal.** The specification calls out the single-symbol case explicitly —
+ * one symbol with a one-bit code, assigned the code zero, leaving half the code space unused. So an
+ * under-full table is built rather than refused, and only a code that actually lands in the unused
+ * space throws.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class BasisHuffmanTable {
+    /**
+     * `(symbol << FAST_LENGTH_BITS) | code_length` for each of the `1 << FAST_LOOKUP_BITS` possible
+     * peeks, or `0` where no code of at most {@link FAST_LOOKUP_BITS} bits starts with those bits.
+     *
+     * Packed into one array rather than two because it is read once per symbol on the hottest path
+     * in the transcoder.
+     *
+     * @type {Int32Array}
+     */
+    #fast = null;
+
+    /**
+     * Number of codes of each length, indexed by length. Entry 0 is unused.
+     * @type {Int32Array}
+     */
+    #length_count = null;
+
+    /**
+     * Smallest canonical code of each length, most significant bit first.
+     * @type {Int32Array}
+     */
+    #first_code = null;
+
+    /**
+     * Index into {@link #sorted_symbols} of the first symbol of each length.
+     * @type {Int32Array}
+     */
+    #first_index = null;
+
+    /**
+     * Symbols with a non-zero code length, ordered by length then by symbol — which is the order
+     * canonical codes are assigned in, so a code's rank within its length indexes straight into it.
+     * @type {Int32Array}
+     */
+    #sorted_symbols = null;
+
+    /**
+     * Build the table from an array of per-symbol code lengths, `0` meaning "symbol not used".
+     *
+     * @param {Uint8Array} code_lengths
+     * @returns {BasisHuffmanTable} this
+     * @throws {Error} for a length past the format's maximum, or a set of lengths that
+     * over-subscribes the code space
+     */
+    init(code_lengths) {
+        const symbol_count = code_lengths.length;
+
+        const length_count = new Int32Array(HUFFMAN_MAX_CODE_SIZE + 1);
+
+        for (let symbol = 0; symbol < symbol_count; symbol++) {
+            const length = code_lengths[symbol];
+
+            if (length > HUFFMAN_MAX_CODE_SIZE) {
+                throw new Error(
+                    `Basis: a Huffman symbol declares a code length of ${length} bits, and the`
+                    + ` format's longest code is ${HUFFMAN_MAX_CODE_SIZE}`
+                );
+            }
+
+            length_count[length]++;
+        }
+
+        // a length of zero means "unused", not "a zero-bit code", so it takes no code space
+        length_count[0] = 0;
+
+        const first_code = new Int32Array(HUFFMAN_MAX_CODE_SIZE + 2);
+        const first_index = new Int32Array(HUFFMAN_MAX_CODE_SIZE + 2);
+
+        let code = 0;
+        let index = 0;
+
+        for (let length = 1; length <= HUFFMAN_MAX_CODE_SIZE; length++) {
+            first_code[length] = code;
+            first_index[length] = index;
+
+            code += length_count[length];
+            index += length_count[length];
+
+            /*
+             After absorbing every code of this length, `code` counts the codes that would exist if
+             the tree were full at this depth. More than that means two symbols were handed the same
+             prefix, which is a corrupt table rather than an unusual one — unlike the under-full case
+             the specification explicitly permits.
+            */
+            if (code > (1 << length)) {
+                throw new Error(
+                    `Basis: the Huffman code lengths over-subscribe the code space at length`
+                    + ` ${length}, so no canonical table can be built from them`
+                );
+            }
+
+            code <<= 1;
+        }
+
+        const sorted_symbols = new Int32Array(index);
+        const next_index = first_index.slice();
+
+        for (let symbol = 0; symbol < symbol_count; symbol++) {
+            const length = code_lengths[symbol];
+
+            if (length !== 0) {
+                sorted_symbols[next_index[length]++] = symbol;
+            }
+        }
+
+        this.#length_count = length_count;
+        this.#first_code = first_code;
+        this.#first_index = first_index;
+        this.#sorted_symbols = sorted_symbols;
+
+        this.#build_fast_lookup(code_lengths, symbol_count);
+
+        return this;
+    }
+
+    /**
+     * Fill {@link #fast} so a peek of {@link FAST_LOOKUP_BITS} bits resolves any short code without
+     * walking the tree.
+     *
+     * @param {Uint8Array} code_lengths
+     * @param {number} symbol_count
+     */
+    #build_fast_lookup(code_lengths, symbol_count) {
+        const fast = new Int32Array(1 << FAST_LOOKUP_BITS);
+
+        const next_code = this.#first_code.slice();
+
+        for (let symbol = 0; symbol < symbol_count; symbol++) {
+            const length = code_lengths[symbol];
+
+            if (length === 0) {
+                continue;
+            }
+
+            const canonical = next_code[length]++;
+
+            if (length > FAST_LOOKUP_BITS) {
+                // left to the slow path, which rebuilds the code as it reads rather than tabulating
+                continue;
+            }
+
+            /*
+             The stream hands bits over least significant first, so a code arrives reversed within
+             its own width. Every peek whose low `length` bits match that reversal decodes to this
+             symbol, whatever the bits above happen to be — which is what the stride fills in.
+            */
+            let reversed = 0;
+
+            for (let bit = 0; bit < length; bit++) {
+                reversed |= ((canonical >>> (length - 1 - bit)) & 1) << bit;
+            }
+
+            const packed = (symbol << FAST_LENGTH_BITS) | length;
+
+            for (let i = reversed; i < fast.length; i += 1 << length) {
+                fast[i] = packed;
+            }
+        }
+
+        this.#fast = fast;
+    }
+
+    /**
+     * Read one symbol.
+     *
+     * @param {BasisBitReader} reader
+     * @returns {number} the symbol
+     * @throws {Error} for a prefix that matches no code in the table
+     */
+    decode(reader) {
+        const packed = this.#fast[reader.peek(FAST_LOOKUP_BITS)];
+
+        if (packed !== 0) {
+            reader.consume(packed & ((1 << FAST_LENGTH_BITS) - 1));
+
+            return packed >>> FAST_LENGTH_BITS;
+        }
+
+        /*
+         Either a code longer than the fast lookup covers, or one that is not in the table at all.
+         Rebuild it a bit at a time, most significant first, which is the order canonical codes
+         compare in.
+        */
+        let code = 0;
+
+        for (let length = 1; length <= HUFFMAN_MAX_CODE_SIZE; length++) {
+            code = (code << 1) | ((reader.peek(length) >>> (length - 1)) & 1);
+
+            const count = this.#length_count[length];
+
+            if (count !== 0) {
+                const offset = code - this.#first_code[length];
+
+                if (offset >= 0 && offset < count) {
+                    reader.consume(length);
+
+                    return this.#sorted_symbols[this.#first_index[length] + offset];
+                }
+            }
+        }
+
+        throw new Error(
+            `Basis: a ${HUFFMAN_MAX_CODE_SIZE} bit prefix matched no code in the Huffman table,`
+            + ` which means the bitstream and the table disagree`
+        );
+    }
+}

package/src/format/texture/basis/astc_block.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Decode one channel the way the format does.
+ *
+ * **This is not `c0 + (c1 - c0) * w / 64`.** ASTC widens each 8-bit endpoint to sixteen bits by bit
+ * replication first, interpolates there with a rounding `+32`, and takes the top eight bits of the
+ * result — which disagrees with the direct form on about one texel in twenty, always by a level.
+ * Fitting endpoints against the direct form and letting hardware decode with this one puts that
+ * disagreement into the output for nothing, so every encoder here scores against this.
+ *
+ * @param {number} c0 eight bits
+ * @param {number} c1 eight bits
+ * @param {number} weight unquantized, `0..64`
+ * @returns {number} eight bits
+ */
+export function astc_interpolate(c0: number, c1: number, weight: number): number;
+/**
+ * Put the endpoints the way round colour endpoint mode 8 requires, inverting the weights to match.
+ *
+ * **The rule that makes a wrong-way-round block decode as the wrong colours rather than as a
+ * mirror.** Mode 8 compares the endpoints by the sum of their channels: with `s1 >= s0` they are
+ * taken as written, and otherwise the decoder *swaps* them and applies blue contraction —
+ * `r = (r + b) >> 1`, `g = (g + b) >> 1` — to both. That second path is a different picture, not an
+ * inverted one, and no bit in the block records that it happened.
+ *
+ * A least-squares fit puts the first endpoint at the darker end, so this is nearly always already
+ * satisfied; nearly is not a guarantee once rounding and clamping have run, and a block that trips
+ * it is not one any test would think to construct. Swapping the pair and inverting the weights
+ * leaves the decoded block identical, so it costs nothing where it does nothing.
+ *
+ * @param {Int32Array} endpoints six values, `R0 R1 G0 G1 B0 B1`, modified in place
+ * @param {Uint8Array} weights sixteen weight *levels* (not unquantized), modified in place
+ * @param {number} top the highest weight level, so the inversion knows its own range
+ */
+export function astc_order_endpoints(endpoints: Int32Array, weights: Uint8Array, top: number): void;
+/**
+ * Write one single-partition, mode-8 ASTC block: header and endpoints from the bottom, weights from
+ * the top.
+ *
+ * @param {Uint8Array} out
+ * @param {number} offset
+ * @param {Int32Array} endpoints six values, `R0 R1 G0 G1 B0 B1`
+ * @param {Uint8Array} weights sixteen weight levels, in raster order
+ * @param {number} weight_bits 2 or 3
+ */
+export function astc_write_block(out: Uint8Array, offset: number, endpoints: Int32Array, weights: Uint8Array, weight_bits: number): void;
+/**
+ * Bytes in one ASTC 4x4 block.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const ASTC_BLOCK_BYTES: number;
+/**
+ * Colour endpoint mode 8: LDR RGB, direct. Six endpoint values, `R0 R1 G0 G1 B0 B1`.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const CEM_LDR_RGB_DIRECT: number;
+/**
+ * The two single-plane 4x4 block modes this tree writes, by how many bits a weight takes.
+ *
+ * **Read out of the specification's block-mode layout, and confirmed against the reference.** The
+ * low-precision row packs `D` at bit 10, `H` at 9, the height term `B` at 8:7, the width term `A` at
+ * 6:5, `R0` at 4, two zero bits, then `R2` and `R1` at 1:0 — with the grid `A+2` wide by `B+4` high
+ * and the weight range read from `R = R2·4 + R1·2 + R0`. So `A = 2`, `B = 0`, `D = H = 0` is a 4x4
+ * grid on one plane, and `R` picks the range: 4 gives four levels and 7 gives eight.
+ *
+ * Both appear in `basisu`'s own output for these files, which is what turns a derivation into a
+ * check.
+ *
+ * @readonly
+ * @type {Object<number, number>}
+ */
+export const ASTC_BLOCK_MODE: {
+    [x: number]: number;
+};
+/**
+ * What a weight unquantizes to, out of 64, for each weight-bit count this writes.
+ *
+ * **Not evenly spaced, and not a rounding of `v / levels`.** A pure-bit weight is replicated up to
+ * six bits and then nudged: `if (T > 32) T += 1`, which is what turns the top of the range into
+ * exactly 64 rather than 63. Two bits gives `0, 21, 43, 64` and three gives `0, 9, 18, 27, 37, 46,
+ * 55, 64` — note 36 becoming 37, which a thirds-and-sevenths formula does not produce.
+ *
+ * @readonly
+ * @type {Object<number, number[]>}
+ */
+export const ASTC_WEIGHT_UNQUANTIZED: {
+    [x: number]: number[];
+};
+//# sourceMappingURL=astc_block.d.ts.map

package/src/format/texture/basis/astc_block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astc_block.d.ts","sourceRoot":"","sources":["../../../../../src/format/texture/basis/astc_block.js"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;GAaG;AACH,qCALW,MAAM,MACN,MAAM,UACN,MAAM,GACJ,MAAM,CAOlB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,gDAJW,UAAU,WACV,UAAU,OACV,MAAM,QAoBhB;AAED;;;;;;;;;GASG;AACH,sCANW,UAAU,UACV,MAAM,aACN,UAAU,WACV,UAAU,eACV,MAAM,QAoChB;AAnKD;;;;;GAKG;AACH,+BAFU,MAAM,CAEmB;AAEnC;;;;;GAKG;AACH,iCAFU,MAAM,CAEoB;AAUpC;;;;;;;;;;;;;;GAcG;AACH;QAFiB,MAAM,GAAE,MAAM;EAK7B;AAEF;;;;;;;;;;GAUG;AACH;QAFiB,MAAM,GAAE,MAAM,EAAE;EAK/B"}