@woosh/meep-engine 3.14.2 → 3.14.3

package/src/format/texture/basis/transcode/etc1s_to_etc2.js

@@ -0,0 +1,332 @@
+import { etc1s_block_colors } from "../etc1s/etc1s_block_colors.js";
+
+/**
+ * Bytes in one ETC2 RGB block, and in one EAC alpha block.
+ *
+ * @readonly
+ * @type {number}
+ */
+const ETC_BLOCK_BYTES = 8;
+
+/**
+ * Where an ETC1S selector lands in ETC1's own index space.
+ *
+ * **The one place these two disagree.** `INTENSITY_MODIFIER` is ordered darkest to brightest, which
+ * is the order a Basis selector indexes it in. ETC1 stores the same four modifiers as two magnitudes
+ * with their signs, indexed `+a, +b, -a, -b`. So a selector of 0 — the darkest, `-b` — is ETC1's
+ * index 3, and writing the selector through unchanged mirrors every block through its own mid-grey.
+ *
+ * @readonly
+ * @type {Uint8Array}
+ */
+const SELECTOR_TO_ETC1_INDEX = new Uint8Array([3, 2, 0, 1]);
+
+/**
+ * EAC's modifier table: sixteen rows of eight, indexed by a block's table field and a texel's index.
+ *
+ * Row 13 is the one this file depends on. It is the only row containing zero, which is what lets a
+ * block encode a single alpha value *exactly* — base codeword, multiplier one, every index pointing
+ * at the zero. An opaque block has to come back as 255 and not 254.
+ *
+ * @readonly
+ * @type {Int32Array}
+ * @see the ETC2/EAC specification, table "Intensity modifier sets for alpha component"
+ */
+const EAC_MODIFIER = new Int32Array([
+    -3, -6, -9, -15, 2, 5, 8, 14,
+    -3, -7, -10, -13, 2, 5, 9, 13,
+    -2, -5, -8, -13, 1, 4, 7, 12,
+    -2, -4, -6, -13, 1, 3, 5, 12,
+    -3, -6, -8, -12, 2, 5, 7, 11,
+    -3, -7, -9, -11, 2, 5, 8, 10,
+    -4, -7, -8, -11, 3, 6, 7, 10,
+    -3, -5, -8, -11, 2, 4, 7, 10,
+    -2, -6, -8, -10, 1, 5, 7, 9,
+    -2, -5, -8, -10, 1, 4, 7, 9,
+    -2, -4, -8, -10, 1, 3, 7, 9,
+    -2, -5, -7, -10, 1, 4, 6, 9,
+    -3, -4, -7, -10, 2, 3, 6, 9,
+    -1, -2, -3, -10, 0, 1, 2, 9,
+    -4, -6, -8, -9, 3, 5, 7, 8,
+    -3, -5, -7, -9, 2, 4, 6, 8,
+]);
+
+/**
+ * The EAC table row holding a zero modifier, and the index of that zero within it.
+ *
+ * @readonly
+ * @type {number}
+ */
+const EAC_EXACT_TABLE = 13;
+const EAC_EXACT_INDEX = 4;
+
+/**
+ * Transcode ETC1S to ETC2, which for these blocks is a repack rather than a re-encode.
+ *
+ * **ETC1S is a constrained ETC1, and ETC1 is a subset of ETC2.** A Basis block is one base colour
+ * with one intensity table and sixteen two-bit selectors, which is precisely ETC1's differential
+ * mode with both subblocks given the same colour — the deltas are zero and the two table codewords
+ * are equal. So nothing is fitted, nothing is searched, and nothing is lost: the RGB half of the
+ * output decodes bit-identically to what {@link etc1s_to_rgba8} produces, on any ETC2 hardware.
+ *
+ * That is what makes this worth having over the uncompressed floor on a device with no BC. It is
+ * eight bits a texel against thirty-two, at no cost in quality at all.
+ *
+ * **Alpha is the part that is actually encoded.** ETC2's RGBA8 block is an EAC alpha block followed
+ * by the RGB one, and EAC is a different scheme — a base value, a multiplier and a table, with three
+ * bits a texel. A payload with no alpha slice is written exactly opaque through the one table row
+ * containing a zero; a payload that carries alpha is fitted, which is the only lossy step here.
+ *
+ * @param {Etc1sSlice} slice
+ * @param {Etc1sSlice|undefined} alpha_slice
+ * @param {Etc1sEndpointCodebook} endpoints
+ * @param {Etc1sSelectorCodebook} selectors
+ * @param {number} _width unused: an ETC2 level is a whole number of blocks, like every block format
+ * @param {number} _height
+ * @param {boolean} [with_alpha] write the 16-byte RGBA8 block rather than the 8-byte RGB8 one
+ * @returns {Uint8Array} tightly packed blocks, in raster order
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function etc1s_to_etc2(slice, alpha_slice, endpoints, selectors, _width, _height, with_alpha = false) {
+    const block_count = slice.blocks_x * slice.blocks_y;
+
+    const block_bytes = with_alpha ? ETC_BLOCK_BYTES * 2 : ETC_BLOCK_BYTES;
+
+    const out = new Uint8Array(block_count * block_bytes);
+
+    const alpha_palette = new Uint8Array(12);
+    const alpha_values = new Uint8Array(16);
+
+    for (let block = 0; block < block_count; block++) {
+        let offset = block * block_bytes;
+
+        if (with_alpha) {
+            if (alpha_slice === undefined) {
+                write_eac_constant(out, offset, 255);
+            } else {
+                etc1s_block_colors(
+                    alpha_palette, 0, endpoints.color5, endpoints.intensity,
+                    alpha_slice.endpoint_index[block]
+                );
+
+                const base = alpha_slice.selector_index[block] * 16;
+
+                for (let texel = 0; texel < 16; texel++) {
+                    // green, for the reason etc1s_to_rgba8 gives: an alpha slice is greyscale
+                    alpha_values[texel] = alpha_palette[selectors.selectors[base + texel] * 3 + 1];
+                }
+
+                write_eac(out, offset, alpha_values);
+            }
+
+            offset += ETC_BLOCK_BYTES;
+        }
+
+        write_etc1(
+            out, offset,
+            endpoints.color5, endpoints.intensity, slice.endpoint_index[block],
+            selectors.selectors, slice.selector_index[block] * 16
+        );
+    }
+
+    return out;
+}
+
+/**
+ * Write one ETC1 block in differential mode, both subblocks sharing the ETC1S block's colour.
+ *
+ * @param {Uint8Array} out
+ * @param {number} offset
+ * @param {Uint8Array} color5 endpoint codebook channels
+ * @param {Uint8Array} intensity endpoint codebook intensity indices
+ * @param {number} endpoint_index
+ * @param {Uint8Array} selector_values the selector codebook's array
+ * @param {number} selector_base where this block's sixteen selectors start
+ */
+function write_etc1(out, offset, color5, intensity, endpoint_index, selector_values, selector_base) {
+    const r = color5[endpoint_index * 3];
+    const g = color5[endpoint_index * 3 + 1];
+    const b = color5[endpoint_index * 3 + 2];
+
+    const table = intensity[endpoint_index];
+
+    /*
+     Differential mode with all three deltas zero. The alternative — individual mode, two 4-bit
+     colours — would have to quantise the five-bit channel down to four and lose a bit per channel
+     for nothing, since the two subblocks hold the same colour either way.
+    */
+    out[offset] = (r << 3);
+    out[offset + 1] = (g << 3);
+    out[offset + 2] = (b << 3);
+
+    // table codeword 0 and 1 both the block's intensity, diffbit set, flipbit clear
+    out[offset + 3] = (table << 5) | (table << 2) | 0b10;
+
+    let msb = 0;
+    let lsb = 0;
+
+    for (let y = 0; y < 4; y++) {
+        for (let x = 0; x < 4; x++) {
+            const index = SELECTOR_TO_ETC1_INDEX[selector_values[selector_base + y * 4 + x]];
+
+            /*
+             ETC1 numbers its texels down each column and then across, where every other block
+             format here runs along the rows — so this is the one place a raster loop has to be
+             transposed rather than followed.
+            */
+            const bit = x * 4 + y;
+
+            msb |= (index >> 1) << bit;
+            lsb |= (index & 1) << bit;
+        }
+    }
+
+    out[offset + 4] = (msb >> 8) & 0xFF;
+    out[offset + 5] = msb & 0xFF;
+    out[offset + 6] = (lsb >> 8) & 0xFF;
+    out[offset + 7] = lsb & 0xFF;
+}
+
+/**
+ * Write an EAC alpha block holding one value in all sixteen texels, exactly.
+ *
+ * @param {Uint8Array} out
+ * @param {number} offset
+ * @param {number} value
+ */
+function write_eac_constant(out, offset, value) {
+    out[offset] = value;
+
+    // multiplier 1, and the table row whose fifth entry is zero
+    out[offset + 1] = (1 << 4) | EAC_EXACT_TABLE;
+
+    // every texel takes that zero, so every texel decodes to the base value
+    let bits = 0n;
+
+    for (let texel = 0; texel < 16; texel++) {
+        bits |= BigInt(EAC_EXACT_INDEX) << BigInt(45 - texel * 3);
+    }
+
+    for (let i = 0; i < 6; i++) {
+        out[offset + 2 + i] = Number((bits >> BigInt(40 - i * 8)) & 0xFFn);
+    }
+}
+
+/**
+ * Fit and write an EAC alpha block for sixteen values.
+ *
+ * **Searched rather than derived.** EAC's sixteen table rows are not scalings of one another — they
+ * differ in how their eight modifiers are distributed, so which row fits a block depends on the
+ * shape of its values and not only on their range. Sixteen rows against sixteen multipliers is 256
+ * candidates and each is sixteen nearest-value lookups, which is small enough to simply try.
+ *
+ * The base is fixed at the midpoint rather than searched with them. It is the one parameter that
+ * shifts every reachable value together, so the midpoint is optimal for a symmetric row and close
+ * for the rest, and adding it to the search would multiply the cost by 256 for a fraction of a
+ * level.
+ *
+ * @param {Uint8Array} out
+ * @param {number} offset
+ * @param {Uint8Array} values sixteen
+ */
+function write_eac(out, offset, values) {
+    let low = 255;
+    let high = 0;
+
+    for (let i = 0; i < 16; i++) {
+        if (values[i] < low) {
+            low = values[i];
+        }
+
+        if (values[i] > high) {
+            high = values[i];
+        }
+    }
+
+    if (low === high) {
+        // exact, and the common case: an alpha slice is mostly flat regions
+        write_eac_constant(out, offset, low);
+
+        return;
+    }
+
+    const base = (low + high) >> 1;
+
+    let best_table = 0;
+    let best_multiplier = 1;
+    let best_error = Infinity;
+
+    for (let table = 0; table < 16; table++) {
+        for (let multiplier = 1; multiplier < 16; multiplier++) {
+            let error = 0;
+
+            for (let texel = 0; texel < 16; texel++) {
+                error += nearest(values[texel], base, table, multiplier).error;
+
+                if (error >= best_error) {
+                    break;
+                }
+            }
+
+            if (error < best_error) {
+                best_error = error;
+                best_table = table;
+                best_multiplier = multiplier;
+            }
+        }
+    }
+
+    out[offset] = base;
+    out[offset + 1] = (best_multiplier << 4) | best_table;
+
+    let bits = 0n;
+
+    /*
+     EAC numbers its texels down each column, exactly as ETC1 does — so a raster-ordered array has to
+     be transposed on the way in. A constant block hides this completely, which is why the opaque
+     path above can ignore it and why this was worth checking against a block that is not constant.
+    */
+    for (let y = 0; y < 4; y++) {
+        for (let x = 0; x < 4; x++) {
+            const index = nearest(values[y * 4 + x], base, best_table, best_multiplier).index;
+
+            bits |= BigInt(index) << BigInt(45 - (x * 4 + y) * 3);
+        }
+    }
+
+    for (let i = 0; i < 6; i++) {
+        out[offset + 2 + i] = Number((bits >> BigInt(40 - i * 8)) & 0xFFn);
+    }
+}
+
+/**
+ * The index whose decoded alpha is closest to `value`, and the squared error it leaves.
+ *
+ * @param {number} value
+ * @param {number} base
+ * @param {number} table
+ * @param {number} multiplier
+ * @returns {{index: number, error: number}}
+ */
+function nearest(value, base, table, multiplier) {
+    let best = 0;
+    let best_error = Infinity;
+
+    for (let index = 0; index < 8; index++) {
+        let decoded = base + EAC_MODIFIER[table * 8 + index] * multiplier;
+
+        decoded = decoded < 0 ? 0 : decoded > 255 ? 255 : decoded;
+
+        const delta = decoded - value;
+        const error = delta * delta;
+
+        if (error < best_error) {
+            best_error = error;
+            best = index;
+        }
+    }
+
+    return { index: best, error: best_error };
+}

package/src/format/texture/basis/transcode/etc1s_to_rgba8.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Decode ETC1S to plain 8-bit RGBA texels.
+ *
+ * **The path for a device that can sample no compressed format at all.** Every other target here
+ * writes blocks, and each is chosen because it is *smaller*; this one is chosen because it is
+ * always available. WebGPU guarantees no compressed format — `texture-compression-bc`, `-etc2` and
+ * `-astc` are all optional features — so without this a `KHR_texture_basisu` model is unloadable on
+ * a device that happens to expose none of them, which is a refusal where a picture was possible.
+ *
+ * It costs four bytes a texel against BC7's one, so it is the last thing any caller should pick, and
+ * `texture_format_preference` accordingly never names it: an empty preference list is what means
+ * "ask for the uncompressed encoding".
+ *
+ * **Cropped to the image, not to the block grid.** A block format's level is a whole number of
+ * blocks and the format table sizes it that way, so a 100x60 texture stores 25x15 blocks and the
+ * padding is simply never sampled. `rgba8unorm` has no such slack — its level is exactly
+ * `width * height * 4` — so the partial blocks along the right and bottom edges are written only as
+ * far as the image goes.
+ *
+ * **Do not remove the two bounds checks below on the grounds that a test still passes.** They are
+ * unobservable, and only by accident: a write past the right edge of row `y` lands at the start of
+ * row `y + 1` because the index is row-major, and row `y + 1` is written afterwards and overwrites
+ * it. The one spill nothing corrects runs past the end of the buffer, where a typed array silently
+ * drops it. So the output is the same either way, and it is the same for reasons that hold only
+ * while the iteration order does — reorder the loops and the coincidence stops covering.
+ *
+ * @param {Etc1sSlice} slice
+ * @param {Etc1sSlice|undefined} alpha_slice a second slice holding alpha, if the payload carries one
+ * @param {Etc1sEndpointCodebook} endpoints
+ * @param {Etc1sSelectorCodebook} selectors
+ * @param {number} width in texels
+ * @param {number} height in texels
+ * @returns {Uint8Array} `width * height * 4` bytes, in raster order
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function etc1s_to_rgba8(slice: Etc1sSlice, alpha_slice: Etc1sSlice | undefined, endpoints: Etc1sEndpointCodebook, selectors: Etc1sSelectorCodebook, width: number, height: number): Uint8Array;
+//# sourceMappingURL=etc1s_to_rgba8.d.ts.map

package/src/format/texture/basis/transcode/etc1s_to_rgba8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"etc1s_to_rgba8.d.ts","sourceRoot":"","sources":["../../../../../../src/format/texture/basis/transcode/etc1s_to_rgba8.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,+DAVW,aAAW,SAAS,6EAGpB,MAAM,UACN,MAAM,GACJ,UAAU,CAwEtB"}

package/src/format/texture/basis/transcode/etc1s_to_rgba8.js

@@ -0,0 +1,115 @@
+import { etc1s_block_colors } from "../etc1s/etc1s_block_colors.js";
+
+/**
+ * Side of an ETC1S block, in texels.
+ *
+ * @readonly
+ * @type {number}
+ */
+const BLOCK_SIZE = 4;
+
+/**
+ * Decode ETC1S to plain 8-bit RGBA texels.
+ *
+ * **The path for a device that can sample no compressed format at all.** Every other target here
+ * writes blocks, and each is chosen because it is *smaller*; this one is chosen because it is
+ * always available. WebGPU guarantees no compressed format — `texture-compression-bc`, `-etc2` and
+ * `-astc` are all optional features — so without this a `KHR_texture_basisu` model is unloadable on
+ * a device that happens to expose none of them, which is a refusal where a picture was possible.
+ *
+ * It costs four bytes a texel against BC7's one, so it is the last thing any caller should pick, and
+ * `texture_format_preference` accordingly never names it: an empty preference list is what means
+ * "ask for the uncompressed encoding".
+ *
+ * **Cropped to the image, not to the block grid.** A block format's level is a whole number of
+ * blocks and the format table sizes it that way, so a 100x60 texture stores 25x15 blocks and the
+ * padding is simply never sampled. `rgba8unorm` has no such slack — its level is exactly
+ * `width * height * 4` — so the partial blocks along the right and bottom edges are written only as
+ * far as the image goes.
+ *
+ * **Do not remove the two bounds checks below on the grounds that a test still passes.** They are
+ * unobservable, and only by accident: a write past the right edge of row `y` lands at the start of
+ * row `y + 1` because the index is row-major, and row `y + 1` is written afterwards and overwrites
+ * it. The one spill nothing corrects runs past the end of the buffer, where a typed array silently
+ * drops it. So the output is the same either way, and it is the same for reasons that hold only
+ * while the iteration order does — reorder the loops and the coincidence stops covering.
+ *
+ * @param {Etc1sSlice} slice
+ * @param {Etc1sSlice|undefined} alpha_slice a second slice holding alpha, if the payload carries one
+ * @param {Etc1sEndpointCodebook} endpoints
+ * @param {Etc1sSelectorCodebook} selectors
+ * @param {number} width in texels
+ * @param {number} height in texels
+ * @returns {Uint8Array} `width * height * 4` bytes, in raster order
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function etc1s_to_rgba8(slice, alpha_slice, endpoints, selectors, width, height) {
+    const out = new Uint8Array(width * height * 4);
+
+    const palette = new Uint8Array(12);
+    const alpha_palette = new Uint8Array(12);
+
+    for (let block_y = 0; block_y < slice.blocks_y; block_y++) {
+        for (let block_x = 0; block_x < slice.blocks_x; block_x++) {
+            const block = block_y * slice.blocks_x + block_x;
+
+            etc1s_block_colors(
+                palette, 0, endpoints.color5, endpoints.intensity, slice.endpoint_index[block]
+            );
+
+            const selector_base = slice.selector_index[block] * 16;
+
+            let alpha_selector_base = 0;
+
+            if (alpha_slice !== undefined) {
+                etc1s_block_colors(
+                    alpha_palette, 0, endpoints.color5, endpoints.intensity,
+                    alpha_slice.endpoint_index[block]
+                );
+
+                alpha_selector_base = alpha_slice.selector_index[block] * 16;
+            }
+
+            for (let row = 0; row < BLOCK_SIZE; row++) {
+                const y = block_y * BLOCK_SIZE + row;
+
+                if (y >= height) {
+                    break;
+                }
+
+                for (let column = 0; column < BLOCK_SIZE; column++) {
+                    const x = block_x * BLOCK_SIZE + column;
+
+                    if (x >= width) {
+                        break;
+                    }
+
+                    const texel = row * BLOCK_SIZE + column;
+
+                    const colour = selectors.selectors[selector_base + texel] * 3;
+
+                    const o = (y * width + x) * 4;
+
+                    out[o] = palette[colour];
+                    out[o + 1] = palette[colour + 1];
+                    out[o + 2] = palette[colour + 2];
+
+                    /*
+                     An alpha slice is an ordinary ETC1S slice carrying a greyscale image, so its
+                     three channels hold the same value and any one of them is the alpha. Green is
+                     taken because it is the channel ETC1S quantises least coarsely — the endpoint's
+                     five bits are the same for each, but the encoder's own fit is driven by
+                     luminance, which green dominates.
+                    */
+                    out[o + 3] = alpha_slice === undefined
+                        ? 255
+                        : alpha_palette[selectors.selectors[alpha_selector_base + texel] * 3 + 1];
+                }
+            }
+        }
+    }
+
+    return out;
+}

package/src/format/texture/basis/transcode/fit_endpoints.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Fit a pair of endpoints to the colours a block actually uses, by least squares.
+ *
+ * **Why the obvious choice is not good enough.** An ETC1S block's four colours are its base colour
+ * plus a modifier applied equally to every channel, so before clamping they lie on a line and the
+ * darkest and brightest of them span it exactly. Clamping breaks that. A base colour near white with
+ * a large modifier gives, say, red `{67, 203, 255, 255}` beside green `{0, 0, 57, 193}` — still
+ * ordered, but no longer collinear, because red saturated and green did not. Taking the outer two as
+ * endpoints then leaves the middle two nowhere near the line between them, and no interpolation
+ * weight can recover them.
+ *
+ * So the endpoints are fitted rather than read off: each colour is assigned the weight that suits it
+ * best, the endpoints are re-solved to minimise squared error against all of them at once, and the
+ * two steps alternate.
+ *
+ * **And the fit is over `[min_selector, max_selector]` only. This is the part that matters.** Which
+ * colours a block uses is a property of its *selector* codebook entry, and most entries do not use
+ * all four — a block spanning only the darkest two is a line those two define exactly, and fitting
+ * it against colours it never samples throws that away for nothing.
+ *
+ * The two halves are worth very different amounts, and it is worth knowing which is which before
+ * anyone simplifies one of them away. Measured on the noise fixture: **conditioning on the span is
+ * worth about 9 dB for BC7 and 6 dB for BC1**, and dropping it takes the worst channel error from 2
+ * to 30. The least-squares solve on top of it is worth **0 to 1 dB** — nothing at all on that
+ * fixture, about a decibel on the harder mip levels of the gradient and the non-power-of-two file.
+ * It stays because it is cheap beside the template build and because those levels are real, not
+ * because it is what closes the gap to the reference transcoder.
+ *
+ * @param {Uint8Array} low three channels, seeded with a guess and overwritten with the fit
+ * @param {Uint8Array} high three channels, likewise
+ * @param {Uint8Array} colors twelve bytes, the block's four `[r, g, b]` colours
+ * @param {Int32Array} weights the destination format's interpolation weights, out of 64
+ * @param {number} min_selector lowest selector value any block using this pairing has
+ * @param {number} max_selector highest
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function fit_endpoints(low: Uint8Array, high: Uint8Array, colors: Uint8Array, weights: Int32Array, min_selector: number, max_selector: number): void;
+/**
+ * Solve for the endpoint pair that best reproduces a span of colours, given which weight each is to
+ * be reproduced at.
+ *
+ * Separated from {@link fit_endpoints} because the assignment is not always worth searching for
+ * greedily. A format with few weights — BC1 has four — is better served by trying every sensible
+ * assignment and solving each, since the best one routinely places both endpoints *outside* the
+ * colours they encode. Three evenly spaced colours are the standard case: no pair of endpoints has
+ * them at weights 0, something, and 64, but a pair extended past both ends puts them at 64, 43 and
+ * 21 almost exactly.
+ *
+ * @param {Uint8Array} low three channels, overwritten
+ * @param {Uint8Array} high three channels, overwritten
+ * @param {Uint8Array} colors twelve bytes
+ * @param {Int32Array} weight_of_selector the weight each selector is to be reproduced at, out of 64
+ * @param {number} min_selector
+ * @param {number} max_selector
+ * @returns {boolean} whether a solution exists — it does not when every colour was given the same
+ * weight, which says nothing about where the endpoints are
+ */
+export function solve_endpoints(low: Uint8Array, high: Uint8Array, colors: Uint8Array, weight_of_selector: Int32Array, min_selector: number, max_selector: number): boolean;
+/**
+ * The `[min, max]` selector span of every entry of a selector codebook.
+ *
+ * @param {Etc1sSelectorCodebook} selectors
+ * @returns {Uint8Array} one index into {@link SELECTOR_RANGES} per entry
+ */
+export function selector_codebook_ranges(selectors: Etc1sSelectorCodebook): Uint8Array;
+/**
+ * Every `[min, max]` span of selector values a block can use, as pairs.
+ *
+ * Ten of them, because a span is an ordered pair drawn from four values. A block that only uses the
+ * darkest two colours is fitted against those two alone, which is the whole reason this exists — see
+ * {@link fit_endpoints}.
+ *
+ * @readonly
+ * @type {number[][]}
+ */
+export const SELECTOR_RANGES: number[][];
+//# sourceMappingURL=fit_endpoints.d.ts.map

package/src/format/texture/basis/transcode/fit_endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fit_endpoints.d.ts","sourceRoot":"","sources":["../../../../../../src/format/texture/basis/transcode/fit_endpoints.js"],"names":[],"mappings":"AAgDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,mCAVW,UAAU,QACV,UAAU,UACV,UAAU,WACV,UAAU,gBACV,MAAM,gBACN,MAAM,QA+EhB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qCATW,UAAU,QACV,UAAU,UACV,UAAU,sBACV,UAAU,gBACV,MAAM,gBACN,MAAM,GACJ,OAAO,CAyCnB;AA+CD;;;;;GAKG;AACH,4EAFa,UAAU,CAyBtB;AA1RD;;;;;;;;;GASG;AACH,8BAFU,MAAM,EAAE,EAAE,CAOlB"}