@woosh/meep-engine 3.14.2 → 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.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/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"}

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

@@ -0,0 +1,164 @@
+/**
+ * Bytes in one ASTC 4x4 block.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const ASTC_BLOCK_BYTES = 16;
+
+/**
+ * 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 = 8;
+
+/**
+ * Where the endpoint values begin: eleven bits of block mode, two of partition count, four of CEM.
+ *
+ * @readonly
+ * @type {number}
+ */
+const ENDPOINT_BIT = 17;
+
+/**
+ * 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 = {
+    2: 0x42,
+    3: 0x53,
+};
+
+/**
+ * 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 = {
+    2: [0, 21, 43, 64],
+    3: [0, 9, 18, 27, 37, 46, 55, 64],
+};
+
+/**
+ * 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, c1, weight) {
+    const wide0 = (c0 << 8) | c0;
+    const wide1 = (c1 << 8) | c1;
+
+    return Math.floor((wide0 * (64 - weight) + wide1 * weight + 32) / 64) >> 8;
+}
+
+/**
+ * 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, weights, top) {
+    const first = endpoints[0] + endpoints[2] + endpoints[4];
+    const second = endpoints[1] + endpoints[3] + endpoints[5];
+
+    if (second >= first) {
+        return;
+    }
+
+    for (let channel = 0; channel < 3; channel++) {
+        const swap = endpoints[channel * 2];
+
+        endpoints[channel * 2] = endpoints[channel * 2 + 1];
+        endpoints[channel * 2 + 1] = swap;
+    }
+
+    for (let texel = 0; texel < 16; texel++) {
+        weights[texel] = top - weights[texel];
+    }
+}
+
+/**
+ * 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, offset, endpoints, weights, weight_bits) {
+    let block = BigInt(ASTC_BLOCK_MODE[weight_bits]);
+
+    // partition count - 1, at bits 11..12, is zero: one partition
+
+    block |= BigInt(CEM_LDR_RGB_DIRECT) << 13n;
+
+    for (let i = 0; i < 6; i++) {
+        block |= BigInt(endpoints[i]) << BigInt(ENDPOINT_BIT + i * 8);
+    }
+
+    /*
+     The weights fill the top of the block with the whole field's bit order reversed — the first
+     texel's weight ends up in the block's most significant bits. Building the field the natural way
+     round and mirroring it once is easier to read than writing each weight to a computed bit, and is
+     the same thing.
+    */
+    let field = 0n;
+
+    for (let texel = 0; texel < 16; texel++) {
+        field |= BigInt(weights[texel]) << BigInt(texel * weight_bits);
+    }
+
+    const width = 16 * weight_bits;
+
+    for (let i = 0; i < width; i++) {
+        if ((field >> BigInt(i)) & 1n) {
+            block |= 1n << BigInt(127 - i);
+        }
+    }
+
+    for (let i = 0; i < ASTC_BLOCK_BYTES; i++) {
+        out[offset + i] = Number((block >> BigInt(i * 8)) & 0xFFn);
+    }
+}

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

@@ -0,0 +1,59 @@
+/**
+ * The five trits packed into one eight-bit group, as the specification's decode produces them.
+ *
+ * **Written as the decoder and inverted, rather than as an encoder.** The specification gives this
+ * direction only — it says outright that encoding is left to the implementation and that a table
+ * works well — so the honest way to get the table is to run the normative procedure over all 256
+ * inputs and read it backwards. A hand-written encoder would be a second reading of the same rules
+ * with nothing to check it against; this one cannot disagree with the decoder because it *is* the
+ * decoder.
+ *
+ * @param {number} packed eight bits
+ * @returns {number[]} five trits
+ */
+export function astc_unpack_trits(packed: number): number[];
+/**
+ * The three quints packed into one seven-bit group.
+ *
+ * @param {number} packed seven bits
+ * @returns {number[]} three quints
+ * @see astc_unpack_trits for why this is the decode rather than an encode
+ */
+export function astc_unpack_quints(packed: number): number[];
+/**
+ * Write a sequence of quantized values into an ASTC block as an integer sequence.
+ *
+ * **The interleaving is the whole of it.** A trit-based sequence goes five values at a time: the
+ * eight bits that carry their trits are cut into pieces and threaded *between* the values' plain
+ * bits, so the group occupies `5 * bits + 8` bits with nothing contiguous. Quints do the same three
+ * at a time over seven bits. A pure-bit range is the easy case and just runs.
+ *
+ * The piece boundaries below — two bits, then two, then one, then two, then one — are the
+ * specification's, and they are what a reader expects to find where. Getting them wrong produces a
+ * block whose every endpoint is somebody else's.
+ *
+ * @param {(value: number, width: number) => void} write appends `width` bits, least significant first
+ * @param {number[]|Uint8Array} values quantized, each below the range's level count
+ * @param {number} range_index into {@link ASTC_RANGE}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function astc_write_integer_sequence(write: (value: number, width: number) => void, values: number[] | Uint8Array, range_index: number): void;
+/**
+ * ASTC's quantization ranges, by the index a block mode or endpoint field names.
+ *
+ * Each is some number of plain bits, optionally multiplied by a trit (three values) or a quint
+ * (five) — which is how the format reaches level counts that are not powers of two without wasting
+ * the fraction of a bit a naive packing would.
+ *
+ * @readonly
+ * @type {{levels: number, bits: number, trits: number, quints: number}[]}
+ */
+export const ASTC_RANGE: {
+    levels: number;
+    bits: number;
+    trits: number;
+    quints: number;
+}[];
+//# sourceMappingURL=astc_integer_sequence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"astc_integer_sequence.d.ts","sourceRoot":"","sources":["../../../../../src/format/texture/basis/astc_integer_sequence.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;GAYG;AACH,0CAHW,MAAM,GACJ,MAAM,EAAE,CAgDpB;AAED;;;;;;GAMG;AACH,2CAJW,MAAM,GACJ,MAAM,EAAE,CAiCpB;AA0CD;;;;;;;;;;;;;;;;;;GAkBG;AACH,2DAPmB,MAAM,SAAS,MAAM,KAAK,IAAI,UACtC,MAAM,EAAE,GAAC,UAAU,eACnB,MAAM,QAiDhB;AA7OD;;;;;;;;;GASG;AACH,yBAFU;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,EAAE,CAwBvE"}