@loaders.gl/scene 5.0.0-alpha.8 → 5.0.0-beta.1

package/dist/gltf/lib/gltf-utils/gltf-utils.cjs

@@ -0,0 +1,157 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gltf/lib/gltf-utils/gltf-utils.ts
+var gltf_utils_exports = {};
+__export(gltf_utils_exports, {
+  getAccessorArrayTypeAndLength: () => getAccessorArrayTypeAndLength,
+  getAccessorTypeFromSize: () => getAccessorTypeFromSize,
+  getComponentTypeFromArray: () => getComponentTypeFromArray,
+  getMemoryUsageGLTF: () => getMemoryUsageGLTF
+});
+module.exports = __toCommonJS(gltf_utils_exports);
+var import_assert = require("../utils/assert.cjs");
+var import_gltf_constants = require("./gltf-constants.cjs");
+var MIPMAP_FACTOR = 1.33;
+var TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
+var ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
+  [Int8Array, 5120],
+  [Uint8Array, 5121],
+  [Int16Array, 5122],
+  [Uint16Array, 5123],
+  [Int32Array, 5124],
+  [Uint32Array, 5125],
+  [Float32Array, 5126],
+  [Float64Array, 5130],
+  [BigInt64Array, 5134],
+  [BigUint64Array, 5135]
+];
+var ARRAY_TO_COMPONENT_TYPE = new Map(
+  ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT
+);
+var ATTRIBUTE_TYPE_TO_COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+var ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
+  5120: 1,
+  5121: 1,
+  5122: 2,
+  5123: 2,
+  5124: 4,
+  5125: 4,
+  5126: 4,
+  5130: 8,
+  5131: 2,
+  5134: 8,
+  5135: 8
+};
+var ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5124: Int32Array,
+  5125: Uint32Array,
+  5126: Float32Array,
+  5130: Float64Array,
+  // JavaScript does not yet provide Float16Array across supported runtimes.
+  // Preserve binary16 payloads in Uint16Array while componentType retains their semantics.
+  5131: Uint16Array,
+  5134: BigInt64Array,
+  5135: BigUint64Array
+};
+function getAccessorTypeFromSize(size) {
+  const type = TYPES[size - 1];
+  return type || TYPES[0];
+}
+function getComponentTypeFromArray(typedArray) {
+  const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);
+  if (!componentType) {
+    throw new Error("Illegal typed array");
+  }
+  return componentType;
+}
+function getAccessorArrayTypeAndLength(accessor, bufferView) {
+  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
+  const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
+  const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
+  const length = accessor.count * components;
+  const byteLength = accessor.count * components * bytesPerComponent;
+  (0, import_assert.assert)(byteLength >= 0 && byteLength <= bufferView.byteLength);
+  const componentByteSize = import_gltf_constants.BYTES[accessor.componentType];
+  const numberOfComponentsInElement = import_gltf_constants.COMPONENTS[accessor.type];
+  return { ArrayType, length, byteLength, componentByteSize, numberOfComponentsInElement };
+}
+function getMemoryUsageGLTF(gltf) {
+  const imageBufferViews = new Set((gltf.json.images || []).map((image) => image.bufferView));
+  const liveBufferViews = /* @__PURE__ */ new Set();
+  const decodedValues = /* @__PURE__ */ new Set();
+  const accessors = /* @__PURE__ */ new Set();
+  let materializedMemory = 0;
+  const addAccessorStorage = (reference) => {
+    const accessor = typeof reference === "number" ? gltf.json.accessors?.[reference] : reference;
+    if (!accessor || accessors.has(accessor)) return;
+    accessors.add(accessor);
+    const value = accessor.value;
+    if (ArrayBuffer.isView(value)) {
+      if (!decodedValues.has(value)) materializedMemory += value.byteLength;
+      decodedValues.add(value);
+    } else if (accessor.sparse || accessor.bufferView === void 0) {
+      materializedMemory += accessor.count * import_gltf_constants.BYTES[accessor.componentType] * import_gltf_constants.COMPONENTS[accessor.type];
+    } else {
+      liveBufferViews.add(accessor.bufferView);
+    }
+  };
+  for (const accessor of gltf.json.accessors || []) {
+    if (accessor.bufferView !== void 0 || accessor.sparse || "value" in accessor)
+      addAccessorStorage(accessor);
+  }
+  for (const mesh of gltf.json.meshes || []) {
+    for (const primitive of mesh.primitives) {
+      addAccessorStorage(primitive.indices);
+      for (const reference of Object.values(primitive.attributes)) addAccessorStorage(reference);
+      for (const target of primitive.targets || []) {
+        for (const reference of Object.values(target)) addAccessorStorage(reference);
+      }
+    }
+  }
+  const bufferMemory = [...liveBufferViews].reduce(
+    (total, index) => total + (imageBufferViews.has(index) ? 0 : gltf.json.bufferViews?.[index]?.byteLength || 0),
+    materializedMemory
+  );
+  const pixelCount = (gltf.images || []).reduce(
+    (total, image) => total + (image?.width || 0) * (image?.height || 0),
+    0
+  );
+  return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAccessorArrayTypeAndLength,
+  getAccessorTypeFromSize,
+  getComponentTypeFromArray,
+  getMemoryUsageGLTF
+});
+//# sourceMappingURL=gltf-utils.cjs.map

package/dist/gltf/lib/gltf-utils/gltf-utils.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/gltf/lib/gltf-utils/gltf-utils.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport {assert} from '../utils/assert';\n\nimport type {GLTFWithBuffers, GLTFAccessor} from '../types/gltf-types';\nimport {BYTES, COMPONENTS} from './gltf-constants';\n\n/**\n * Memory needed to store texture and all mipmap levels 1 + 1/4 + 1/16 + 1/64 + ...\n * Minimum 1.33, but due to GPU layout may be 1.5\n */\nconst MIPMAP_FACTOR = 1.33;\n\nconst TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];\n\ntype TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor\n  | BigInt64ArrayConstructor\n  | BigUint64ArrayConstructor;\n\nconst ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT: [TypedArrayConstructor, number][] = [\n  [Int8Array, 5120],\n  [Uint8Array, 5121],\n  [Int16Array, 5122],\n  [Uint16Array, 5123],\n  [Int32Array, 5124],\n  [Uint32Array, 5125],\n  [Float32Array, 5126],\n  [Float64Array, 5130],\n  [BigInt64Array, 5134],\n  [BigUint64Array, 5135]\n];\nconst ARRAY_TO_COMPONENT_TYPE = new Map<TypedArrayConstructor, number>(\n  ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT\n);\n\nconst ATTRIBUTE_TYPE_TO_COMPONENTS = {\n  SCALAR: 1,\n  VEC2: 2,\n  VEC3: 3,\n  VEC4: 4,\n  MAT2: 4,\n  MAT3: 9,\n  MAT4: 16\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {\n  5120: 1,\n  5121: 1,\n  5122: 2,\n  5123: 2,\n  5124: 4,\n  5125: 4,\n  5126: 4,\n  5130: 8,\n  5131: 2,\n  5134: 8,\n  5135: 8\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {\n  5120: Int8Array,\n  5121: Uint8Array,\n  5122: Int16Array,\n  5123: Uint16Array,\n  5124: Int32Array,\n  5125: Uint32Array,\n  5126: Float32Array,\n  5130: Float64Array,\n  // JavaScript does not yet provide Float16Array across supported runtimes.\n  // Preserve binary16 payloads in Uint16Array while componentType retains their semantics.\n  5131: Uint16Array,\n  5134: BigInt64Array,\n  5135: BigUint64Array\n};\n\nexport function getAccessorTypeFromSize(size) {\n  const type = TYPES[size - 1];\n  return type || TYPES[0];\n}\n\nexport function getComponentTypeFromArray(typedArray) {\n  const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);\n  if (!componentType) {\n    throw new Error('Illegal typed array');\n  }\n  return componentType;\n}\n\nexport function getAccessorArrayTypeAndLength(accessor, bufferView) {\n  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];\n  const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];\n  const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];\n  const length = accessor.count * components;\n  const byteLength = accessor.count * components * bytesPerComponent;\n  assert(byteLength >= 0 && byteLength <= bufferView.byteLength);\n  const componentByteSize = BYTES[accessor.componentType];\n  const numberOfComponentsInElement = COMPONENTS[accessor.type];\n  return {ArrayType, length, byteLength, componentByteSize, numberOfComponentsInElement};\n}\n\n/**\n * Calculate the GPU memory used by a GLTF tile, for both buffer and texture memory\n * @param gltf - the gltf content of a GLTF tile\n * @returns - total memory usage in bytes\n */\nexport function getMemoryUsageGLTF(gltf: GLTFWithBuffers): number {\n  const imageBufferViews = new Set((gltf.json.images || []).map(image => image.bufferView));\n  const liveBufferViews = new Set<number>();\n  const decodedValues = new Set<ArrayBufferView>();\n  const accessors = new Set<GLTFAccessor>();\n  let materializedMemory = 0;\n  /** Count current accessor storage without reading or allocating its values. */\n  const addAccessorStorage = (reference: number | GLTFAccessor | undefined): void => {\n    const accessor = typeof reference === 'number' ? gltf.json.accessors?.[reference] : reference;\n    if (!accessor || accessors.has(accessor)) return;\n    accessors.add(accessor);\n    const value = (accessor as GLTFAccessor & {value?: ArrayBufferView}).value;\n    if (ArrayBuffer.isView(value)) {\n      if (!decodedValues.has(value)) materializedMemory += value.byteLength;\n      decodedValues.add(value);\n    } else if (accessor.sparse || accessor.bufferView === undefined) {\n      materializedMemory +=\n        accessor.count * BYTES[accessor.componentType] * COMPONENTS[accessor.type];\n    } else {\n      liveBufferViews.add(accessor.bufferView);\n    }\n  };\n  for (const accessor of gltf.json.accessors || []) {\n    // Unused Draco declarations can lack storage after decoding into inline accessors.\n    if (accessor.bufferView !== undefined || accessor.sparse || 'value' in accessor)\n      addAccessorStorage(accessor);\n  }\n  for (const mesh of gltf.json.meshes || []) {\n    for (const primitive of mesh.primitives) {\n      addAccessorStorage(primitive.indices);\n      for (const reference of Object.values(primitive.attributes)) addAccessorStorage(reference);\n      for (const target of primitive.targets || []) {\n        for (const reference of Object.values(target)) addAccessorStorage(reference);\n      }\n    }\n  }\n  const bufferMemory = [...liveBufferViews].reduce(\n    (total, index) =>\n      total + (imageBufferViews.has(index) ? 0 : gltf.json.bufferViews?.[index]?.byteLength || 0),\n    materializedMemory\n  );\n  const pixelCount = (gltf.images || []).reduce(\n    (total, image) => total + ((image as any)?.width || 0) * ((image as any)?.height || 0),\n    0\n  );\n  return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/gltf/lib/gltf-utils/gltf-utils.d.ts

@@ -0,0 +1,17 @@
+import type { GLTFWithBuffers } from "../types/gltf-types.js";
+export declare function getAccessorTypeFromSize(size: any): string;
+export declare function getComponentTypeFromArray(typedArray: any): number;
+export declare function getAccessorArrayTypeAndLength(accessor: any, bufferView: any): {
+    ArrayType: any;
+    length: number;
+    byteLength: number;
+    componentByteSize: any;
+    numberOfComponentsInElement: any;
+};
+/**
+ * Calculate the GPU memory used by a GLTF tile, for both buffer and texture memory
+ * @param gltf - the gltf content of a GLTF tile
+ * @returns - total memory usage in bytes
+ */
+export declare function getMemoryUsageGLTF(gltf: GLTFWithBuffers): number;
+//# sourceMappingURL=gltf-utils.d.ts.map

package/dist/gltf/lib/gltf-utils/gltf-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-utils.d.ts","sourceRoot":"","sources":["../../../../src/gltf/lib/gltf-utils/gltf-utils.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,eAAe,EAAe,+BAA4B;AA+EvE,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,UAG3C;AAED,wBAAgB,yBAAyB,CAAC,UAAU,KAAA,UAMnD;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,KAAA,EAAE,UAAU,KAAA;;;;;;EAUjE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CA8ChE"}

package/dist/gltf/lib/gltf-utils/gltf-utils.js

@@ -0,0 +1,135 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { assert } from "../utils/assert.js";
+import { BYTES, COMPONENTS } from "./gltf-constants.js";
+/**
+ * Memory needed to store texture and all mipmap levels 1 + 1/4 + 1/16 + 1/64 + ...
+ * Minimum 1.33, but due to GPU layout may be 1.5
+ */
+const MIPMAP_FACTOR = 1.33;
+const TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];
+const ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
+    [Int8Array, 5120],
+    [Uint8Array, 5121],
+    [Int16Array, 5122],
+    [Uint16Array, 5123],
+    [Int32Array, 5124],
+    [Uint32Array, 5125],
+    [Float32Array, 5126],
+    [Float64Array, 5130],
+    [BigInt64Array, 5134],
+    [BigUint64Array, 5135]
+];
+const ARRAY_TO_COMPONENT_TYPE = new Map(ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT);
+const ATTRIBUTE_TYPE_TO_COMPONENTS = {
+    SCALAR: 1,
+    VEC2: 2,
+    VEC3: 3,
+    VEC4: 4,
+    MAT2: 4,
+    MAT3: 9,
+    MAT4: 16
+};
+const ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
+    5120: 1,
+    5121: 1,
+    5122: 2,
+    5123: 2,
+    5124: 4,
+    5125: 4,
+    5126: 4,
+    5130: 8,
+    5131: 2,
+    5134: 8,
+    5135: 8
+};
+const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
+    5120: Int8Array,
+    5121: Uint8Array,
+    5122: Int16Array,
+    5123: Uint16Array,
+    5124: Int32Array,
+    5125: Uint32Array,
+    5126: Float32Array,
+    5130: Float64Array,
+    // JavaScript does not yet provide Float16Array across supported runtimes.
+    // Preserve binary16 payloads in Uint16Array while componentType retains their semantics.
+    5131: Uint16Array,
+    5134: BigInt64Array,
+    5135: BigUint64Array
+};
+export function getAccessorTypeFromSize(size) {
+    const type = TYPES[size - 1];
+    return type || TYPES[0];
+}
+export function getComponentTypeFromArray(typedArray) {
+    const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);
+    if (!componentType) {
+        throw new Error('Illegal typed array');
+    }
+    return componentType;
+}
+export function getAccessorArrayTypeAndLength(accessor, bufferView) {
+    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
+    const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
+    const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
+    const length = accessor.count * components;
+    const byteLength = accessor.count * components * bytesPerComponent;
+    assert(byteLength >= 0 && byteLength <= bufferView.byteLength);
+    const componentByteSize = BYTES[accessor.componentType];
+    const numberOfComponentsInElement = COMPONENTS[accessor.type];
+    return { ArrayType, length, byteLength, componentByteSize, numberOfComponentsInElement };
+}
+/**
+ * Calculate the GPU memory used by a GLTF tile, for both buffer and texture memory
+ * @param gltf - the gltf content of a GLTF tile
+ * @returns - total memory usage in bytes
+ */
+export function getMemoryUsageGLTF(gltf) {
+    const imageBufferViews = new Set((gltf.json.images || []).map(image => image.bufferView));
+    const liveBufferViews = new Set();
+    const decodedValues = new Set();
+    const accessors = new Set();
+    let materializedMemory = 0;
+    /** Count current accessor storage without reading or allocating its values. */
+    const addAccessorStorage = (reference) => {
+        const accessor = typeof reference === 'number' ? gltf.json.accessors?.[reference] : reference;
+        if (!accessor || accessors.has(accessor))
+            return;
+        accessors.add(accessor);
+        const value = accessor.value;
+        if (ArrayBuffer.isView(value)) {
+            if (!decodedValues.has(value))
+                materializedMemory += value.byteLength;
+            decodedValues.add(value);
+        }
+        else if (accessor.sparse || accessor.bufferView === undefined) {
+            materializedMemory +=
+                accessor.count * BYTES[accessor.componentType] * COMPONENTS[accessor.type];
+        }
+        else {
+            liveBufferViews.add(accessor.bufferView);
+        }
+    };
+    for (const accessor of gltf.json.accessors || []) {
+        // Unused Draco declarations can lack storage after decoding into inline accessors.
+        if (accessor.bufferView !== undefined || accessor.sparse || 'value' in accessor)
+            addAccessorStorage(accessor);
+    }
+    for (const mesh of gltf.json.meshes || []) {
+        for (const primitive of mesh.primitives) {
+            addAccessorStorage(primitive.indices);
+            for (const reference of Object.values(primitive.attributes))
+                addAccessorStorage(reference);
+            for (const target of primitive.targets || []) {
+                for (const reference of Object.values(target))
+                    addAccessorStorage(reference);
+            }
+        }
+    }
+    const bufferMemory = [...liveBufferViews].reduce((total, index) => total + (imageBufferViews.has(index) ? 0 : gltf.json.bufferViews?.[index]?.byteLength || 0), materializedMemory);
+    const pixelCount = (gltf.images || []).reduce((total, image) => total + (image?.width || 0) * (image?.height || 0), 0);
+    return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);
+}
+//# sourceMappingURL=gltf-utils.js.map

package/dist/gltf/lib/gltf-utils/gltf-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-utils.js","sourceRoot":"","sources":["../../../../src/gltf/lib/gltf-utils/gltf-utils.ts"],"names":[],"mappings":"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"}

package/dist/gltf/lib/gltf-utils/resolve-gltf-file.cjs

@@ -0,0 +1,91 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gltf/lib/gltf-utils/resolve-gltf-file.ts
+var resolve_gltf_file_exports = {};
+__export(resolve_gltf_file_exports, {
+  findGLTFFileIndex: () => findGLTFFileIndex,
+  resolveGLTFFile: () => resolveGLTFFile
+});
+module.exports = __toCommonJS(resolve_gltf_file_exports);
+var import_get_typed_array = require("./get-typed-array.cjs");
+var import_resolve_url = require("./resolve-url.cjs");
+var import_assert = require("../utils/assert.cjs");
+function findGLTFFileIndex(gltf, reference) {
+  const files = gltf.json.files || [];
+  const matches = [];
+  for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
+    const file = files[fileIndex];
+    if (file.name === reference || file.uri === reference) {
+      matches.push(fileIndex);
+    }
+  }
+  (0, import_assert.assert)(matches.length <= 1, `glTF package file reference ${reference} is ambiguous.`);
+  return matches[0] ?? -1;
+}
+async function resolveGLTFFile(gltf, fileReference, options, context) {
+  const files = gltf.json.files || [];
+  const fileIndex = typeof fileReference === "number" ? fileReference : findGLTFFileIndex(gltf, fileReference);
+  (0, import_assert.assert)(Number.isInteger(fileIndex) && fileIndex >= 0 && fileIndex < files.length);
+  gltf.files = gltf.files || new Array(files.length).fill(null);
+  const loadedFile = gltf.files[fileIndex];
+  if (loadedFile) {
+    return loadedFile;
+  }
+  const file = files[fileIndex];
+  (0, import_assert.assert)(file.mimeType, `glTF file ${fileIndex} must define mimeType.`);
+  const hasUri = file.uri !== void 0;
+  const hasBufferView = file.bufferView !== void 0;
+  (0, import_assert.assert)(
+    hasUri !== hasBufferView,
+    `glTF file ${fileIndex} must define exactly one of uri or bufferView.`
+  );
+  let resolvedFile;
+  if (file.uri !== void 0) {
+    const url = (0, import_resolve_url.resolveUrl)(file.uri, options, context);
+    const response = await context.fetch(url);
+    (0, import_assert.assert)(response?.ok, `Failed to fetch glTF file ${file.uri}: HTTP ${response?.status}.`);
+    const arrayBuffer = await response.arrayBuffer();
+    resolvedFile = {
+      arrayBuffer,
+      byteOffset: 0,
+      byteLength: arrayBuffer.byteLength,
+      mimeType: file.mimeType,
+      name: file.name,
+      url
+    };
+  } else {
+    const data = (0, import_get_typed_array.getTypedArrayForBufferView)(gltf.json, gltf.buffers, file.bufferView);
+    resolvedFile = {
+      arrayBuffer: data.buffer,
+      byteOffset: data.byteOffset,
+      byteLength: data.byteLength,
+      mimeType: file.mimeType,
+      name: file.name
+    };
+  }
+  gltf.files[fileIndex] = resolvedFile;
+  return resolvedFile;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findGLTFFileIndex,
+  resolveGLTFFile
+});
+//# sourceMappingURL=resolve-gltf-file.cjs.map

package/dist/gltf/lib/gltf-utils/resolve-gltf-file.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/gltf/lib/gltf-utils/resolve-gltf-file.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {LoaderContext, StrictLoaderOptions} from '@loaders.gl/core/loader-utils';\nimport type {GLTFExternalFile, GLTFWithBuffers} from '../types/gltf-types';\nimport {getTypedArrayForBufferView} from './get-typed-array';\nimport {resolveUrl} from './resolve-url';\nimport {assert} from '../utils/assert';\n\n/**\n * Find a draft glTF 2.1 file definition by package name or original URI.\n * @param gltf - Parsed glTF container.\n * @param reference - Package-relative file reference.\n * @returns File index, or `-1` when no definition matches.\n */\nexport function findGLTFFileIndex(gltf: GLTFWithBuffers, reference: string): number {\n  const files = gltf.json.files || [];\n  const matches: number[] = [];\n\n  for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {\n    const file = files[fileIndex];\n    if (file.name === reference || file.uri === reference) {\n      matches.push(fileIndex);\n    }\n  }\n\n  assert(matches.length <= 1, `glTF package file reference ${reference} is ambiguous.`);\n  return matches[0] ?? -1;\n}\n\n/**\n * Resolve a draft glTF 2.1 file from a URI or embedded buffer view.\n * String references are matched against `files[*].name` and `files[*].uri`, enabling this\n * function to serve as the virtual file-system lookup for packaged assets.\n * @param gltf - Parsed glTF container with buffers loaded when embedded files are used.\n * @param fileReference - File array index, package name, or original URI.\n * @param options - Loader options used for relative URL resolution.\n * @param context - Loader context supplying base URL and fetch implementation.\n * @returns Resolved file bytes and metadata.\n */\nexport async function resolveGLTFFile(\n  gltf: GLTFWithBuffers,\n  fileReference: number | string,\n  options: StrictLoaderOptions,\n  context: LoaderContext\n): Promise<GLTFExternalFile> {\n  const files = gltf.json.files || [];\n  const fileIndex =\n    typeof fileReference === 'number' ? fileReference : findGLTFFileIndex(gltf, fileReference);\n  assert(Number.isInteger(fileIndex) && fileIndex >= 0 && fileIndex < files.length);\n\n  gltf.files = gltf.files || new Array(files.length).fill(null);\n  const loadedFile = gltf.files[fileIndex];\n  if (loadedFile) {\n    return loadedFile;\n  }\n\n  const file = files[fileIndex];\n  assert(file.mimeType, `glTF file ${fileIndex} must define mimeType.`);\n  const hasUri = file.uri !== undefined;\n  const hasBufferView = file.bufferView !== undefined;\n  assert(\n    hasUri !== hasBufferView,\n    `glTF file ${fileIndex} must define exactly one of uri or bufferView.`\n  );\n\n  let resolvedFile: GLTFExternalFile;\n  if (file.uri !== undefined) {\n    const url = resolveUrl(file.uri, options, context);\n    const response = await context.fetch(url);\n    assert(response?.ok, `Failed to fetch glTF file ${file.uri}: HTTP ${response?.status}.`);\n    const arrayBuffer = await response.arrayBuffer();\n    resolvedFile = {\n      arrayBuffer,\n      byteOffset: 0,\n      byteLength: arrayBuffer.byteLength,\n      mimeType: file.mimeType,\n      name: file.name,\n      url\n    };\n  } else {\n    const data = getTypedArrayForBufferView(gltf.json, gltf.buffers, file.bufferView);\n    resolvedFile = {\n      arrayBuffer: data.buffer as ArrayBuffer,\n      byteOffset: data.byteOffset,\n      byteLength: data.byteLength,\n      mimeType: file.mimeType,\n      name: file.name\n    };\n  }\n\n  gltf.files[fileIndex] = resolvedFile;\n  return resolvedFile;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,6BAAyC;AACzC,yBAAyB;AACzB,oBAAqB;AAQd,SAAS,kBAAkB,MAAuB,WAA2B;AAClF,QAAM,QAAQ,KAAK,KAAK,SAAS,CAAC;AAClC,QAAM,UAAoB,CAAC;AAE3B,WAAS,YAAY,GAAG,YAAY,MAAM,QAAQ,aAAa;AAC7D,UAAM,OAAO,MAAM,SAAS;AAC5B,QAAI,KAAK,SAAS,aAAa,KAAK,QAAQ,WAAW;AACrD,cAAQ,KAAK,SAAS;AAAA,IACxB;AAAA,EACF;AAEA,4BAAO,QAAQ,UAAU,GAAG,+BAA+B,SAAS,gBAAgB;AACpF,SAAO,QAAQ,CAAC,KAAK;AACvB;AAYA,eAAsB,gBACpB,MACA,eACA,SACA,SAC2B;AAC3B,QAAM,QAAQ,KAAK,KAAK,SAAS,CAAC;AAClC,QAAM,YACJ,OAAO,kBAAkB,WAAW,gBAAgB,kBAAkB,MAAM,aAAa;AAC3F,4BAAO,OAAO,UAAU,SAAS,KAAK,aAAa,KAAK,YAAY,MAAM,MAAM;AAEhF,OAAK,QAAQ,KAAK,SAAS,IAAI,MAAM,MAAM,MAAM,EAAE,KAAK,IAAI;AAC5D,QAAM,aAAa,KAAK,MAAM,SAAS;AACvC,MAAI,YAAY;AACd,WAAO;AAAA,EACT;AAEA,QAAM,OAAO,MAAM,SAAS;AAC5B,4BAAO,KAAK,UAAU,aAAa,SAAS,wBAAwB;AACpE,QAAM,SAAS,KAAK,QAAQ;AAC5B,QAAM,gBAAgB,KAAK,eAAe;AAC1C;AAAA,IACE,WAAW;AAAA,IACX,aAAa,SAAS;AAAA,EACxB;AAEA,MAAI;AACJ,MAAI,KAAK,QAAQ,QAAW;AAC1B,UAAM,UAAM,+BAAW,KAAK,KAAK,SAAS,OAAO;AACjD,UAAM,WAAW,MAAM,QAAQ,MAAM,GAAG;AACxC,8BAAO,UAAU,IAAI,6BAA6B,KAAK,GAAG,UAAU,UAAU,MAAM,GAAG;AACvF,UAAM,cAAc,MAAM,SAAS,YAAY;AAC/C,mBAAe;AAAA,MACb;AAAA,MACA,YAAY;AAAA,MACZ,YAAY,YAAY;AAAA,MACxB,UAAU,KAAK;AAAA,MACf,MAAM,KAAK;AAAA,MACX;AAAA,IACF;AAAA,EACF,OAAO;AACL,UAAM,WAAO,mDAA2B,KAAK,MAAM,KAAK,SAAS,KAAK,UAAU;AAChF,mBAAe;AAAA,MACb,aAAa,KAAK;AAAA,MAClB,YAAY,KAAK;AAAA,MACjB,YAAY,KAAK;AAAA,MACjB,UAAU,KAAK;AAAA,MACf,MAAM,KAAK;AAAA,IACb;AAAA,EACF;AAEA,OAAK,MAAM,SAAS,IAAI;AACxB,SAAO;AACT;",
+  "names": []
+}

package/dist/gltf/lib/gltf-utils/resolve-gltf-file.d.ts

@@ -0,0 +1,21 @@
+import type { LoaderContext, StrictLoaderOptions } from '@loaders.gl/core/loader-utils';
+import type { GLTFExternalFile, GLTFWithBuffers } from "../types/gltf-types.js";
+/**
+ * Find a draft glTF 2.1 file definition by package name or original URI.
+ * @param gltf - Parsed glTF container.
+ * @param reference - Package-relative file reference.
+ * @returns File index, or `-1` when no definition matches.
+ */
+export declare function findGLTFFileIndex(gltf: GLTFWithBuffers, reference: string): number;
+/**
+ * Resolve a draft glTF 2.1 file from a URI or embedded buffer view.
+ * String references are matched against `files[*].name` and `files[*].uri`, enabling this
+ * function to serve as the virtual file-system lookup for packaged assets.
+ * @param gltf - Parsed glTF container with buffers loaded when embedded files are used.
+ * @param fileReference - File array index, package name, or original URI.
+ * @param options - Loader options used for relative URL resolution.
+ * @param context - Loader context supplying base URL and fetch implementation.
+ * @returns Resolved file bytes and metadata.
+ */
+export declare function resolveGLTFFile(gltf: GLTFWithBuffers, fileReference: number | string, options: StrictLoaderOptions, context: LoaderContext): Promise<GLTFExternalFile>;
+//# sourceMappingURL=resolve-gltf-file.d.ts.map

package/dist/gltf/lib/gltf-utils/resolve-gltf-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-gltf-file.d.ts","sourceRoot":"","sources":["../../../../src/gltf/lib/gltf-utils/resolve-gltf-file.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAE,mBAAmB,EAAC,MAAM,+BAA+B,CAAC;AACtF,OAAO,KAAK,EAAC,gBAAgB,EAAE,eAAe,EAAC,+BAA4B;AAK3E;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAalF;AAED;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,eAAe,EACrB,aAAa,EAAE,MAAM,GAAG,MAAM,EAC9B,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,gBAAgB,CAAC,CAgD3B"}

package/dist/gltf/lib/gltf-utils/resolve-gltf-file.js

@@ -0,0 +1,77 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { getTypedArrayForBufferView } from "./get-typed-array.js";
+import { resolveUrl } from "./resolve-url.js";
+import { assert } from "../utils/assert.js";
+/**
+ * Find a draft glTF 2.1 file definition by package name or original URI.
+ * @param gltf - Parsed glTF container.
+ * @param reference - Package-relative file reference.
+ * @returns File index, or `-1` when no definition matches.
+ */
+export function findGLTFFileIndex(gltf, reference) {
+    const files = gltf.json.files || [];
+    const matches = [];
+    for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
+        const file = files[fileIndex];
+        if (file.name === reference || file.uri === reference) {
+            matches.push(fileIndex);
+        }
+    }
+    assert(matches.length <= 1, `glTF package file reference ${reference} is ambiguous.`);
+    return matches[0] ?? -1;
+}
+/**
+ * Resolve a draft glTF 2.1 file from a URI or embedded buffer view.
+ * String references are matched against `files[*].name` and `files[*].uri`, enabling this
+ * function to serve as the virtual file-system lookup for packaged assets.
+ * @param gltf - Parsed glTF container with buffers loaded when embedded files are used.
+ * @param fileReference - File array index, package name, or original URI.
+ * @param options - Loader options used for relative URL resolution.
+ * @param context - Loader context supplying base URL and fetch implementation.
+ * @returns Resolved file bytes and metadata.
+ */
+export async function resolveGLTFFile(gltf, fileReference, options, context) {
+    const files = gltf.json.files || [];
+    const fileIndex = typeof fileReference === 'number' ? fileReference : findGLTFFileIndex(gltf, fileReference);
+    assert(Number.isInteger(fileIndex) && fileIndex >= 0 && fileIndex < files.length);
+    gltf.files = gltf.files || new Array(files.length).fill(null);
+    const loadedFile = gltf.files[fileIndex];
+    if (loadedFile) {
+        return loadedFile;
+    }
+    const file = files[fileIndex];
+    assert(file.mimeType, `glTF file ${fileIndex} must define mimeType.`);
+    const hasUri = file.uri !== undefined;
+    const hasBufferView = file.bufferView !== undefined;
+    assert(hasUri !== hasBufferView, `glTF file ${fileIndex} must define exactly one of uri or bufferView.`);
+    let resolvedFile;
+    if (file.uri !== undefined) {
+        const url = resolveUrl(file.uri, options, context);
+        const response = await context.fetch(url);
+        assert(response?.ok, `Failed to fetch glTF file ${file.uri}: HTTP ${response?.status}.`);
+        const arrayBuffer = await response.arrayBuffer();
+        resolvedFile = {
+            arrayBuffer,
+            byteOffset: 0,
+            byteLength: arrayBuffer.byteLength,
+            mimeType: file.mimeType,
+            name: file.name,
+            url
+        };
+    }
+    else {
+        const data = getTypedArrayForBufferView(gltf.json, gltf.buffers, file.bufferView);
+        resolvedFile = {
+            arrayBuffer: data.buffer,
+            byteOffset: data.byteOffset,
+            byteLength: data.byteLength,
+            mimeType: file.mimeType,
+            name: file.name
+        };
+    }
+    gltf.files[fileIndex] = resolvedFile;
+    return resolvedFile;
+}
+//# sourceMappingURL=resolve-gltf-file.js.map

package/dist/gltf/lib/gltf-utils/resolve-gltf-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-gltf-file.js","sourceRoot":"","sources":["../../../../src/gltf/lib/gltf-utils/resolve-gltf-file.ts"],"names":[],"mappings":"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"}

package/dist/gltf/lib/gltf-utils/resolve-url.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gltf/lib/gltf-utils/resolve-url.ts
+var resolve_url_exports = {};
+__export(resolve_url_exports, {
+  canonicalizeUrl: () => canonicalizeUrl,
+  resolveUrl: () => resolveUrl
+});
+module.exports = __toCommonJS(resolve_url_exports);
+function resolveUrl(url, options, context) {
+  const absolute = url.startsWith("data:") || url.startsWith("http:") || url.startsWith("https:");
+  if (absolute) {
+    return canonicalizeUrl(url);
+  }
+  const baseUrl = context?.baseUrl || getResolveBaseUrl(options?.core?.baseUrl);
+  if (!baseUrl) {
+    throw new Error(`'baseUrl' must be provided to resolve relative url ${url}`);
+  }
+  const resolvedUrl = baseUrl.endsWith("/") ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
+  return canonicalizeUrl(resolvedUrl);
+}
+function canonicalizeUrl(url) {
+  try {
+    return new URL(url).href;
+  } catch {
+    return url;
+  }
+}
+function getResolveBaseUrl(baseUrl) {
+  if (!baseUrl) {
+    return void 0;
+  }
+  if (baseUrl.endsWith("/")) {
+    return baseUrl;
+  }
+  const slashIndex = baseUrl.lastIndexOf("/");
+  return slashIndex >= 0 ? baseUrl.slice(0, slashIndex + 1) : "";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  canonicalizeUrl,
+  resolveUrl
+});
+//# sourceMappingURL=resolve-url.cjs.map

package/dist/gltf/lib/gltf-utils/resolve-url.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/gltf/lib/gltf-utils/resolve-url.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {LoaderContext, StrictLoaderOptions} from '@loaders.gl/core/loader-utils';\n\n// Resolves a relative url against a baseUrl\n// If url is absolute, return it unchanged\nexport function resolveUrl(url: string, options?: StrictLoaderOptions, context?: LoaderContext) {\n  // TODO: Use better logic to handle all protocols plus not delay on data\n  const absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');\n  if (absolute) {\n    return canonicalizeUrl(url);\n  }\n  const baseUrl = context?.baseUrl || getResolveBaseUrl(options?.core?.baseUrl);\n  if (!baseUrl) {\n    throw new Error(`'baseUrl' must be provided to resolve relative url ${url}`);\n  }\n  const resolvedUrl = baseUrl.endsWith('/') ? `${baseUrl}${url}` : `${baseUrl}/${url}`;\n  return canonicalizeUrl(resolvedUrl);\n}\n\n/**\n * Normalize equivalent absolute URLs for cache and cycle-detection keys.\n * Non-URL paths are returned unchanged so local and virtual file-system resolution remains intact.\n * @param url - URL to normalize.\n * @returns Canonical URL when the input has a supported absolute scheme.\n */\nexport function canonicalizeUrl(url: string): string {\n  try {\n    return new URL(url).href;\n  } catch {\n    return url;\n  }\n}\n\nfunction getResolveBaseUrl(baseUrl?: string): string | undefined {\n  if (!baseUrl) {\n    return undefined;\n  }\n\n  if (baseUrl.endsWith('/')) {\n    return baseUrl;\n  }\n\n  const slashIndex = baseUrl.lastIndexOf('/');\n  return slashIndex >= 0 ? baseUrl.slice(0, slashIndex + 1) : '';\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQO,SAAS,WAAW,KAAa,SAA+B,SAAyB;AAE9F,QAAM,WAAW,IAAI,WAAW,OAAO,KAAK,IAAI,WAAW,OAAO,KAAK,IAAI,WAAW,QAAQ;AAC9F,MAAI,UAAU;AACZ,WAAO,gBAAgB,GAAG;AAAA,EAC5B;AACA,QAAM,UAAU,SAAS,WAAW,kBAAkB,SAAS,MAAM,OAAO;AAC5E,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI,MAAM,sDAAsD,GAAG,EAAE;AAAA,EAC7E;AACA,QAAM,cAAc,QAAQ,SAAS,GAAG,IAAI,GAAG,OAAO,GAAG,GAAG,KAAK,GAAG,OAAO,IAAI,GAAG;AAClF,SAAO,gBAAgB,WAAW;AACpC;AAQO,SAAS,gBAAgB,KAAqB;AACnD,MAAI;AACF,WAAO,IAAI,IAAI,GAAG,EAAE;AAAA,EACtB,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,SAAS,kBAAkB,SAAsC;AAC/D,MAAI,CAAC,SAAS;AACZ,WAAO;AAAA,EACT;AAEA,MAAI,QAAQ,SAAS,GAAG,GAAG;AACzB,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,QAAQ,YAAY,GAAG;AAC1C,SAAO,cAAc,IAAI,QAAQ,MAAM,GAAG,aAAa,CAAC,IAAI;AAC9D;",
+  "names": []
+}

package/dist/gltf/lib/gltf-utils/resolve-url.d.ts

@@ -0,0 +1,10 @@
+import type { LoaderContext, StrictLoaderOptions } from '@loaders.gl/core/loader-utils';
+export declare function resolveUrl(url: string, options?: StrictLoaderOptions, context?: LoaderContext): string;
+/**
+ * Normalize equivalent absolute URLs for cache and cycle-detection keys.
+ * Non-URL paths are returned unchanged so local and virtual file-system resolution remains intact.
+ * @param url - URL to normalize.
+ * @returns Canonical URL when the input has a supported absolute scheme.
+ */
+export declare function canonicalizeUrl(url: string): string;
+//# sourceMappingURL=resolve-url.d.ts.map