@woosh/meep-engine 3.14.2 → 3.14.3

package/src/shade/renderer/loader/gltf/coalesce_array_duplicates.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"coalesce_array_duplicates.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/coalesce_array_duplicates.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,mDAFW;IAAC,MAAM,CAAC,GAAG,OAAO,CAAC;IAAC,IAAI,CAAC,QAAY,MAAM,CAAA;CAAC,EAAE,QAiDxD"}

package/src/shade/renderer/loader/gltf/ext/GltfBufferViewExtension.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GltfBufferViewExtension.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/loader/gltf/ext/GltfBufferViewExtension.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;;;;;;;;OAaG;IACH,kBAPW,MAAM,eACN,MAAM,WACN,UAAU,EAAE,SACZ,MAAM,GACJ,UAAU,CAKtB;IAED;;;;;;;;;OASG;IACH,8BAHW,MAAM,GACJ,OAAO,CAInB;CACJ"}

package/src/shade/renderer/loader/gltf/ext/GltfBufferViewExtensionSet.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GltfBufferViewExtensionSet.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/loader/gltf/ext/GltfBufferViewExtensionSet.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH;IAMI;;OAEG;IACH,yBAFW,uBAAuB,EAAE,EAMnC;IAED;;OAEG;IACH,eAFW,uBAAuB,QAQjC;IAED;;OAEG;IACH,sBAEC;IAED;;;;;;;;;;;;OAYG;IACH;;eALW,MAAM,GACJ,uBAAuB,GAAC,IAAI,CAgCxC;IAED;;;;;OAKG;IACH,8BAHW,MAAM,GACJ,OAAO,CAcnB;;CACJ;wCA3GuC,8BAA8B"}

package/src/shade/renderer/loader/gltf/ext/GltfBufferViewExtensionSet.js

@@ -1,109 +0,0 @@
-import { assert } from "../../../../../core/assert.js";
-import { GltfBufferViewExtension } from "./GltfBufferViewExtension.js";
-
-/**
- * The bufferView extensions a parser knows how to honour.
- *
- * A glTF names its extensions by string, so this is keyed by string - it is modelling the format,
- * not saving boilerplate. What it holds are typed {@link GltfBufferViewExtension} objects, and the
- * only thing it does with them is answer "which of you claims this?".
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class GltfBufferViewExtensionSet {
-    /**
-     * @type {Map<string, GltfBufferViewExtension>}
-     */
-    #by_name = new Map();
-
-    /**
-     * @param {GltfBufferViewExtension[]} [extensions]
-     */
-    constructor(extensions = []) {
-        for (const extension of extensions) {
-            this.add(extension);
-        }
-    }
-
-    /**
-     * @param {GltfBufferViewExtension} extension
-     */
-    add(extension) {
-        assert.isInstanceOf(extension, GltfBufferViewExtension, 'extension');
-        assert.notEqual(extension.name, "", 'extension.name');
-        assert.notOk(this.#by_name.has(extension.name), `'${extension.name}' is already registered`);
-
-        this.#by_name.set(extension.name, extension);
-    }
-
-    /**
-     * @returns {string[]} every name this set answers to
-     */
-    get names() {
-        return Array.from(this.#by_name.keys());
-    }
-
-    /**
-     * Which extension produces this bufferView's bytes, if any.
-     *
-     * Two of them claiming the same view is a file that cannot be read whichever way you look at it:
-     * both would have to produce the same bytes, and nothing says which wins. That is a property of
-     * the collision rather than of either extension, so it is refused here.
-     *
-     * @param {{extensions?:Object}} buffer_view
-     * @param {number} [index] for the message
-     * @returns {GltfBufferViewExtension|null} `null` for a view nothing claims, which is nearly all
-     *   of them - a file that has never heard of any of these costs one lookup per registered name
-     * @throws {Error} if more than one registered extension claims it
-     */
-    claim(buffer_view, index = -1) {
-        const extensions = buffer_view.extensions;
-
-        if (extensions === undefined) {
-            return null;
-        }
-
-        /**
-         * @type {GltfBufferViewExtension|null}
-         */
-        let claimed = null;
-
-        for (const [name, extension] of this.#by_name) {
-            if (extensions[name] === undefined) {
-                continue;
-            }
-
-            if (claimed !== null) {
-                throw new Error(
-                    `bufferViews[${index}] is claimed by both '${claimed.name}' and '${name}',`
-                    + ` and they cannot both describe the same bytes`
-                );
-            }
-
-            claimed = extension;
-        }
-
-        return claimed;
-    }
-
-    /**
-     * Whether any registered extension marks this buffer as one the file never wrote.
-     *
-     * @param {object} buffer an entry of `json.buffers`
-     * @returns {boolean}
-     */
-    is_placeholder_buffer(buffer) {
-        if (buffer.extensions === undefined) {
-            return false;
-        }
-
-        for (const extension of this.#by_name.values()) {
-            if (extension.is_placeholder_buffer(buffer)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-}

package/src/shade/renderer/loader/gltf/ext/gltf_apply_buffer_view_extensions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf_apply_buffer_view_extensions.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/loader/gltf/ext/gltf_apply_buffer_view_extensions.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,gEATW,MAAM,EAAE,WACR,UAAU,EAAE,cACZ,0BAA0B,GACxB,MAAM,EAAE,CA8CpB;2CApE0C,iCAAiC"}

package/src/shade/renderer/loader/gltf/ext/gltf_buffer_view_extensions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf_buffer_view_extensions.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/loader/gltf/ext/gltf_buffer_view_extensions.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,0CALU,0BAA0B,CAQjC;2CArBwC,iCAAiC"}

package/src/shade/renderer/loader/gltf/ext/gltf_geometry_extensions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf_geometry_extensions.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/loader/gltf/ext/gltf_geometry_extensions.js"],"names":[],"mappings":"AAyBA;;;;;;;;GAQG;AACH,8FAFa,MAAM,EAAE,CAMpB;AAtCD;;;;;;;;;;;;;GAaG;AAEH;;;GAGG;AACH,uCAFU,MAAM,EAAE,CAMhB"}

package/src/shade/renderer/loader/gltf/ext/meshopt/MeshoptBufferViewExtension.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MeshoptBufferViewExtension.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/loader/gltf/ext/meshopt/MeshoptBufferViewExtension.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;GAaG;AACH;IAkBI;;;;;OAKG;IACH;QAJ2B,IAAI,EAApB,MAAM;QACY,OAAO,EAAzB,MAAM,EAAE;QACwB,eAAe;gBAAxC,MAAM,GAAE,MAAM;;OAS/B;;CAuJJ;AAED;;;GAGG;AACH,sCAFU,0BAA0B,CAMjC;AAEH;;;;GAIG;AACH,sCAFU,0BAA0B,CAMjC;wCAzSqC,+BAA+B"}

package/src/shade/renderer/loader/gltf/ext/meshopt/MeshoptBufferViewExtension.js

@@ -1,301 +0,0 @@
-import { MeshoptCompressionFilter } from "../../../../../../core/binary/meshopt/MeshoptCompressionFilter.js";
-import { MeshoptCompressionMode } from "../../../../../../core/binary/meshopt/MeshoptCompressionMode.js";
-import { meshopt_decode } from "../../../../../../core/binary/meshopt/meshopt_decode.js";
-import { GltfBufferViewExtension } from "../GltfBufferViewExtension.js";
-
-/**
- * The three compression modes, and what each demands of the layout it decodes into.
- *
- * This is the specification's own table of constraints, written as one. The alternative is a run of
- * `if (mode === ...)` down the validator, which is the same information with the shape taken out of
- * it - and which grows a branch every time a mode is added.
- *
- * @type {Object<string, {id:number, accepts_stride:function(number):boolean, stride_rule:string, accepts_count:function(number):boolean, count_rule:string, filtered:boolean}>}
- */
-const MODES = {
-    ATTRIBUTES: {
-        id: MeshoptCompressionMode.Attributes,
-        accepts_stride: (stride) => stride % 4 === 0 && stride >= 4 && stride <= 256,
-        stride_rule: 'divisible by 4, at least 4 and at most 256',
-        accepts_count: () => true,
-        count_rule: 'any',
-        filtered: true
-    },
-    TRIANGLES: {
-        id: MeshoptCompressionMode.Triangles,
-        accepts_stride: (stride) => stride === 2 || stride === 4,
-        stride_rule: '2 or 4',
-        accepts_count: (count) => count % 3 === 0,
-        count_rule: 'divisible by 3',
-        filtered: false
-    },
-    INDICES: {
-        id: MeshoptCompressionMode.Indices,
-        accepts_stride: (stride) => stride === 2 || stride === 4,
-        stride_rule: '2 or 4',
-        accepts_count: () => true,
-        count_rule: 'any',
-        filtered: false
-    }
-};
-
-/**
- * The five filters, and the strides each is defined for. Which of them a given extension actually
- * *has* is that extension's business - see {@link MeshoptBufferViewExtension}.
- *
- * @type {Object<string, {id:number, accepts_stride:function(number):boolean, stride_rule:string}>}
- */
-const FILTERS = {
-    NONE: {
-        id: MeshoptCompressionFilter.None,
-        accepts_stride: () => true,
-        stride_rule: 'any'
-    },
-    OCTAHEDRAL: {
-        id: MeshoptCompressionFilter.Octahedral,
-        accepts_stride: (stride) => stride === 4 || stride === 8,
-        stride_rule: '4 or 8'
-    },
-    QUATERNION: {
-        id: MeshoptCompressionFilter.Quaternion,
-        accepts_stride: (stride) => stride === 8,
-        stride_rule: '8'
-    },
-    EXPONENTIAL: {
-        id: MeshoptCompressionFilter.Exponential,
-        accepts_stride: (stride) => stride % 4 === 0,
-        stride_rule: 'divisible by 4'
-    },
-    COLOR: {
-        id: MeshoptCompressionFilter.Color,
-        accepts_stride: (stride) => stride === 4 || stride === 8,
-        stride_rule: '4 or 8'
-    }
-};
-
-/**
- * @param {*} value
- * @returns {boolean}
- */
-function is_index(value) {
-    return Number.isInteger(value) && value >= 0;
-}
-
-/**
- * A meshopt-compressed bufferView, under whichever of the two names carries it.
- *
- * The codec beneath this decodes everything the two extensions can express between them and reports
- * what it found. What each *name* is allowed to express is this object's two fields, and that is the
- * whole of the difference between the vendor extension and the Khronos one: which filters exist, and
- * how new an attribute stream may be.
- *
- * @see https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Vendor/EXT_meshopt_compression
- * @see https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_meshopt_compression
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class MeshoptBufferViewExtension extends GltfBufferViewExtension {
-    /**
-     * The filter names this extension defines. A filter outside it is not "unsupported"; it is not
-     * part of this extension, and a file using one has named the wrong extension.
-     * @type {Set<string>}
-     */
-    #filters;
-
-    /**
-     * The newest codec version each mode may carry, by mode name.
-     *
-     * Not one number: the two index codecs' version 1 is legal under both extensions, while the
-     * attribute codec's is what the Khronos extension exists to add.
-     *
-     * @type {Object<string, number>}
-     */
-    #version_ceiling;
-
-    /**
-     * @param {Object} options
-     * @param {string} options.name
-     * @param {string[]} options.filters
-     * @param {Object<string, number>} options.version_ceiling by mode name
-     */
-    constructor({ name, filters, version_ceiling }) {
-        super();
-
-        this.name = name;
-
-        this.#filters = new Set(filters);
-        this.#version_ceiling = version_ceiling;
-    }
-
-    /**
-     * @param {object} buffer
-     * @returns {boolean}
-     */
-    is_placeholder_buffer(buffer) {
-        return buffer.extensions?.[this.name]?.fallback === true;
-    }
-
-    /**
-     * @param {object} extension
-     * @param {object} buffer_view
-     * @param {Uint8Array[]} buffers
-     * @param {number} index
-     * @returns {Uint8Array}
-     */
-    decode(extension, buffer_view, buffers, index) {
-        const where = `bufferViews[${index}].extensions.${this.name}`;
-
-        const layout = this.#read_layout(extension, buffer_view, where);
-        const source = this.#read_source(extension, buffers, where);
-
-        const decoded = new Uint8Array(layout.byte_stride * layout.count);
-
-        const version = meshopt_decode(
-            decoded,
-            layout.count, layout.byte_stride,
-            layout.mode.id, layout.filter.id,
-            source
-        );
-
-        const ceiling = this.#version_ceiling[layout.mode_name];
-
-        if (version > ceiling) {
-            throw new Error(
-                `${where} is a ${layout.mode_name} stream of codec version ${version}, and`
-                + ` ${this.name} defines up to version ${ceiling}`
-            );
-        }
-
-        return decoded;
-    }
-
-    /**
-     * Everything the extension object says about the bytes, checked against everything its
-     * specification says must hold.
-     *
-     * @param {object} extension
-     * @param {object} buffer_view
-     * @param {string} where
-     * @returns {{mode_name:string, mode:object, filter_name:string, filter:object, count:number, byte_stride:number}}
-     */
-    #read_layout(extension, buffer_view, where) {
-        const mode_name = extension.mode;
-        const mode = MODES[mode_name];
-
-        if (mode === undefined) {
-            throw new Error(`${where}.mode is '${mode_name}', which is not a compression mode`);
-        }
-
-        const filter_name = extension.filter ?? 'NONE';
-
-        if (!this.#filters.has(filter_name)) {
-            throw new Error(`${where}.filter is '${filter_name}', which ${this.name} does not define`);
-        }
-
-        const filter = FILTERS[filter_name];
-
-        const count = extension.count;
-        const byte_stride = extension.byteStride;
-
-        if (!is_index(count)) {
-            throw new Error(`${where}.count is ${count}, which is not a number of elements`);
-        }
-
-        if (!Number.isInteger(byte_stride) || byte_stride <= 0) {
-            throw new Error(`${where}.byteStride is ${byte_stride}, which is not a stride`);
-        }
-
-        if (!mode.accepts_stride(byte_stride)) {
-            throw new Error(
-                `${where}.byteStride is ${byte_stride}; ${mode_name} strides are ${mode.stride_rule}`
-            );
-        }
-
-        if (!mode.accepts_count(count)) {
-            throw new Error(`${where}.count is ${count}; ${mode_name} counts are ${mode.count_rule}`);
-        }
-
-        if (!mode.filtered && filter.id !== MeshoptCompressionFilter.None) {
-            throw new Error(`${where}.filter is '${filter_name}', and ${mode_name} takes no filter`);
-        }
-
-        if (!filter.accepts_stride(byte_stride)) {
-            throw new Error(
-                `${where}.byteStride is ${byte_stride}; ${filter_name} strides are ${filter.stride_rule}`
-            );
-        }
-
-        if (buffer_view.byteStride !== undefined && buffer_view.byteStride !== byte_stride) {
-            throw new Error(
-                `${where}.byteStride is ${byte_stride}, but the bufferView it fills declares`
-                + ` ${buffer_view.byteStride}`
-            );
-        }
-
-        if (buffer_view.byteLength !== byte_stride * count) {
-            throw new Error(
-                `${where} decodes to ${byte_stride * count} bytes, but the bufferView it fills is`
-                + ` ${buffer_view.byteLength}`
-            );
-        }
-
-        return { mode_name, mode, filter_name, filter, count, byte_stride };
-    }
-
-    /**
-     * The compressed bytes the extension points at.
-     *
-     * @param {object} extension
-     * @param {Uint8Array[]} buffers
-     * @param {string} where
-     * @returns {Uint8Array}
-     */
-    #read_source(extension, buffers, where) {
-        if (!is_index(extension.buffer)) {
-            throw new Error(`${where}.buffer is ${extension.buffer}, which is not a buffer index`);
-        }
-
-        if (!Number.isInteger(extension.byteLength) || extension.byteLength <= 0) {
-            throw new Error(`${where}.byteLength is ${extension.byteLength}, which is not a length`);
-        }
-
-        const buffer = buffers[extension.buffer];
-
-        if (buffer === undefined) {
-            throw new Error(`${where}.buffer is ${extension.buffer}, which no buffer resolved to`);
-        }
-
-        const byte_offset = extension.byteOffset ?? 0;
-
-        if (!is_index(byte_offset) || byte_offset + extension.byteLength > buffer.byteLength) {
-            throw new Error(
-                `${where} reads ${extension.byteLength} bytes at ${byte_offset} of a`
-                + ` ${buffer.byteLength} byte buffer`
-            );
-        }
-
-        return buffer.subarray(byte_offset, byte_offset + extension.byteLength);
-    }
-}
-
-/**
- * The vendor extension, ratified first: four filters, and the attribute codec pinned at version 0.
- * @type {MeshoptBufferViewExtension}
- */
-export const EXT_MESHOPT_COMPRESSION = new MeshoptBufferViewExtension({
-    name: 'EXT_meshopt_compression',
-    filters: ['NONE', 'OCTAHEDRAL', 'QUATERNION', 'EXPONENTIAL'],
-    version_ceiling: { ATTRIBUTES: 0, TRIANGLES: 1, INDICES: 1 }
-});
-
-/**
- * The Khronos extension derived from it. Same JSON, same modes, same fallback buffers; what it adds
- * is the colour filter and the attribute codec's version 1.
- * @type {MeshoptBufferViewExtension}
- */
-export const KHR_MESHOPT_COMPRESSION = new MeshoptBufferViewExtension({
-    name: 'KHR_meshopt_compression',
-    filters: ['NONE', 'OCTAHEDRAL', 'QUATERNION', 'EXPONENTIAL', 'COLOR'],
-    version_ceiling: { ATTRIBUTES: 1, TRIANGLES: 1, INDICES: 1 }
-});

package/src/shade/renderer/loader/gltf/gltf_component_type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf_component_type.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/gltf_component_type.js"],"names":[],"mappings":"AAwBA;;;;;;;;;GASG;AACH,oDAHW,MAAM,GACJ,MAAM,CAqBlB;AAED;;;;;;;;;GASG;AACH,iDAHW,MAAM,GACJ,MAAM,CAalB;AAED;;;GAGG;AACH,6DAHW,mBAAmB,GACjB,MAAM,CAgBlB;AAED;;;;;;;;;;;;GAYG;AACH,kDAJW,MAAM,kBACN,mBAAmB,GACjB,MAAM,CAclB;AAED;;;;;;;GAOG;AACH,iDAJW,MAAM,kBACN,mBAAmB,GACjB,MAAM,CAIlB;AAED;;;;GAIG;AACH,mEAJW,mBAAmB,YAqB7B;AAED;;;;;;;;;;;;GAYG;AACH,0CANW,QAAQ,UACR,MAAM,kBACN,mBAAmB,GACjB,MAAM,CAoBlB;AAED;;;;;;;GAOG;AACH,wDAHW,mBAAmB,GACjB,MAAM,CAelB;AAED;;;GAGG;AACH,8DAHW,mBAAmB,GACjB,OAAO,CAInB;kCAjNS,MAAM"}

package/src/shade/renderer/loader/gltf/gltf_node_world_matrices.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf_node_world_matrices.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/gltf_node_world_matrices.js"],"names":[],"mappings":"AAsBA;;;;;;GAMG;AACH,+CAJW,YAAY,QACZ;IAAC,MAAM,CAAC,EAAC,MAAM,EAAE,CAAC;IAAC,WAAW,CAAC,EAAC,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAC,MAAM,EAAE,CAAC;IAAC,KAAK,CAAC,EAAC,MAAM,EAAE,CAAA;CAAC,GAC5E,YAAY,CAexB;AAED;;;;;;;;;;GAUG;AACH;YAHmB,MAAM,EAAE;;gBAAkB,MAAM,EAAE;;IACxC,YAAY,EAAE,CAyC1B;AAED;;;;;;;;;GASG;AACH;YAHmB,MAAM,EAAE;;gBAAkB,MAAM,EAAE;;IACxC,IAAI,MAAM,CAAC,CAgCvB"}

package/src/shade/renderer/loader/gltf/gltf_node_world_matrices.js

@@ -1,137 +0,0 @@
-import { M4_IDENTITY } from "../../../../core/geom/3d/mat4/M4_IDENTITY.js";
-import { m4_allocate } from "../../../../core/geom/3d/mat4/m4_allocate.js";
-import {
-    m4_from_rotation_translation_scale
-} from "../../../../core/geom/3d/mat4/m4_from_rotation_translation_scale.js";
-import { m4_multiply } from "../../../../core/geom/3d/mat4/m4_multiply.js";
-
-/**
- * Where a glTF's nodes end up, once the scene graph above each one is taken into account.
- *
- * A node's own transform is authored either as a matrix or as a translation/rotation/scale triple,
- * and its world transform is that composed with its parent's. Which is the whole of the scene graph:
- * everything else a node carries — a mesh, a camera, a light — is placed by this and nothing more.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-const DEFAULT_TRANSLATION = [0, 0, 0];
-const DEFAULT_ROTATION = [0, 0, 0, 1];
-const DEFAULT_SCALE = [1, 1, 1];
-
-/**
- * The transform a node authors for itself, before its parent is taken into account.
- *
- * @param {Float32Array} result 4x4, column-major
- * @param {{matrix?:number[], translation?:number[], rotation?:number[], scale?:number[]}} node
- * @returns {Float32Array} `result`
- */
-export function gltf_node_local_matrix(result, node) {
-    if (node.matrix !== undefined) {
-        result.set(node.matrix);
-
-        return result;
-    }
-
-    return m4_from_rotation_translation_scale(
-        result,
-        node.rotation ?? DEFAULT_ROTATION,
-        node.translation ?? DEFAULT_TRANSLATION,
-        node.scale ?? DEFAULT_SCALE
-    );
-}
-
-/**
- * Every node's world transform, indexed as `gltf.nodes` is.
- *
- * A node reached twice keeps the transform of its first visit, and is not descended into a second
- * time. The format forbids a node having two parents, so this is what to do with a file that breaks
- * the rule rather than a feature — but it is also what stops a cycle from recursing forever, and it
- * is what makes the answer depend on the document rather than on the order the walk happened to take.
- *
- * @param {{nodes?:object[], scenes?:{nodes?:number[]}[]}} gltf
- * @returns {Float32Array[]} column-major 4x4 matrices, one per node
- */
-export function gltf_node_world_matrices(gltf) {
-    const nodes = gltf.nodes ?? [];
-
-    /**
-     * @type {Float32Array[]}
-     */
-    const result = new Array(nodes.length);
-
-    /*
-     Shared across the walk: every call composes its local transform and multiplies it into a world
-     matrix of its own before recursing, so a child overwriting this cannot disturb its parent.
-    */
-    const local = m4_allocate();
-
-    /**
-     * @param {number} index
-     * @param {Float32Array|number[]} parent 4x4, column-major
-     */
-    function visit(index, parent) {
-        if (result[index] !== undefined) {
-            return;
-        }
-
-        const world = m4_allocate();
-
-        m4_multiply(world, parent, gltf_node_local_matrix(local, nodes[index]));
-
-        result[index] = world;
-
-        for (const child of nodes[index].children ?? []) {
-            visit(child, world);
-        }
-    }
-
-    for (const root of gltf_root_nodes(gltf)) {
-        visit(root, M4_IDENTITY);
-    }
-
-    return result;
-}
-
-/**
- * Where the walk starts.
- *
- * The scenes name their own roots, and normally that is the answer. A container that declares no
- * scene at all still describes nodes, and treating every node nothing parents as a root is what keeps
- * that document's geometry from being silently dropped.
- *
- * @param {{nodes?:object[], scenes?:{nodes?:number[]}[]}} gltf
- * @returns {Set<number>} node indices
- */
-export function gltf_root_nodes(gltf) {
-    const roots = new Set();
-
-    for (const scene of gltf.scenes ?? []) {
-        for (const node of scene.nodes ?? []) {
-            roots.add(node);
-        }
-    }
-
-    if (roots.size > 0) {
-        return roots;
-    }
-
-    const nodes = gltf.nodes ?? [];
-
-    const parented = new Set();
-
-    for (const node of nodes) {
-        for (const child of node.children ?? []) {
-            parented.add(child);
-        }
-    }
-
-    for (let index = 0; index < nodes.length; index++) {
-        if (!parented.has(index)) {
-            roots.add(index);
-        }
-    }
-
-    return roots;
-}

package/src/shade/renderer/loader/gltf/gltf_parse_container.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf_parse_container.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/gltf_parse_container.js"],"names":[],"mappings":"AAgDA;;;GAGG;AACH,gDAHW,UAAU,GACR,OAAO,CAQnB;AAED;;;;;;GAMG;AACH,4CAJW,UAAU,GACR,aAAa,CAyDzB;AA0BD;;;;;;;;;;;GAWG;AACH,wDALoB,MAAM,QAAE,MAAM,KAAG,UAAU,eACpC,MAAM,GACJ,mBAAmB,CA6D/B;AAED;;;;;;;;GAQG;AACH,qDAHW,MAAM,QAehB;AArND;;GAEG;AACH;IACI;;;OAGG;IACH,MAFU,MAAM,CAEJ;IAEZ;;;;;;;OAOG;IACH,cAFU,UAAU,GAAC,IAAI,CAEL;CACvB;AA6ED;;GAEG;AACH;IACI;;;OAGG;IACH,MAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,qBAFU,MAAM,CAES;IAEzB;;OAEG;IACH,qBAFU,MAAM,CAEQ;CAC3B"}

package/src/shade/renderer/loader/gltf/gltf_read_accessor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf_read_accessor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/gltf_read_accessor.js"],"names":[],"mappings":"AAoMA;;;;;;GAMG;AACH,yCAJW,MAAM,kBACN,MAAM,GACJ,gBAAgB,CAoD5B;AAED;;;;;;GAMG;AACH,mDAJW,gBAAgB,GACd,YAAY,CAkCxB;AAvRD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;GAEG;AACH;IACI;;;;OAIG;IACH,mBAA6B;IAE7B;;OAEG;IACH,YAFU,MAAM,CAED;IAEf;;OAEG;IACH,gBAFU,mBAAmB,CAEc;IAE3C;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,YAFU,OAAO,CAEE;CACtB;oCA3DM,0BAA0B"}