@woosh/meep-engine 3.14.2 → 3.14.4

package/src/ktx2/ktx2_read.js

@@ -1,581 +0,0 @@
-import pako from "pako";
-import { assert } from "../core/assert.js";
-import { ByteCursor } from "../core/binary/ByteCursor.js";
-import { EndianType } from "../core/binary/EndianType.js";
-import { utf8_decode } from "../core/binary/utf8/utf8_decode.js";
-import { isArrayEqualStrict } from "../core/collection/array/isArrayEqualStrict.js";
-import { gpu_texture_format_is_block_compressed } from "../shade/descriptor/texture/format/gpu_texture_format_info.js";
-import { ShadeTexelData } from "../shade/renderer/texture/source/ShadeTexelData.js";
-import { khr_df_model_name, KhrDfModel } from "./KhrDfModel.js";
-import { KTX2_IDENTIFIER } from "./KTX2_IDENTIFIER.js";
-import { SupercompressionScheme } from "./SupercompressionScheme.js";
-import { vk_format_to_texture_format, VK_FORMAT_UNDEFINED } from "./vk_format_to_texture_format.js";
-
-/**
- * Offset of the Data Format Descriptor's `colorModel` byte from the start of the DFD section:
- * past `dfdTotalSize`, then past the basic block's first two words.
- *
- * @readonly
- * @type {number}
- */
-const DFD_COLOR_MODEL_OFFSET = 4 + 8;
-
-/**
- * Bytes each entry of the level index occupies — three 64-bit fields.
- *
- * @readonly
- * @type {number}
- */
-const LEVEL_INDEX_ENTRY_BYTES = 24;
-
-/**
- * The only orientation this reader accepts, as the axis letters KTX2 writes them in.
- *
- * `r` then `d` is a top-left origin with rows running down, which is what `queue.writeTexture` takes
- * and what every tool in this tree assumes; `i` is the third axis running away from the viewer,
- * which is the order 3D slices are uploaded in. As many letters are checked as the texture has
- * dimensions, so a 2D file is judged on `rd` alone.
- *
- * Deliberately strict about the third axis, which is the one that could go either way: `o` would
- * mean the slices are stored back to front, and a volume loaded inside out is not a failure anybody
- * would attribute to the reader. Refusing names the value, so a file that is genuinely fine is a
- * one-line change here rather than a mystery.
- *
- * @readonly
- * @type {string}
- */
-const SUPPORTED_ORIENTATION = "rdi";
-
-/**
- * Read a KTX2 file into the texel payload the engine uploads.
- *
- * **The whole contract is `bytes -> ShadeTexelData`.** No device, no queue, no engine: the same
- * function serves a worker, a node tool and the offline encoder, which is why a container reader is
- * not engine code. What it produces is the ordinary payload — a compressed texture entering this way
- * is indistinguishable, below `ShadeImage`, from one that arrived any other way.
- *
- * **What it reads.** A file whose payload is already in a format WebGPU can sample: any `vkFormat`
- * that maps to a `GPUTextureFormat` (see {@link vk_format_to_texture_format}), with
- * {@link SupercompressionScheme.None} or {@link SupercompressionScheme.ZLIB}. That is what
- * first-party tooling emits, and it needs no transcoder.
- *
- * **What it refuses, by name.** Everything else, individually, because the point of a refusal is to
- * say which feature is missing rather than to produce a texture full of the wrong bytes:
- *
- * | Refused | Why |
- * |---|---|
- * | {@link SupercompressionScheme.BasisLZ} | ETC1S, and a transcoder is not a decompressor |
- * | {@link SupercompressionScheme.Zstandard} | there is no Zstandard decompressor in this repository |
- * | `VK_FORMAT_UNDEFINED` (ETC1S / UASTC) | Basis Universal, transcoded rather than sampled |
- * | an unmapped `vkFormat` | WebGPU does not expose it |
- * | `layerCount > 0`, `faceCount == 6` | array and cube textures, which {@link ShadeTexelData} does not model |
- * | `pixelHeight == 0` | a 1D texture, likewise |
- * | a 3D block-compressed payload | needs `texture-compression-*-sliced-3d`, which nothing here asks for |
- * | `levelCount == 0` on a block format | see below |
- * | a non-default `KTXorientation` or `KTXswizzle` | the bytes would need rearranging, and nothing here rearranges them |
- *
- * **`levelCount == 0` means "generate the mip chain at load", which is not the same as `1`.** It is
- * an *instruction*, and the payload type carries data rather than instructions: the engine's
- * instruction is `ShadeTextureFlags.GenerateMipMaps`, which lives on the `ShadeTexture` and is
- * honoured or thrown. So a `levelCount == 0` file reads as the single level it physically contains,
- * and whether mips get generated is the caller's to state — which is the same rule that makes a
- * supplied chain and a generated one distinguishable at all. For a block-compressed payload the
- * instruction cannot be honoured by anything, at any layer, so that combination is refused here
- * rather than left to fail later with a message about a flag the file never mentioned.
- *
- * **The level index is base-first; the image data usually is not.** KTX2 conventionally stores the
- * smallest level at the lowest offset, so levels are read through `byteOffset` and never by walking
- * the file. `levels[0]` is the base level whatever order the file laid its bytes out in.
- *
- * Level bytes are views onto `bytes`, not copies, wherever supercompression permits it — the payload
- * is the overwhelming majority of a texture file, and copying it to hand it to `writeTexture` would
- * double the peak memory of every texture load for nothing.
- *
- * @param {ArrayBuffer|Uint8Array} bytes the whole file
- * @returns {ShadeTexelData}
- * @throws {Error} naming the feature, for a file this reader does not read; naming the field, for a
- * file that is truncated or self-inconsistent
- *
- * @see https://registry.khronos.org/KTX/specs/2.0/ktxspec.v2.html
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function ktx2_read(bytes) {
-    assert.defined(bytes, 'bytes');
-    assert.notNull(bytes, 'bytes');
-
-    // KTX2 is little-endian throughout, which is the one thing the cursor has to be told
-    const cursor = new ByteCursor().init(bytes, EndianType.LittleEndian);
-
-    read_identifier(cursor);
-
-    const vk_format = cursor.u32();
-    const type_size = cursor.u32();
-    const pixel_width = cursor.u32();
-    const pixel_height = cursor.u32();
-    const pixel_depth = cursor.u32();
-    const layer_count = cursor.u32();
-    const face_count = cursor.u32();
-    const level_count = cursor.u32();
-    const supercompression_scheme = cursor.u32();
-
-    const dfd_byte_offset = cursor.u32();
-    const dfd_byte_length = cursor.u32();
-    const kvd_byte_offset = cursor.u32();
-    const kvd_byte_length = cursor.u32();
-
-    // the SGD holds BasisLZ codebooks and nothing else, so it is skipped rather than read — the
-    // scheme that produced it is refused below
-    cursor.skip(16);
-
-    /*
-     The level index follows the header immediately, but the refusals below read from elsewhere in
-     the file and a cursor is one position. Remember where the index starts rather than depending on
-     which of them happened to move it, which is the kind of coupling that survives until someone
-     reorders two lines.
-    */
-    const level_index_position = cursor.position;
-
-    refuse_unsupported_supercompression(supercompression_scheme);
-
-    const format = texture_format_of(cursor, vk_format, dfd_byte_offset, dfd_byte_length);
-
-    refuse_unsupported_shape(pixel_width, pixel_height, pixel_depth, layer_count, face_count, format);
-
-    refuse_unsupported_metadata(cursor, kvd_byte_offset, kvd_byte_length, pixel_depth);
-
-    if (gpu_texture_format_is_block_compressed(format)) {
-        /*
-         The specification requires this of a block-compressed payload, and it is worth checking
-         rather than ignoring: `typeSize` is the width of the unit a big-endian host would byte-swap,
-         and a block has no such unit. A file claiming otherwise disagrees with itself about what its
-         own bytes are.
-        */
-        if (type_size !== 1) {
-            throw new Error(
-                `KTX2: typeSize is ${type_size} for '${format}', which is block-compressed and must`
-                + ` declare a typeSize of 1`
-            );
-        }
-
-        if (level_count === 0) {
-            throw new Error(
-                `KTX2: levelCount is 0 — "generate the mip chain at load" — for '${format}', which`
-                + ` is block-compressed. Nothing can generate mips for a block format: they come`
-                + ` from the encoder. Re-encode with a mip chain, or declare levelCount 1 and accept`
-                + ` a single-level texture.`
-            );
-        }
-    }
-
-    cursor.seek(level_index_position);
-
-    const level_index = read_level_index(cursor, Math.max(level_count, 1));
-
-    const levels = level_index.map(
-        (entry, level) => read_level(cursor, entry, level, supercompression_scheme)
-    );
-
-    /*
-     `ShadeTexelData` is the authority on whether these bytes are the right number of them: it checks
-     every level against the format table, and rejects a chain that is neither one level nor all of
-     them. A reader that re-derived either would be a second opinion able to disagree with the
-     uploader's.
-    */
-    return new ShadeTexelData(format, pixel_width, pixel_height, Math.max(pixel_depth, 1), levels);
-}
-
-/**
- * @param {ByteCursor} cursor positioned at the start of the file
- * @throws {Error} for anything that is not a KTX2 file
- */
-function read_identifier(cursor) {
-    if (cursor.remaining < KTX2_IDENTIFIER.length) {
-        throw new Error(
-            `KTX2: a ${cursor.remaining} byte input is too short to hold the 12 byte identifier`
-        );
-    }
-
-    const identifier = cursor.view_bytes(KTX2_IDENTIFIER.length);
-
-    if (!isArrayEqualStrict(identifier, KTX2_IDENTIFIER)) {
-        const found = Array.from(identifier, byte => byte.toString(16).padStart(2, "0")).join(" ");
-
-        throw new Error(
-            `KTX2: identifier mismatch. Expected AB 4B 54 58 20 32 30 BB 0D 0A 1A 0A, found ${found}.`
-            + ` This is not a KTX2 file — a KTX1 file starts AB 4B 54 58 20 31 31 BB.`
-        );
-    }
-}
-
-/**
- * @param {SupercompressionScheme|number} scheme
- * @throws {Error} for every scheme but {@link SupercompressionScheme.None} and
- * {@link SupercompressionScheme.ZLIB}
- */
-function refuse_unsupported_supercompression(scheme) {
-    if (scheme === SupercompressionScheme.None || scheme === SupercompressionScheme.ZLIB) {
-        return;
-    }
-
-    if (scheme === SupercompressionScheme.BasisLZ) {
-        throw new Error(
-            `KTX2: BasisLZ supercompression (scheme ${SupercompressionScheme.BasisLZ}) is not`
-            + ` supported. It is not a wrapper around device-format texels but an ETC1S encoding with`
-            + ` its own codebooks in the supercompression global data, so reading it needs the Basis`
-            + ` transcoder rather than a decompressor.`
-        );
-    }
-
-    if (scheme === SupercompressionScheme.Zstandard) {
-        throw new Error(
-            `KTX2: Zstandard supercompression (scheme ${SupercompressionScheme.Zstandard}) is not`
-            + ` supported. There is no Zstandard decompressor in this repository; re-package the file`
-            + ` with ZLIB supercompression or with none.`
-        );
-    }
-
-    throw new Error(
-        `KTX2: supercompressionScheme ${scheme} is not one this reader knows — the specification`
-        + ` defines 0 (None), 1 (BasisLZ), 2 (Zstandard) and 3 (ZLIB). A file from a later revision`
-        + ` cannot be read by guessing what its levels contain.`
-    );
-}
-
-/**
- * The `GPUTextureFormat` a file's payload is already in.
- *
- * @param {ByteCursor} cursor
- * @param {number} vk_format
- * @param {number} dfd_byte_offset
- * @param {number} dfd_byte_length
- * @returns {TextureFormat}
- * @throws {Error} naming the encoding, for a payload that is not in a device format
- */
-function texture_format_of(cursor, vk_format, dfd_byte_offset, dfd_byte_length) {
-    if (vk_format !== VK_FORMAT_UNDEFINED) {
-        return vk_format_to_texture_format(vk_format);
-    }
-
-    /*
-     `VK_FORMAT_UNDEFINED` is not "no format". It is how a Basis Universal payload is spelled, and
-     the Data Format Descriptor's colour model is the only field that says which of the two encodings
-     it holds. Reading it costs one byte and turns "vkFormat 0" — which says nothing — into the name
-     of the transcoder the file needs.
-    */
-    const color_model = read_dfd_color_model(cursor, dfd_byte_offset, dfd_byte_length);
-
-    if (color_model === KhrDfModel.ETC1S || color_model === KhrDfModel.UASTC) {
-        throw new Error(
-            `KTX2: the payload is Basis Universal ${khr_df_model_name(color_model)}, which is`
-            + ` transcoded to a device format rather than sampled directly. The Basis transcoder is`
-            + ` not implemented; a file already in a device format needs none.`
-        );
-    }
-
-    throw new Error(
-        `KTX2: vkFormat is VK_FORMAT_UNDEFINED, so the payload's encoding is whatever the Data Format`
-        + ` Descriptor says — and it says ${color_model === undefined
-            ? "nothing this reader could read"
-            : khr_df_model_name(color_model)}.`
-        + ` Only ETC1S and UASTC use an undefined vkFormat, and neither is supported.`
-    );
-}
-
-/**
- * @param {ByteCursor} cursor
- * @param {number} byte_offset of the DFD section, `0` when there is none
- * @param {number} byte_length
- * @returns {KhrDfModel|number|undefined} `undefined` when the file has no DFD, or one too short to
- * hold a basic descriptor block's colour model
- */
-function read_dfd_color_model(cursor, byte_offset, byte_length) {
-    if (byte_offset === 0 || byte_length <= DFD_COLOR_MODEL_OFFSET) {
-        return undefined;
-    }
-
-    if (byte_offset + DFD_COLOR_MODEL_OFFSET >= cursor.end) {
-        return undefined;
-    }
-
-    cursor.seek(byte_offset + DFD_COLOR_MODEL_OFFSET);
-
-    return cursor.u8();
-}
-
-/**
- * @param {number} pixel_width
- * @param {number} pixel_height
- * @param {number} pixel_depth
- * @param {number} layer_count `0` for a texture that is not an array
- * @param {number} face_count `1`, or `6` for a cube map
- * @param {TextureFormat} format
- * @throws {Error} for a shape {@link ShadeTexelData} cannot describe
- */
-function refuse_unsupported_shape(
-    pixel_width, pixel_height, pixel_depth, layer_count, face_count, format
-) {
-    if (pixel_width === 0) {
-        throw new Error("KTX2: pixelWidth is 0, which no texture has");
-    }
-
-    if (pixel_height === 0) {
-        throw new Error(
-            "KTX2: pixelHeight is 0, which is a 1D texture. ShadeTexelData describes 2D and 3D"
-            + " payloads only, and nothing in the engine samples a 1D texture."
-        );
-    }
-
-    if (layer_count > 0) {
-        throw new Error(
-            `KTX2: layerCount is ${layer_count}, which is an array texture. ShadeTexelData reads its`
-            + ` depth as a 3D volume — every level halves it — so an array's layers cannot be`
-            + ` expressed by it without changing what a level's byte length means.`
-        );
-    }
-
-    if (face_count === 6) {
-        throw new Error(
-            "KTX2: faceCount is 6, which is a cube map. ShadeTexelData models a single 2D or 3D"
-            + " image; the six faces have nowhere to go."
-        );
-    }
-
-    if (face_count !== 1) {
-        throw new Error(`KTX2: faceCount is ${face_count}, which is neither 1 nor 6`);
-    }
-
-    if (pixel_depth > 0 && gpu_texture_format_is_block_compressed(format)) {
-        /*
-         Sampling a block-compressed 3D texture needs `texture-compression-bc-sliced-3d` or its ASTC
-         counterpart, neither of which the renderer requests, and the block layout of a 3D level is
-         not the 2D one repeated per slice for every format. Refusing beats producing a payload whose
-         byte lengths happen to add up.
-        */
-        throw new Error(
-            `KTX2: pixelDepth is ${pixel_depth} and the format is '${format}', which is`
-            + ` block-compressed. A 3D block-compressed texture needs a sliced-3d device feature that`
-            + ` the renderer does not request.`
-        );
-    }
-}
-
-/**
- * Refuse a file whose metadata says its texels are arranged in a way nothing here rearranges.
- *
- * Both keys are cheap to read and expensive to ignore: a flipped orientation renders the texture
- * upside down and a non-identity swizzle renders it in the wrong channels, and neither failure looks
- * like a bug in the reader.
- *
- * @param {ByteCursor} cursor
- * @param {number} kvd_byte_offset `0` when the file carries no key/value data
- * @param {number} kvd_byte_length
- * @param {number} pixel_depth
- * @throws {Error} naming the key and its value
- */
-function refuse_unsupported_metadata(cursor, kvd_byte_offset, kvd_byte_length, pixel_depth) {
-    if (kvd_byte_offset === 0 || kvd_byte_length === 0) {
-        // absent means the default, which is the orientation and swizzle this reader wants
-        return;
-    }
-
-    const key_values = read_key_values(cursor, kvd_byte_offset, kvd_byte_length);
-
-    const orientation = key_values.get("KTXorientation");
-
-    if (orientation !== undefined) {
-        const axes = pixel_depth > 0 ? 3 : 2;
-        const expected = SUPPORTED_ORIENTATION.slice(0, axes);
-
-        if (orientation.slice(0, axes) !== expected) {
-            throw new Error(
-                `KTX2: KTXorientation is '${orientation}', and only '${expected}' is supported —`
-                + ` a top-left origin with rows running down, which is the arrangement`
-                + ` queue.writeTexture takes. Flipping the payload would mean re-encoding every`
-                + ` block, which is the encoder's job.`
-            );
-        }
-    }
-
-    const swizzle = key_values.get("KTXswizzle");
-
-    if (swizzle !== undefined && swizzle !== "rgba") {
-        throw new Error(
-            `KTX2: KTXswizzle is '${swizzle}', and only the identity 'rgba' is supported. Applying a`
-            + ` swizzle means rewriting the texels, which for a block format means re-encoding them.`
-        );
-    }
-}
-
-/**
- * The file's key/value data, as strings.
- *
- * Every value KTX2 defines is a NUL-terminated string, and a value this reader does not recognise is
- * never looked at, so decoding them all as text costs nothing and keeps the caller simple. A value
- * that is genuinely binary decodes to nonsense and is ignored, which is what an unrecognised key
- * gets either way.
- *
- * @param {ByteCursor} cursor
- * @param {number} byte_offset
- * @param {number} byte_length
- * @returns {Map<string, string>}
- * @throws {Error} for a section that runs past the end of the file, or an entry that runs past the
- * end of the section
- */
-function read_key_values(cursor, byte_offset, byte_length) {
-    if (byte_offset + byte_length > cursor.end) {
-        throw new Error(
-            `KTX2: the key/value section [${byte_offset}, ${byte_offset + byte_length}) runs past`
-            + ` the end of a ${cursor.end} byte file`
-        );
-    }
-
-    const section = cursor.sub_cursor(byte_offset, byte_length);
-
-    const result = new Map();
-
-    // four bytes is the smallest an entry's length field can be; a shorter tail is the padding of
-    // the last entry rather than the start of another one
-    while (section.remaining >= 4) {
-        const entry_byte_length = section.u32();
-
-        const entry_start = section.position;
-
-        if (entry_byte_length > section.remaining) {
-            throw new Error(
-                `KTX2: a key/value entry declares ${entry_byte_length} bytes with only`
-                + ` ${section.remaining} left in the section`
-            );
-        }
-
-        // the key is NUL-terminated and the value is whatever follows it, to the entry's end
-        const key = section.utf8_string();
-
-        const key_bytes = section.position - entry_start;
-
-        if (key_bytes > entry_byte_length) {
-            throw new Error(
-                `KTX2: the key/value entry '${key}' has no NUL terminator inside its own`
-                + ` ${entry_byte_length} bytes`
-            );
-        }
-
-        const value_bytes = section.view_bytes(entry_byte_length - key_bytes);
-
-        result.set(key, decode_key_value(value_bytes));
-
-        // entries are padded to a four byte boundary, and the padding is not part of the value
-        section.skip(Math.min((4 - (entry_byte_length % 4)) % 4, section.remaining));
-    }
-
-    return result;
-}
-
-/**
- * @param {Uint8Array} bytes
- * @returns {string} the value, without the NUL that terminates it
- */
-function decode_key_value(bytes) {
-    const end = bytes.indexOf(0);
-
-    return utf8_decode(bytes, 0, end === -1 ? bytes.length : end);
-}
-
-/**
- * @typedef {Object} Ktx2LevelIndexEntry
- * @property {number} byte_offset where this level's bytes are, from the start of the file
- * @property {number} byte_length how many of them there are, supercompressed
- * @property {number} uncompressed_byte_length how many there are after inflation
- */
-
-/**
- * @param {ByteCursor} cursor positioned at the start of the level index
- * @param {number} entry_count `levelCount`, or `1` when that is zero
- * @returns {Ktx2LevelIndexEntry[]} index 0 first, which is the base level
- * @throws {Error} for an index that runs past the end of the file
- */
-function read_level_index(cursor, entry_count) {
-    cursor.require(entry_count * LEVEL_INDEX_ENTRY_BYTES, `level index of ${entry_count} levels`);
-
-    const entries = [];
-
-    for (let i = 0; i < entry_count; i++) {
-        entries.push({
-            byte_offset: cursor.u64(),
-            byte_length: cursor.u64(),
-            uncompressed_byte_length: cursor.u64(),
-        });
-    }
-
-    return entries;
-}
-
-/**
- * One level's texel bytes, inflated if the file supercompressed them.
- *
- * @param {ByteCursor} cursor
- * @param {Ktx2LevelIndexEntry} entry
- * @param {number} level `0` is the base
- * @param {SupercompressionScheme|number} scheme already known to be one of the two supported ones
- * @returns {Uint8Array} a view onto the file where the scheme is `None`, its own memory otherwise
- * @throws {Error} naming the level, for one that runs past the end of the file or inflates to the
- * wrong size
- */
-function read_level(cursor, entry, level, scheme) {
-    const { byte_offset, byte_length, uncompressed_byte_length } = entry;
-
-    /*
-     Checked here rather than left to the cursor because the cursor's message names a byte range and
-     this one names the level, which is the difference between a file that is truncated and a level
-     index that points somewhere it should not.
-    */
-    if (byte_offset + byte_length > cursor.end) {
-        throw new Error(
-            `KTX2: level ${level} claims bytes [${byte_offset}, ${byte_offset + byte_length}) of a`
-            + ` ${cursor.end} byte file, which is past its end`
-        );
-    }
-
-    cursor.seek(byte_offset);
-
-    const stored = cursor.view_bytes(byte_length);
-
-    if (scheme === SupercompressionScheme.None) {
-        /*
-         A view, not a copy. The level data is nearly the whole of a texture file, and `writeTexture`
-         takes a view as readily as it takes its own array — copying here would double the peak
-         memory of every texture load to no end.
-        */
-        return stored;
-    }
-
-    /*
-     `pako.inflate` rather than `png_inflate`: what that function adds over this call is PNG's two
-     peculiarities — a stream split across IDAT chunks, and a fallback that abandons the adler32
-     check because real encoders get it wrong. A KTX2 level is one stream, and a texture payload
-     whose checksum fails should fail rather than decode to blocks nobody verified.
-
-     What it also adds, and what this has to do for itself: **pako throws a bare string.** Not an
-     Error — `"incorrect header check"`, with no stack, no `.message`, and nothing saying which file
-     or which level it came from. Letting that escape would make the one path this reader adds beyond
-     the plan the one path that does not refuse by name.
-    */
-    let inflated;
-
-    try {
-        inflated = pako.inflate(stored);
-    } catch (error) {
-        throw new Error(
-            `KTX2: level ${level} is not a readable zlib stream: ${error?.message ?? error}`
-        );
-    }
-
-    if (uncompressed_byte_length !== inflated.byteLength) {
-        throw new Error(
-            `KTX2: level ${level} declares an uncompressedByteLength of ${uncompressed_byte_length}`
-            + ` but inflates to ${inflated.byteLength} bytes`
-        );
-    }
-
-    return inflated;
-}

package/src/ktx2/ktx2_read_basis_lz_global_data.d.ts

@@ -1,27 +0,0 @@
-/**
- * Read the BasisLZ supercompression global data.
- *
- * This is the codebook every image in the file shares — endpoints, selectors and Huffman tables —
- * plus one descriptor per image saying where that image's slices sit inside its mip level. The
- * structure is the *container's*, defined by KTX2 rather than by Basis; what is inside the four
- * sections is the codec's, and is decoded by the transcoder.
- *
- * **Slice offsets are relative to their own mip level**, not to the file, which is why the level
- * bytes are passed in already located rather than the file being re-walked here.
- *
- * @param {ArrayBuffer|Uint8Array} bytes the whole file
- * @param {number} byte_offset of the global data section, from `sgdByteOffset`
- * @param {number} byte_length from `sgdByteLength`
- * @param {number} image_count one per level, for the 2D non-array textures this reader accepts
- * @param {Uint8Array[]} level_bytes one per level, base first, as located by the level index
- * @param {boolean} has_alpha whether the file's images carry a second slice, from the descriptor
- * @returns {import("../basis/transcode_basis.js").BasisEtc1sPayload} without its dimensions, which
- * the caller holds
- * @throws {Error} naming the field, for global data that is truncated or disagrees with itself
- *
- * @see the KTX2 specification, Appendix C
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function ktx2_read_basis_lz_global_data(bytes: ArrayBuffer | Uint8Array, byte_offset: number, byte_length: number, image_count: number, level_bytes: Uint8Array[], has_alpha: boolean): any;
-//# sourceMappingURL=ktx2_read_basis_lz_global_data.d.ts.map

package/src/ktx2/ktx2_read_basis_lz_global_data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ktx2_read_basis_lz_global_data.d.ts","sourceRoot":"","sources":["../../../src/ktx2/ktx2_read_basis_lz_global_data.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,sDAdW,WAAW,GAAC,UAAU,eACtB,MAAM,eACN,MAAM,eACN,MAAM,eACN,UAAU,EAAE,aACZ,OAAO,OA+GjB"}