@woosh/meep-engine 3.14.2 → 3.14.3

package/src/format/texture/basis/uastc/uastc_decode_block.js

@@ -0,0 +1,480 @@
+import {
+    UASTC_ANCHORS_2,
+    UASTC_ANCHORS_2_BC7_3,
+    UASTC_ANCHORS_3,
+    UASTC_DEQUANT,
+    UASTC_MODE_BY_INDEX,
+    UASTC_MODE_OF_PREFIX,
+    UASTC_MODE_RESERVED,
+    UASTC_MODE_SOLID,
+    UASTC_PATTERNS_2,
+    UASTC_PATTERNS_2_BC7_3,
+    UASTC_PATTERNS_3,
+    UASTC_WEIGHT_VALUE,
+} from "./uastc_tables.js";
+
+/**
+ * Bytes one UASTC block occupies.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const UASTC_BLOCK_BYTES = 16;
+
+/**
+ * Texels one block covers.
+ *
+ * @readonly
+ * @type {number}
+ */
+const TEXELS = 16;
+
+/**
+ * The mode that uses the 2-subset patterns which are 3-subset in BC7. Its subset count says two and
+ * its pattern table is not the ordinary two-subset one, which is the only thing that separates it
+ * from mode 4.
+ *
+ * @readonly
+ * @type {number}
+ */
+const MODE_BC7_3_SUBSET_PATTERNS = 7;
+
+/**
+ * Read `count` bits from a block, least significant first, starting `offset` bits into it.
+ *
+ * The specification prints every field as "name: bit_offset num_bits", so reading one is this call
+ * with those two numbers — which is why this is random access rather than a cursor. A cursor would
+ * mean tracking a position through fields the decoder skips, and the offsets are already known.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} base byte offset of the block
+ * @param {number} offset bits into the block
+ * @param {number} count at most 24
+ * @returns {number}
+ */
+function read_bits(bytes, base, offset, count) {
+    let value = 0;
+
+    for (let i = 0; i < count; i++) {
+        const bit = offset + i;
+
+        value |= ((bytes[base + (bit >> 3)] >> (bit & 7)) & 1) << i;
+    }
+
+    return value;
+}
+
+/**
+ * How many colour components a Colour Endpoint Mode describes.
+ *
+ * @param {number} cem 4 luminance-alpha, 8 RGB, 12 RGBA — all "direct"
+ * @returns {number}
+ */
+function components_of(cem) {
+    return cem === 4 ? 2 : cem === 8 ? 3 : 4;
+}
+
+/**
+ * ASTC's endpoint interpolation, which UASTC uses unchanged.
+ *
+ * The eight-bit endpoints are widened to sixteen by replication before interpolating and the result
+ * narrowed back, which is not the same as interpolating at eight bits — the extra precision is why
+ * the specification calls the BC7 mapping lossy while the ASTC one is exact.
+ *
+ * @param {number} low eight bits
+ * @param {number} high eight bits
+ * @param {number} weight `[0, 64]`
+ * @returns {number} eight bits
+ */
+function interpolate(low, high, weight) {
+    const l = (low << 8) | low;
+    const h = (high << 8) | high;
+
+    return ((l * (64 - weight) + h * weight + 32) >> 6) >> 8;
+}
+
+/**
+ * Dequantise one encoded endpoint integer to eight bits.
+ *
+ * @param {UastcEndpointRange|undefined} range `undefined` for a plain bit range
+ * @param {number} bits width of a plain bit range
+ * @param {number} encoded
+ * @returns {number}
+ */
+function dequantise(range, bits, encoded) {
+    if (range !== undefined) {
+        return range.value[encoded];
+    }
+
+    /*
+     A plain bit range dequantises by replicating the value's top bits downward until eight are
+     filled — the same rule that takes a five-bit channel to eight everywhere else in this tree.
+    */
+    let value = encoded;
+    let filled = bits;
+
+    while (filled < 8) {
+        value = (value << bits) | encoded;
+        filled += bits;
+    }
+
+    return (value >> (filled - 8)) & 255;
+}
+
+/**
+ * The partition pattern table a mode draws on, and the anchor table beside it.
+ *
+ * @param {UastcMode} mode
+ * @returns {{patterns: Uint8Array, anchors: Uint8Array, anchor_stride: number}}
+ */
+function pattern_tables(mode) {
+    if (mode.subsets === 3) {
+        return { patterns: UASTC_PATTERNS_3, anchors: UASTC_ANCHORS_3, anchor_stride: 3 };
+    }
+
+    if (mode.mode === MODE_BC7_3_SUBSET_PATTERNS) {
+        return {
+            patterns: UASTC_PATTERNS_2_BC7_3,
+            anchors: UASTC_ANCHORS_2_BC7_3,
+            anchor_stride: 2,
+        };
+    }
+
+    return { patterns: UASTC_PATTERNS_2, anchors: UASTC_ANCHORS_2, anchor_stride: 2 };
+}
+
+/**
+ * One decoded UASTC block, in the terms the format states it rather than as texels.
+ *
+ * Kept in this form because a transcoder wants it: the partition and the per-subset endpoints are
+ * what map onto BC7's and ASTC's own, and going through RGBA would throw away the structure that
+ * makes those mappings cheap and nearly lossless.
+ *
+ * @typedef {object} UastcBlock
+ * @property {number} mode
+ * @property {number} subsets
+ * @property {boolean} has_alpha whether the source carried an alpha channel, as opposed to the
+ * opaque one an RGB colour endpoint mode implies
+ * @property {number} pattern index into the mode's partition pattern table, `0` for one subset
+ * @property {Uint8Array} partition one subset index per texel, all zero for a single subset
+ * @property {Uint8Array} endpoints `subsets * 2 * 4` bytes: low then high RGBA, per subset
+ * @property {Uint8Array} weights one `[0, 64]` interpolant per texel per plane, plane 0 first
+ * @property {Uint8Array} weight_indices the same, before unquantisation — what a transcoder maps to
+ * its own index space, since going via the interpolant would round twice
+ * @property {number} weight_range index into `UASTC_WEIGHT_VALUE`
+ * @property {boolean} dual_plane
+ * @property {number} component_selector which channel reads plane 1, when `dual_plane`
+ */
+
+/**
+ * Decode one UASTC LDR 4x4 block.
+ *
+ * **The whole of the format's complexity is here**, and it is why UASTC is a second bitstream rather
+ * than a variation on ETC1S: nineteen modes differing in subset count, endpoint precision, weight
+ * precision and whether one channel is interpolated separately, with the endpoints trit- or
+ * quint-coded in most modes and the weights packed a bit short at each subset's anchor texel.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} base byte offset of the block
+ * @returns {UastcBlock}
+ * @throws {Error} for the reserved mode, which no encoder emits
+ *
+ * @see the UASTC LDR 4x4 specification
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function uastc_decode_block(bytes, base) {
+    const mode_index = UASTC_MODE_OF_PREFIX[bytes[base] & 0x7F];
+
+    if (mode_index === UASTC_MODE_RESERVED) {
+        throw new Error(
+            `UASTC: block mode ${UASTC_MODE_RESERVED} is reserved by the specification for a future`
+            + ` revision, and nothing defines what its bits mean`
+        );
+    }
+
+    if (mode_index === UASTC_MODE_SOLID) {
+        return solid_block(bytes, base);
+    }
+
+    const mode = UASTC_MODE_BY_INDEX[mode_index];
+
+    const { patterns, anchors, anchor_stride } = mode.subsets > 1
+        ? pattern_tables(mode)
+        : { patterns: undefined, anchors: undefined, anchor_stride: 0 };
+
+    const pattern_index = mode.subsets > 1
+        ? read_bits(bytes, base, mode.pat_offset, mode.pat_bits)
+        : 0;
+
+    const partition = new Uint8Array(TEXELS);
+
+    if (mode.subsets > 1) {
+        partition.set(patterns.subarray(pattern_index * TEXELS, (pattern_index + 1) * TEXELS));
+    }
+
+    /*
+     The quantised values as well as the dequantised ones. A transcoder that re-encodes needs the
+     colours; one that repacks into ASTC needs the numbers the file actually stored, because they are
+     already in ASTC's quantised space and requantising them would lose what the format went to the
+     trouble of preserving.
+    */
+    const endpoints_quantised = [];
+
+    const endpoints = read_endpoints(bytes, base, mode, endpoints_quantised);
+
+    const { weights, indices } = read_weights(
+        bytes, base, mode, partition, anchors, anchor_stride, pattern_index
+    );
+
+    return {
+        mode: mode_index,
+        endpoints_quantised,
+        subsets: mode.subsets,
+        pattern: pattern_index,
+        has_alpha: mode.cem !== 8,
+        partition,
+        endpoints,
+        weights,
+        weight_indices: indices,
+        weight_range: mode.weight_range,
+        dual_plane: mode.dual_plane,
+        component_selector: mode.dual_plane
+            ? (mode.comp_offset < 0 ? 3 : read_bits(bytes, base, mode.comp_offset, 2))
+            : 0,
+    };
+}
+
+/**
+ * Mode 8: one colour over the whole block, stored outright.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} base
+ * @returns {UastcBlock}
+ */
+function solid_block(bytes, base) {
+    const endpoints = new Uint8Array(8);
+
+    for (let c = 0; c < 4; c++) {
+        const value = read_bits(bytes, base, 5 + c * 8, 8);
+
+        endpoints[c] = value;
+        endpoints[4 + c] = value;
+    }
+
+    return {
+        mode: UASTC_MODE_SOLID,
+        subsets: 1,
+        pattern: 0,
+        has_alpha: true,
+        partition: new Uint8Array(TEXELS),
+        endpoints,
+        // both endpoints are the colour, so every weight gives it back
+        weights: new Uint8Array(TEXELS),
+        weight_indices: new Uint8Array(TEXELS),
+        weight_range: 0,
+        dual_plane: false,
+        component_selector: 0,
+    };
+}
+
+/**
+ * Read and dequantise a block's endpoints into `subsets * 2 * 4` RGBA bytes.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} base
+ * @param {UastcMode} mode
+ * @returns {Uint8Array}
+ */
+function read_endpoints(bytes, base, mode, quantised_out) {
+    const range = UASTC_DEQUANT[mode.endpoint_range];
+
+    const component_count = components_of(mode.cem);
+    const value_count = component_count * 2 * mode.subsets;
+
+    /*
+     The trits or quints come first, all of them, and the values' bit portions follow — which is
+     UASTC's simplification of ASTC's interleaving, and the reason a decoder can read them with two
+     plain loops instead of ASTC's bit-shuffling procedure.
+    */
+    const extra = new Uint8Array(value_count);
+
+    let offset = mode.value_offset;
+
+    if (range !== undefined && (range.trits === 1 || range.quints === 1)) {
+        const per_group = range.trits === 1 ? 5 : 3;
+        const radix = range.trits === 1 ? 3 : 5;
+
+        let value_index = 0;
+
+        for (const group_bits of mode.etq_bits) {
+            let packed = read_bits(bytes, base, offset, group_bits);
+
+            offset += group_bits;
+
+            // the group is the digits of one integer in base three or base five, least significant
+            // digit first
+            for (let i = 0; i < per_group && value_index < value_count; i++) {
+                extra[value_index++] = packed % radix;
+                packed = (packed / radix) | 0;
+            }
+        }
+    }
+
+    const bits = range !== undefined ? range.bits : mode.endpoint_bits[0];
+
+    const endpoints = new Uint8Array(mode.subsets * 2 * 4);
+
+    for (let i = 0; i < value_count; i++) {
+        const width = mode.endpoint_bits[i];
+
+        const raw = read_bits(bytes, base, offset, width);
+
+        offset += width;
+
+        const encoded = range !== undefined ? ((extra[i] << bits) | raw) : raw;
+
+        if (quantised_out !== undefined) {
+            quantised_out.push(encoded);
+        }
+
+        const value = dequantise(range, width, encoded);
+
+        place_endpoint(endpoints, mode.cem, component_count, i, value);
+    }
+
+    return endpoints;
+}
+
+/**
+ * Write one decoded endpoint value into its RGBA slot.
+ *
+ * The format's ordering is ASTC's — low then high, per component, per subset — and the two modes
+ * that are not RGBA have to be widened into one: an RGB mode's alpha is opaque, and a
+ * luminance-alpha mode's luminance goes to all three colour channels.
+ *
+ * @param {Uint8Array} endpoints
+ * @param {number} cem
+ * @param {number} component_count
+ * @param {number} index into the format's value ordering
+ * @param {number} value eight bits
+ */
+function place_endpoint(endpoints, cem, component_count, index, value) {
+    const subset = (index / (component_count * 2)) | 0;
+    const within = index % (component_count * 2);
+    const component = (within / 2) | 0;
+    const half = within % 2;
+
+    const slot = (subset * 2 + half) * 4;
+
+    if (cem === 4) {
+        // luminance then alpha: LL LH AL AH
+        if (component === 0) {
+            endpoints[slot] = value;
+            endpoints[slot + 1] = value;
+            endpoints[slot + 2] = value;
+        } else {
+            endpoints[slot + 3] = value;
+        }
+
+        return;
+    }
+
+    endpoints[slot + component] = value;
+
+    if (cem === 8) {
+        endpoints[slot + 3] = 255;
+    }
+}
+
+/**
+ * Read a block's weights, unquantised to `[0, 64]`.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} base
+ * @param {UastcMode} mode
+ * @param {Uint8Array} partition
+ * @param {Uint8Array|undefined} anchors
+ * @param {number} anchor_stride
+ * @param {number} pattern_index
+ * @returns {Uint8Array} one entry per texel per plane, plane 0 first
+ */
+function read_weights(bytes, base, mode, partition, anchors, anchor_stride, pattern_index) {
+    const table = UASTC_WEIGHT_VALUE[mode.weight_range];
+
+    const width = Math.log2(table.length);
+
+    const planes = mode.dual_plane ? 2 : 1;
+
+    /*
+     One texel per subset has its weight stored a bit short, because the block is written so that
+     weight's top bit is zero — the same trick BC7 plays, and what lets some of these modes fit in
+     128 bits at all. For a single subset that texel is the first; otherwise the anchor table says
+     which, and in a dual plane mode both of the first texel's planes are short.
+    */
+    const short_at = new Uint8Array(TEXELS * planes);
+
+    if (mode.subsets === 1) {
+        for (let plane = 0; plane < planes; plane++) {
+            short_at[plane] = 1;
+        }
+    } else {
+        for (let subset = 0; subset < mode.subsets; subset++) {
+            short_at[anchors[pattern_index * anchor_stride + subset] * planes] = 1;
+        }
+    }
+
+    const weights = new Uint8Array(TEXELS * planes);
+    const indices = new Uint8Array(TEXELS * planes);
+
+    let offset = mode.weights_offset;
+
+    for (let i = 0; i < TEXELS * planes; i++) {
+        const count = width - short_at[i];
+
+        const index = read_bits(bytes, base, offset, count);
+
+        indices[i] = index;
+        weights[i] = table[index];
+
+        offset += count;
+    }
+
+    return { weights, indices };
+}
+
+/**
+ * Turn a decoded block into its sixteen RGBA texels.
+ *
+ * @param {UastcBlock} block
+ * @param {Uint8Array} out at least 64 bytes
+ * @param {number} [out_offset]
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function uastc_block_texels(block, out, out_offset = 0) {
+    const planes = block.dual_plane ? 2 : 1;
+
+    for (let texel = 0; texel < TEXELS; texel++) {
+        const subset = block.partition[texel];
+
+        const low = subset * 8;
+        const high = low + 4;
+
+        for (let c = 0; c < 4; c++) {
+            /*
+             In a dual plane block one channel is interpolated with its own weight. Which channel is
+             the component selector's, and it is the ASTC field rather than BC7's rotation — the
+             components are not reordered here.
+            */
+            const plane = (block.dual_plane && c === block.component_selector) ? 1 : 0;
+
+            const weight = block.weights[texel * planes + plane];
+
+            out[out_offset + texel * 4 + c] = interpolate(
+                block.endpoints[low + c], block.endpoints[high + c], weight
+            );
+        }
+    }
+}

package/src/format/texture/basis/uastc/uastc_tables.d.ts

@@ -0,0 +1,240 @@
+/**
+ * The constant tables UASTC decoding runs on, transcribed from the specification.
+ *
+ * **Data, not logic.** Every table here appears verbatim in the UASTC LDR 4x4 specification, which
+ * is where a reviewer should check them against; nothing was derived, condensed or re-ordered, and
+ * the one thing that was computed — the per-mode field offsets — is checked against the offsets the
+ * specification prints for each mode by `uastc_tables.spec.js`.
+ *
+ * They are in their own module because they are long and because that check wants to import them
+ * without dragging a decoder along.
+ *
+ * @see https://github.com/BinomialLLC/basis_universal/wiki/UASTC-LDR-4x4-Texture-Specification
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Mode index for each of the 128 values the low seven bits of a block's first byte can take.
+ *
+ * The mode is a Huffman code of two to seven bits, and seven bits is enough to resolve every one of
+ * them — which is why the specification publishes this table rather than a decoding procedure.
+ *
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_MODE_OF_PREFIX: Uint8Array;
+/**
+ * How many bits each mode's Huffman code occupies, indexed by mode.
+ *
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_MODE_CODE_BITS: Uint8Array;
+/**
+ * Mode 8 is a solid colour over the whole block, and carries none of the fields the others do.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const UASTC_MODE_SOLID: number;
+/**
+ * Mode 19 is reserved by the specification for a future revision and no encoder emits it.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const UASTC_MODE_RESERVED: number;
+/**
+ * One mode's layout.
+ *
+ * `cem` is ASTC's Colour Endpoint Mode: 4 is luminance-alpha, 8 is RGB, 12 is RGBA, all "direct".
+ * The offsets are bit positions from the start of the block, exactly as the specification prints
+ * them; `value_offset` is where the packed trits and quints begin, or the endpoint bits when a mode
+ * has none.
+ *
+ * @typedef {object} UastcMode
+ * @property {number} mode
+ * @property {number} cem
+ * @property {number} subsets
+ * @property {boolean} dual_plane
+ * @property {number} weight_range index into {@link UASTC_WEIGHT_LEVELS}
+ * @property {number} endpoint_range index into {@link UASTC_DEQUANT}
+ * @property {number} pat_offset bit offset of the partition pattern index, `-1` for one subset
+ * @property {number} pat_bits
+ * @property {number} comp_offset bit offset of the component selector, `-1` when not dual plane
+ * @property {number} value_offset
+ * @property {number} weights_offset
+ * @property {number[]} etq_bits width of each packed trit or quint group
+ * @property {number[]} endpoint_bits width of each endpoint's bit portion
+ */
+/**
+ * Every mode but 8 and 19, in the order the specification lists them.
+ *
+ * @readonly
+ * @type {UastcMode[]}
+ */
+export const UASTC_MODES: UastcMode[];
+/**
+ * {@link UASTC_MODES} indexed by mode number, so a decoded mode is a lookup rather than a search.
+ * The solid and reserved modes are `undefined`.
+ *
+ * @readonly
+ * @type {(UastcMode|undefined)[]}
+ */
+export const UASTC_MODE_BY_INDEX: (UastcMode | undefined)[];
+/**
+ * How many levels each weight range holds. UASTC weights never use trits or quints, so a range is
+ * just a bit width and these are all powers of two.
+ *
+ * @readonly
+ * @type {Object<number, number>}
+ */
+export const UASTC_WEIGHT_LEVELS: {
+    [x: number]: number;
+};
+/**
+ * ASTC's weight unquantisation, from a range's encoded weight to the `[0, 64]` interpolant.
+ *
+ * Keyed by range index, matching {@link UastcMode.weight_range}. The two- and three-bit rows are
+ * identical to BC7's weight tables, which is what makes those weights copyable rather than remapped
+ * when transcoding.
+ *
+ * @readonly
+ * @type {Object<number, Uint8Array>}
+ */
+export const UASTC_WEIGHT_VALUE: {
+    [x: number]: Uint8Array;
+};
+/**
+ * One endpoint range's encoding and its dequantisation to eight bits.
+ *
+ * **The values are not monotonic in the encoded integer**, which is the thing about ASTC's
+ * trit and quint ranges that surprises everyone: encoded 1 in range 4 dequantises to 255, not to 51.
+ * The order is the specification's, and the table is used exactly as printed.
+ *
+ * @typedef {object} UastcEndpointRange
+ * @property {number} bits bits stored per value, beside its trit or quint
+ * @property {number} trits one when the range is trit-coded
+ * @property {number} quints one when the range is quint-coded
+ * @property {Uint8Array} value dequantised eight-bit value, indexed by the encoded integer
+ */
+/**
+ * Every endpoint range UASTC uses that is trit- or quint-coded.
+ *
+ * A range not listed here is a plain bit range: its values dequantise by replicating the top bit
+ * downward, which needs no table.
+ *
+ * @readonly
+ * @type {Object<number, UastcEndpointRange>}
+ */
+export const UASTC_DEQUANT: {
+    [x: number]: UastcEndpointRange;
+};
+/**
+ * The 2-subset partition patterns, as a subset index per texel in raster order.
+ *
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_PATTERNS_2: Uint8Array;
+/**
+ * The 3-subset partition patterns.
+ *
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_PATTERNS_3: Uint8Array;
+/**
+ * The patterns that are 2-subset in ASTC and 3-subset in BC7, used by mode 7 alone.
+ *
+ * Two subsets as far as a decoder is concerned; the third exists only so the pattern has a BC7
+ * counterpart to be transcoded into.
+ *
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_PATTERNS_2_BC7_3: Uint8Array;
+/**
+ * For each 2-subset pattern, the texel whose weight is stored a bit short in each subset.
+ *
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_ANCHORS_2: Uint8Array;
+/**
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_ANCHORS_3: Uint8Array;
+/**
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_ANCHORS_2_BC7_3: Uint8Array;
+/**
+ * One mode's layout.
+ *
+ * `cem` is ASTC's Colour Endpoint Mode: 4 is luminance-alpha, 8 is RGB, 12 is RGBA, all "direct".
+ * The offsets are bit positions from the start of the block, exactly as the specification prints
+ * them; `value_offset` is where the packed trits and quints begin, or the endpoint bits when a mode
+ * has none.
+ */
+export type UastcMode = {
+    mode: number;
+    cem: number;
+    subsets: number;
+    dual_plane: boolean;
+    /**
+     * index into {@link UASTC_WEIGHT_LEVELS }
+     */
+    weight_range: number;
+    /**
+     * index into {@link UASTC_DEQUANT }
+     */
+    endpoint_range: number;
+    /**
+     * bit offset of the partition pattern index, `-1` for one subset
+     */
+    pat_offset: number;
+    pat_bits: number;
+    /**
+     * bit offset of the component selector, `-1` when not dual plane
+     */
+    comp_offset: number;
+    value_offset: number;
+    weights_offset: number;
+    /**
+     * width of each packed trit or quint group
+     */
+    etq_bits: number[];
+    /**
+     * width of each endpoint's bit portion
+     */
+    endpoint_bits: number[];
+};
+/**
+ * One endpoint range's encoding and its dequantisation to eight bits.
+ *
+ * **The values are not monotonic in the encoded integer**, which is the thing about ASTC's
+ * trit and quint ranges that surprises everyone: encoded 1 in range 4 dequantises to 255, not to 51.
+ * The order is the specification's, and the table is used exactly as printed.
+ */
+export type UastcEndpointRange = {
+    /**
+     * bits stored per value, beside its trit or quint
+     */
+    bits: number;
+    /**
+     * one when the range is trit-coded
+     */
+    trits: number;
+    /**
+     * one when the range is quint-coded
+     */
+    quints: number;
+    /**
+     * dequantised eight-bit value, indexed by the encoded integer
+     */
+    value: Uint8Array;
+};
+//# sourceMappingURL=uastc_tables.d.ts.map