@woosh/meep-engine 3.14.2 → 3.14.3

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

@@ -0,0 +1 @@
+{"version":3,"file":"uastc_tables.d.ts","sourceRoot":"","sources":["../../../../../../src/format/texture/basis/uastc/uastc_tables.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;GAQG;AACH,mCAFU,UAAU,CAQjB;AAEH;;;;;GAKG;AACH,mCAFU,UAAU,CAE6F;AAEjH;;;;;GAKG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;GAKG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;GAKG;AACH,0BAFU,SAAS,EAAE,CAyDnB;AAEF;;;;;;GAMG;AACH,kCAFU,CAAC,SAAS,GAAC,SAAS,CAAC,EAAE,CAU5B;AAEL;;;;;;GAMG;AACH;QAFiB,MAAM,GAAE,MAAM;EAEwC;AAEvE;;;;;;;;;GASG;AACH;QAFiB,MAAM,GAAE,UAAU;EAWjC;AAEF;;;;;;;;;;;;GAYG;AAEH;;;;;;;;GAQG;AACH;QAFiB,MAAM,GAAE,kBAAkB;EAgFzC;AAEF;;;;;GAKG;AACH,+BAFU,UAAU,CAkBjB;AAEH;;;;;GAKG;AACH,+BAFU,UAAU,CASjB;AAEH;;;;;;;;GAQG;AACH,qCAFU,UAAU,CAajB;AAEH;;;;;GAKG;AACH,8BAFU,UAAU,CAKjB;AAEH;;;GAGG;AACH,8BAFU,UAAU,CAKjB;AAEH;;;GAGG;AACH,oCAFU,UAAU,CAKjB;;;;;;;;;;UA5TW,MAAM;SACN,MAAM;aACN,MAAM;gBACN,OAAO;;;;kBACP,MAAM;;;;oBACN,MAAM;;;;gBACN,MAAM;cACN,MAAM;;;;iBACN,MAAM;kBACN,MAAM;oBACN,MAAM;;;;cACN,MAAM,EAAE;;;;mBACR,MAAM,EAAE;;;;;;;;;;;;;UAyHR,MAAM;;;;WACN,MAAM;;;;YACN,MAAM;;;;WACN,UAAU"}

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

@@ -0,0 +1,383 @@
+/**
+ * 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 = new Uint8Array([
+    11, 0, 10, 3, 11, 15, 12, 7, 11, 18, 10, 5, 11, 14, 12, 9, 11, 0, 10, 4, 11, 16, 12, 8, 11, 18,
+    10, 6, 11, 2, 12, 13, 11, 0, 10, 3, 11, 17, 12, 7, 11, 18, 10, 5, 11, 14, 12, 9, 11, 0, 10, 4,
+    11, 1, 12, 8, 11, 18, 10, 6, 11, 2, 12, 13, 11, 0, 10, 3, 11, 19, 12, 7, 11, 18, 10, 5, 11, 14,
+    12, 9, 11, 0, 10, 4, 11, 16, 12, 8, 11, 18, 10, 6, 11, 2, 12, 13, 11, 0, 10, 3, 11, 17, 12, 7,
+    11, 18, 10, 5, 11, 14, 12, 9, 11, 0, 10, 4, 11, 1, 12, 8, 11, 18, 10, 6, 11, 2, 12, 13,
+]);
+
+/**
+ * How many bits each mode's Huffman code occupies, indexed by mode.
+ *
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_MODE_CODE_BITS = new Uint8Array([4, 6, 5, 5, 5, 5, 5, 5, 5, 5, 3, 2, 3, 5, 5, 7, 6, 6, 4, 7]);
+
+/**
+ * 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 = 8;
+
+/**
+ * Mode 19 is reserved by the specification for a future revision and no encoder emits it.
+ *
+ * @readonly
+ * @type {number}
+ */
+export const UASTC_MODE_RESERVED = 19;
+
+/**
+ * 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 = [
+    { mode: 0, cem: 8, subsets: 1, dual_plane: false, weight_range: 8, endpoint_range: 19,
+      pat_offset: -1, pat_bits: 0, comp_offset: -1, value_offset: 19, weights_offset: 65,
+      etq_bits: [8, 2], endpoint_bits: [6, 6, 6, 6, 6, 6] },
+    { mode: 1, cem: 8, subsets: 1, dual_plane: false, weight_range: 2, endpoint_range: 20,
+      pat_offset: -1, pat_bits: 0, comp_offset: -1, value_offset: 21, weights_offset: 69,
+      etq_bits: [], endpoint_bits: [8, 8, 8, 8, 8, 8] },
+    { mode: 2, cem: 8, subsets: 2, dual_plane: false, weight_range: 5, endpoint_range: 8,
+      pat_offset: 20, pat_bits: 5, comp_offset: -1, value_offset: 25, weights_offset: 73,
+      etq_bits: [], endpoint_bits: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4] },
+    { mode: 3, cem: 8, subsets: 3, dual_plane: false, weight_range: 2, endpoint_range: 7,
+      pat_offset: 20, pat_bits: 4, comp_offset: -1, value_offset: 24, weights_offset: 89,
+      etq_bits: [8, 8, 8, 5], endpoint_bits: [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2] },
+    { mode: 4, cem: 8, subsets: 2, dual_plane: false, weight_range: 2, endpoint_range: 12,
+      pat_offset: 20, pat_bits: 5, comp_offset: -1, value_offset: 25, weights_offset: 89,
+      etq_bits: [7, 7, 7, 7], endpoint_bits: [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3] },
+    { mode: 5, cem: 8, subsets: 1, dual_plane: false, weight_range: 5, endpoint_range: 20,
+      pat_offset: -1, pat_bits: 0, comp_offset: -1, value_offset: 20, weights_offset: 68,
+      etq_bits: [], endpoint_bits: [8, 8, 8, 8, 8, 8] },
+    { mode: 6, cem: 8, subsets: 1, dual_plane: true, weight_range: 2, endpoint_range: 18,
+      pat_offset: -1, pat_bits: 0, comp_offset: 20, value_offset: 22, weights_offset: 66,
+      etq_bits: [7, 7], endpoint_bits: [5, 5, 5, 5, 5, 5] },
+    { mode: 7, cem: 8, subsets: 2, dual_plane: false, weight_range: 2, endpoint_range: 12,
+      pat_offset: 20, pat_bits: 5, comp_offset: -1, value_offset: 25, weights_offset: 89,
+      etq_bits: [7, 7, 7, 7], endpoint_bits: [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3] },
+    { mode: 9, cem: 12, subsets: 2, dual_plane: false, weight_range: 2, endpoint_range: 8,
+      pat_offset: 28, pat_bits: 5, comp_offset: -1, value_offset: 33, weights_offset: 97,
+      etq_bits: [], endpoint_bits: [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4] },
+    { mode: 10, cem: 12, subsets: 1, dual_plane: false, weight_range: 8, endpoint_range: 13,
+      pat_offset: -1, pat_bits: 0, comp_offset: -1, value_offset: 20, weights_offset: 65,
+      etq_bits: [8, 5], endpoint_bits: [4, 4, 4, 4, 4, 4, 4, 4] },
+    { mode: 11, cem: 12, subsets: 1, dual_plane: true, weight_range: 2, endpoint_range: 13,
+      pat_offset: -1, pat_bits: 0, comp_offset: 19, value_offset: 21, weights_offset: 66,
+      etq_bits: [8, 5], endpoint_bits: [4, 4, 4, 4, 4, 4, 4, 4] },
+    { mode: 12, cem: 12, subsets: 1, dual_plane: false, weight_range: 5, endpoint_range: 19,
+      pat_offset: -1, pat_bits: 0, comp_offset: -1, value_offset: 20, weights_offset: 81,
+      etq_bits: [8, 5], endpoint_bits: [6, 6, 6, 6, 6, 6, 6, 6] },
+    { mode: 13, cem: 12, subsets: 1, dual_plane: true, weight_range: 0, endpoint_range: 20,
+      pat_offset: -1, pat_bits: 0, comp_offset: 28, value_offset: 30, weights_offset: 94,
+      etq_bits: [], endpoint_bits: [8, 8, 8, 8, 8, 8, 8, 8] },
+    { mode: 14, cem: 12, subsets: 1, dual_plane: false, weight_range: 2, endpoint_range: 20,
+      pat_offset: -1, pat_bits: 0, comp_offset: -1, value_offset: 28, weights_offset: 92,
+      etq_bits: [], endpoint_bits: [8, 8, 8, 8, 8, 8, 8, 8] },
+    { mode: 15, cem: 4, subsets: 1, dual_plane: false, weight_range: 8, endpoint_range: 20,
+      pat_offset: -1, pat_bits: 0, comp_offset: -1, value_offset: 30, weights_offset: 62,
+      etq_bits: [], endpoint_bits: [8, 8, 8, 8] },
+    { mode: 16, cem: 4, subsets: 2, dual_plane: false, weight_range: 2, endpoint_range: 20,
+      pat_offset: 29, pat_bits: 5, comp_offset: -1, value_offset: 34, weights_offset: 98,
+      etq_bits: [], endpoint_bits: [8, 8, 8, 8, 8, 8, 8, 8] },
+    { mode: 17, cem: 4, subsets: 1, dual_plane: true, weight_range: 2, endpoint_range: 20,
+      pat_offset: -1, pat_bits: 0, comp_offset: -1, value_offset: 29, weights_offset: 61,
+      etq_bits: [], endpoint_bits: [8, 8, 8, 8] },
+    { mode: 18, cem: 8, subsets: 1, dual_plane: false, weight_range: 11, endpoint_range: 11,
+      pat_offset: -1, pat_bits: 0, comp_offset: -1, value_offset: 19, weights_offset: 49,
+      etq_bits: [], endpoint_bits: [5, 5, 5, 5, 5, 5] },
+];
+
+/**
+ * {@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 = (() => {
+    const out = new Array(20);
+
+    for (const mode of UASTC_MODES) {
+        out[mode.mode] = mode;
+    }
+
+    return out;
+})();
+
+/**
+ * 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 = { 0: 2, 2: 4, 5: 8, 8: 16, 11: 32 };
+
+/**
+ * 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 = {
+    0: new Uint8Array([0, 64]),
+    2: new Uint8Array([0, 21, 43, 64]),
+    5: new Uint8Array([0, 9, 18, 27, 37, 46, 55, 64]),
+    8: new Uint8Array([0, 4, 8, 12, 17, 21, 25, 29, 35, 39, 43, 47, 52, 56, 60, 64]),
+    11: new Uint8Array([
+        0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30,
+        34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64,
+    ]),
+};
+
+/**
+ * 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 = {
+    4: { bits: 1, trits: 1, quints: 0,
+        value: new Uint8Array([
+            0, 255, 51, 204, 102, 153,
+        ]) },
+    6: { bits: 1, trits: 0, quints: 1,
+        value: new Uint8Array([
+            0, 255, 28, 227, 56, 199, 84, 171, 113, 142,
+        ]) },
+    7: { bits: 2, trits: 1, quints: 0,
+        value: new Uint8Array([
+            0, 255, 69, 186, 23, 232, 92, 163, 46, 209, 116, 139,
+        ]) },
+    9: { bits: 2, trits: 0, quints: 1,
+        value: new Uint8Array([
+            0, 255, 67, 188, 13, 242, 80, 175, 27, 228, 94, 161, 40, 215, 107, 148, 54, 201, 121,
+            134,
+        ]) },
+    10: { bits: 3, trits: 1, quints: 0,
+        value: new Uint8Array([
+            0, 255, 33, 222, 66, 189, 99, 156, 11, 244, 44, 211, 77, 178, 110, 145, 22, 233, 55,
+            200, 88, 167, 121, 134,
+        ]) },
+    12: { bits: 3, trits: 0, quints: 1,
+        value: new Uint8Array([
+            0, 255, 32, 223, 65, 190, 97, 158, 6, 249, 39, 216, 71, 184, 104, 151, 13, 242, 45,
+            210, 78, 177, 110, 145, 19, 236, 52, 203, 84, 171, 117, 138, 26, 229, 58, 197, 91, 164,
+            123, 132,
+        ]) },
+    13: { bits: 4, trits: 1, quints: 0,
+        value: new Uint8Array([
+            0, 255, 16, 239, 32, 223, 48, 207, 65, 190, 81, 174, 97, 158, 113, 142, 5, 250, 21,
+            234, 38, 217, 54, 201, 70, 185, 86, 169, 103, 152, 119, 136, 11, 244, 27, 228, 43, 212,
+            59, 196, 76, 179, 92, 163, 108, 147, 124, 131,
+        ]) },
+    15: { bits: 4, trits: 0, quints: 1,
+        value: new Uint8Array([
+            0, 255, 16, 239, 32, 223, 48, 207, 64, 191, 80, 175, 96, 159, 112, 143, 3, 252, 19,
+            236, 35, 220, 51, 204, 67, 188, 83, 172, 100, 155, 116, 139, 6, 249, 22, 233, 38, 217,
+            54, 201, 71, 184, 87, 168, 103, 152, 119, 136, 9, 246, 25, 230, 42, 213, 58, 197, 74,
+            181, 90, 165, 106, 149, 122, 133, 13, 242, 29, 226, 45, 210, 61, 194, 77, 178, 93, 162,
+            109, 146, 125, 130,
+        ]) },
+    16: { bits: 5, trits: 1, quints: 0,
+        value: new Uint8Array([
+            0, 255, 8, 247, 16, 239, 24, 231, 32, 223, 40, 215, 48, 207, 56, 199, 64, 191, 72, 183,
+            80, 175, 88, 167, 96, 159, 104, 151, 112, 143, 120, 135, 2, 253, 10, 245, 18, 237, 26,
+            229, 35, 220, 43, 212, 51, 204, 59, 196, 67, 188, 75, 180, 83, 172, 91, 164, 99, 156,
+            107, 148, 115, 140, 123, 132, 5, 250, 13, 242, 21, 234, 29, 226, 37, 218, 45, 210, 53,
+            202, 61, 194, 70, 185, 78, 177, 86, 169, 94, 161, 102, 153, 110, 145, 118, 137, 126,
+            129,
+        ]) },
+    18: { bits: 5, trits: 0, quints: 1,
+        value: new Uint8Array([
+            0, 255, 8, 247, 16, 239, 24, 231, 32, 223, 40, 215, 48, 207, 56, 199, 64, 191, 72, 183,
+            80, 175, 88, 167, 96, 159, 104, 151, 112, 143, 120, 135, 1, 254, 9, 246, 17, 238, 25,
+            230, 33, 222, 41, 214, 49, 206, 57, 198, 65, 190, 73, 182, 81, 174, 89, 166, 97, 158,
+            105, 150, 113, 142, 121, 134, 3, 252, 11, 244, 19, 236, 27, 228, 35, 220, 43, 212, 51,
+            204, 59, 196, 67, 188, 75, 180, 83, 172, 91, 164, 99, 156, 107, 148, 115, 140, 123,
+            132, 4, 251, 12, 243, 20, 235, 28, 227, 36, 219, 44, 211, 52, 203, 60, 195, 68, 187,
+            76, 179, 84, 171, 92, 163, 100, 155, 108, 147, 116, 139, 124, 131, 6, 249, 14, 241, 22,
+            233, 30, 225, 38, 217, 46, 209, 54, 201, 62, 193, 70, 185, 78, 177, 86, 169, 94, 161,
+            102, 153, 110, 145, 118, 137, 126, 129,
+        ]) },
+    19: { bits: 6, trits: 1, quints: 0,
+        value: new Uint8Array([
+            0, 255, 4, 251, 8, 247, 12, 243, 16, 239, 20, 235, 24, 231, 28, 227, 32, 223, 36, 219,
+            40, 215, 44, 211, 48, 207, 52, 203, 56, 199, 60, 195, 64, 191, 68, 187, 72, 183, 76,
+            179, 80, 175, 84, 171, 88, 167, 92, 163, 96, 159, 100, 155, 104, 151, 108, 147, 112,
+            143, 116, 139, 120, 135, 124, 131, 1, 254, 5, 250, 9, 246, 13, 242, 17, 238, 21, 234,
+            25, 230, 29, 226, 33, 222, 37, 218, 41, 214, 45, 210, 49, 206, 53, 202, 57, 198, 61,
+            194, 65, 190, 69, 186, 73, 182, 77, 178, 81, 174, 85, 170, 89, 166, 93, 162, 97, 158,
+            101, 154, 105, 150, 109, 146, 113, 142, 117, 138, 121, 134, 125, 130, 2, 253, 6, 249,
+            10, 245, 14, 241, 18, 237, 22, 233, 26, 229, 30, 225, 34, 221, 38, 217, 42, 213, 46,
+            209, 50, 205, 54, 201, 58, 197, 62, 193, 66, 189, 70, 185, 74, 181, 78, 177, 82, 173,
+            86, 169, 90, 165, 94, 161, 98, 157, 102, 153, 106, 149, 110, 145, 114, 141, 118, 137,
+            122, 133, 126, 129,
+        ]) },
+};
+
+/**
+ * The 2-subset partition patterns, as a subset index per texel in raster order.
+ *
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_PATTERNS_2 = new Uint8Array([
+    0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1,
+    1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0,
+    1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+    1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1,
+    0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1,
+    1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0,
+    1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0,
+    1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
+    1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0,
+]);
+
+/**
+ * The 3-subset partition patterns.
+ *
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_PATTERNS_3 = new Uint8Array([
+    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2,
+    1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0,
+    1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2,
+    0, 2, 1, 1, 0, 2, 1, 1, 0, 2, 1, 1, 0, 2, 1, 1, 2, 0, 0, 0, 2, 0, 0, 0, 2, 1, 1, 1, 2, 1, 1, 1,
+    2, 0, 1, 2, 2, 0, 1, 2, 2, 0, 1, 2, 2, 0, 1, 2, 1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 1, 1, 1, 1,
+    0, 0, 2, 2, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 2,
+]);
+
+/**
+ * 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 = new Uint8Array([
+    0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0,
+    1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
+    0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1,
+    1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+    0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0,
+    1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+]);
+
+/**
+ * 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 = new Uint8Array([
+    0, 2, 0, 3, 1, 0, 0, 3, 7, 0, 0, 2, 3, 0, 7, 0, 0, 11, 2, 0, 0, 7, 11, 0, 3, 0, 8, 0, 0, 4, 12,
+    0, 1, 0, 8, 0, 0, 1, 0, 2, 0, 4, 8, 0, 1, 0, 0, 2, 4, 0, 0, 1, 4, 0, 1, 0, 4, 0, 1, 0,
+]);
+
+/**
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_ANCHORS_3 = new Uint8Array([
+    0, 8, 10, 8, 0, 12, 4, 0, 12, 8, 0, 4, 3, 0, 2, 0, 1, 3, 0, 2, 1, 1, 9, 0, 1, 2, 0, 4, 0, 8, 0,
+    6, 2,
+]);
+
+/**
+ * @readonly
+ * @type {Uint8Array}
+ */
+export const UASTC_ANCHORS_2_BC7_3 = new Uint8Array([
+    0, 4, 0, 2, 2, 0, 0, 7, 8, 0, 0, 1, 0, 3, 0, 1, 2, 0, 0, 1, 0, 8, 2, 0, 0, 1, 0, 7, 12, 0, 2,
+    0, 9, 0, 0, 2, 4, 0,
+]);

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

@@ -0,0 +1,30 @@
+/**
+ * Transcode UASTC to ASTC 4x4 by repacking, which is what the format was built for.
+ *
+ * **Nothing is fitted and nothing is lost.** UASTC's nineteen modes were laid out so that each one's
+ * fields *are* an ASTC block's fields: the endpoints are already in ASTC's quantized space at a range
+ * ASTC names, the weights are already ASTC weights, and the partition patterns were taken from
+ * ASTC's own hash. What is left is arithmetic on bit positions — ASTC interleaves its integer
+ * sequences where UASTC keeps them in two plain runs, and puts its weights at the far end of the
+ * block in reverse.
+ *
+ * That is the whole difference between this and the re-encode measured at 34.9 dB in §9.18. A
+ * re-encode has to choose one colour line for a block that may have three, which is exactly what a
+ * normal map is worst at; a repack keeps the three the file already had.
+ *
+ * **Endpoints may be swapped, which is lossless.** Colour endpoint modes 8 and 12 swap their pair and
+ * blue-contract when the second endpoint's channel sum falls below the first's. UASTC guarantees the
+ * order it needs for BC7's rules rather than ASTC's, so a subset that would trip the rule has its
+ * pair exchanged and its weights inverted — the same block, described the other way up.
+ *
+ * @param {Uint8Array} blocks UASTC blocks, tightly packed
+ * @param {number} block_count
+ * @returns {Uint8Array} tightly packed ASTC blocks, in raster order
+ * @throws {Error} for a mode this cannot express
+ *
+ * @see the UASTC LDR 4x4 specification, "Converting to ASTC"
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function uastc_to_astc(blocks: Uint8Array, block_count: number): Uint8Array;
+//# sourceMappingURL=uastc_to_astc.d.ts.map

package/src/format/texture/basis/uastc/uastc_to_astc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uastc_to_astc.d.ts","sourceRoot":"","sources":["../../../../../../src/format/texture/basis/uastc/uastc_to_astc.js"],"names":[],"mappings":"AA2IA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,sCATW,UAAU,eACV,MAAM,GACJ,UAAU,CAmBtB"}