@loaders.gl/scene 5.0.0-beta.1 → 5.0.0-beta.4

package/dist/gltf-loader-types.cjs

@@ -0,0 +1,73 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gltf-loader-types.ts
+var gltf_loader_types_exports = {};
+__export(gltf_loader_types_exports, {
+  GLTFLoader: () => GLTFLoader
+});
+module.exports = __toCommonJS(gltf_loader_types_exports);
+
+// src/gltf/gltf-loader-types.ts
+var import_version = require("./lib/utils/version.cjs");
+var import_gltf_format = require("./gltf-format.cjs");
+async function preload() {
+  const { GLTFLoaderWithParser } = await import("@loaders.gl/scene/gltf-loader");
+  return GLTFLoaderWithParser;
+}
+var GLTFLoader = {
+  dataType: null,
+  batchType: null,
+  ...import_gltf_format.GLTFFormat,
+  version: import_version.VERSION,
+  preload,
+  options: {
+    gltf: {
+      normalize: true,
+      // Normalize glTF v1 to glTF v2 format (not yet stable)
+      loadBuffers: true,
+      // Fetch any linked .BIN buffers, decode base64
+      loadFiles: false,
+      // Resolve generic glTF 2.1 file references on demand
+      loadExternalAssets: false,
+      // Recursively parse glTF 2.1 external assets
+      loadImages: true,
+      // Create image objects
+      loadAudio: true,
+      // Load encoded KHR_audio_emitter clips
+      decompressMeshes: true
+      // Decompress Draco and KHR/EXT meshopt encoded data
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GLTFLoader
+});
+//# sourceMappingURL=gltf-loader-types.cjs.map

package/dist/gltf-loader-types.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/gltf-loader-types.ts", "../src/gltf/gltf-loader-types.ts"],
+  "sourcesContent": ["export * from './gltf/gltf-loader-types.js';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader, StrictLoaderOptions} from '@loaders.gl/core/loader-utils';\nimport type {DracoLoaderOptions} from '@loaders.gl/scene/draco-loader-types';\nimport {VERSION} from './lib/utils/version';\nimport type {ImageLoaderOptions} from '@loaders.gl/images';\nimport type {BasisLoaderOptions, TextureLoaderOptions} from '@loaders.gl/images';\nimport type {GLTFWithBuffers} from './lib/types/gltf-types';\nimport type {GLBLoaderOptions} from './glb-loader-types';\nimport type {ParseGLTFOptions} from './lib/parsers/parse-gltf';\nimport {GLTFFormat} from './gltf-format';\n\n/**\n * GLTF loader options\n */\nexport type GLTFLoaderOptions = StrictLoaderOptions &\n  ImageLoaderOptions &\n  Pick<BasisLoaderOptions, 'basis'> &\n  TextureLoaderOptions &\n  GLBLoaderOptions &\n  DracoLoaderOptions & {\n    gltf?: ParseGLTFOptions;\n    /** Options forwarded to an injected SPZ loader. The source frame is always LUF for glTF. */\n    splats?: {\n      shape?: 'arrow-table';\n      sourceCoordinateSystem?: 'RUB' | 'LUF' | 'RUF' | 'UNSPECIFIED';\n      targetCoordinateSystem?: 'RUB' | 'LUF' | 'RUF' | 'UNSPECIFIED';\n    };\n  };\n\n/** Preloads the parser-bearing glTF loader implementation. */\nasync function preload() {\n  const {GLTFLoaderWithParser} = await import('@loaders.gl/scene/gltf-loader');\n  return GLTFLoaderWithParser;\n}\n\n/** Metadata-only glTF loader. */\nexport const GLTFLoader = {\n  dataType: null as unknown as GLTFWithBuffers,\n  batchType: null as never,\n  ...GLTFFormat,\n  version: VERSION,\n  preload,\n\n  options: {\n    gltf: {\n      normalize: true, // Normalize glTF v1 to glTF v2 format (not yet stable)\n      loadBuffers: true, // Fetch any linked .BIN buffers, decode base64\n      loadFiles: false, // Resolve generic glTF 2.1 file references on demand\n      loadExternalAssets: false, // Recursively parse glTF 2.1 external assets\n      loadImages: true, // Create image objects\n      loadAudio: true, // Load encoded KHR_audio_emitter clips\n      decompressMeshes: true // Decompress Draco and KHR/EXT meshopt encoded data\n    }\n  }\n} as const satisfies Loader<GLTFWithBuffers, never, GLTFLoaderOptions>;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACMA,qBAAsB;AAMtB,yBAAyB;AAqBzB,eAAe,UAAU;AACvB,QAAM,EAAC,qBAAoB,IAAI,MAAM,OAAO,+BAA+B;AAC3E,SAAO;AACT;AAGO,IAAM,aAAa;AAAA,EACxB,UAAU;AAAA,EACV,WAAW;AAAA,EACX,GAAG;AAAA,EACH,SAAS;AAAA,EACT;AAAA,EAEA,SAAS;AAAA,IACP,MAAM;AAAA,MACJ,WAAW;AAAA;AAAA,MACX,aAAa;AAAA;AAAA,MACb,WAAW;AAAA;AAAA,MACX,oBAAoB;AAAA;AAAA,MACpB,YAAY;AAAA;AAAA,MACZ,WAAW;AAAA;AAAA,MACX,kBAAkB;AAAA;AAAA,IACpB;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/gltf-loader-types.d.ts

@@ -0,0 +1,2 @@
+export * from './gltf/gltf-loader-types.js';
+//# sourceMappingURL=gltf-loader-types.d.ts.map

package/dist/gltf-loader-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-loader-types.d.ts","sourceRoot":"","sources":["../src/gltf-loader-types.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}

package/dist/gltf-loader-types.js

@@ -0,0 +1,2 @@
+export * from './gltf/gltf-loader-types.js';
+//# sourceMappingURL=gltf-loader-types.js.map

package/dist/gltf-loader-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-loader-types.js","sourceRoot":"","sources":["../src/gltf-loader-types.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}

package/dist/gltf-loader.cjs

@@ -0,0 +1,48 @@
+"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-loader.ts
+var gltf_loader_exports = {};
+__export(gltf_loader_exports, {
+  GLTFLoaderWithParser: () => GLTFLoaderWithParser,
+  parse: () => parse
+});
+module.exports = __toCommonJS(gltf_loader_exports);
+
+// src/gltf/gltf-loader.ts
+var import_parse_gltf = require("./lib/parsers/parse-gltf.cjs");
+var import_gltf_loader_types = require("./gltf-loader-types.cjs");
+var { preload: _GLTFLoaderPreload, ...GLTFLoaderMetadataWithoutPreload } = import_gltf_loader_types.GLTFLoader;
+var GLTFLoaderWithParser = {
+  ...GLTFLoaderMetadataWithoutPreload,
+  parse
+};
+async function parse(arrayBuffer, options = {}, context) {
+  const mergedOptions = { ...GLTFLoaderWithParser.options, ...options };
+  mergedOptions.gltf = { ...GLTFLoaderWithParser.options.gltf, ...mergedOptions.gltf };
+  const byteOffset = options?.glb?.byteOffset || 0;
+  const gltf = {};
+  return await (0, import_parse_gltf.parseGLTF)(gltf, arrayBuffer, byteOffset, mergedOptions, context);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GLTFLoaderWithParser,
+  parse
+});
+//# sourceMappingURL=gltf-loader.cjs.map

package/dist/gltf-loader.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/gltf-loader.ts", "../src/gltf/gltf-loader.ts"],
+  "sourcesContent": ["export * from './gltf/gltf-loader.js';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {LoaderWithParser, StrictLoaderOptions} from '@loaders.gl/core/loader-utils';\nimport type {DracoLoaderOptions} from '@loaders.gl/scene/draco-loader-types';\nimport type {ImageLoaderOptions} from '@loaders.gl/images';\nimport type {BasisLoaderOptions, TextureLoaderOptions} from '@loaders.gl/images';\nimport type {ParseGLTFOptions} from './lib/parsers/parse-gltf';\nimport type {GLTFWithBuffers} from './lib/types/gltf-types';\nimport type {GLBLoaderOptions} from './glb-loader-types';\nimport {parseGLTF} from './lib/parsers/parse-gltf';\nimport {GLTFLoader as GLTFLoaderMetadata} from './gltf-loader-types';\n\nconst {preload: _GLTFLoaderPreload, ...GLTFLoaderMetadataWithoutPreload} = GLTFLoaderMetadata;\n\n/**\n * GLTF loader options\n */\nexport type GLTFLoaderOptions = StrictLoaderOptions &\n  ImageLoaderOptions &\n  Pick<BasisLoaderOptions, 'basis'> &\n  TextureLoaderOptions &\n  GLBLoaderOptions &\n  DracoLoaderOptions & {\n    gltf?: ParseGLTFOptions;\n  };\n\n/**\n * GLTF loader\n */\nexport const GLTFLoaderWithParser = {\n  ...GLTFLoaderMetadataWithoutPreload,\n  parse\n} as const satisfies LoaderWithParser<GLTFWithBuffers, never, GLTFLoaderOptions>;\n\nexport async function parse(\n  arrayBuffer,\n  options: GLTFLoaderOptions = {},\n  context\n): Promise<GLTFWithBuffers> {\n  // Apps can call the parse method directly, we so apply default options here\n  const mergedOptions = {...GLTFLoaderWithParser.options, ...options};\n  mergedOptions.gltf = {...GLTFLoaderWithParser.options.gltf, ...mergedOptions.gltf};\n\n  const byteOffset = options?.glb?.byteOffset || 0;\n  const gltf = {};\n  return await parseGLTF(gltf as GLTFWithBuffers, arrayBuffer, byteOffset, mergedOptions, context);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACWA,wBAAwB;AACxB,+BAA+C;AAE/C,IAAM,EAAC,SAAS,oBAAoB,GAAG,iCAAgC,IAAI,yBAAAA;AAiBpE,IAAM,uBAAuB;AAAA,EAClC,GAAG;AAAA,EACH;AACF;AAEA,eAAsB,MACpB,aACA,UAA6B,CAAC,GAC9B,SAC0B;AAE1B,QAAM,gBAAgB,EAAC,GAAG,qBAAqB,SAAS,GAAG,QAAO;AAClE,gBAAc,OAAO,EAAC,GAAG,qBAAqB,QAAQ,MAAM,GAAG,cAAc,KAAI;AAEjF,QAAM,aAAa,SAAS,KAAK,cAAc;AAC/C,QAAM,OAAO,CAAC;AACd,SAAO,UAAM,6BAAU,MAAyB,aAAa,YAAY,eAAe,OAAO;AACjG;",
+  "names": ["GLTFLoaderMetadata"]
+}

package/dist/gltf-loader.d.ts

@@ -0,0 +1,2 @@
+export * from './gltf/gltf-loader.js';
+//# sourceMappingURL=gltf-loader.d.ts.map

package/dist/gltf-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-loader.d.ts","sourceRoot":"","sources":["../src/gltf-loader.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/gltf-loader.js

@@ -0,0 +1,2 @@
+export * from './gltf/gltf-loader.js';
+//# sourceMappingURL=gltf-loader.js.map

package/dist/gltf-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-loader.js","sourceRoot":"","sources":["../src/gltf-loader.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/gltf-source.cjs

@@ -0,0 +1,238 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gltf-source.ts
+var gltf_source_exports = {};
+__export(gltf_source_exports, {
+  GLTFSource: () => GLTFSource
+});
+module.exports = __toCommonJS(gltf_source_exports);
+
+// src/gltf/gltf-source.ts
+var GLTFSource = class _GLTFSource {
+  /** Canonical URL of the root document, including redirects. */
+  url;
+  /** Parsed container and lazily resolved resources. */
+  gltf;
+  /** Original glTF JSON without extension decoding. */
+  json;
+  /** Fetch implementation used for lazy requests. */
+  fetcher;
+  /** Maximum traversal depth relative to each scene root. */
+  maxDepth;
+  /** Requests shared by canonical resource URL. */
+  pending = /* @__PURE__ */ new Map();
+  /** Downloaded bytes shared by canonical resource URL. */
+  cache = /* @__PURE__ */ new Map();
+  /** Cancellation signal shared by resource requests. */
+  controller = new AbortController();
+  /** Whether this source has been closed. */
+  closed = false;
+  /** Initialize an open source around the parsed container. */
+  constructor(url, gltf, options) {
+    this.url = url;
+    this.gltf = gltf;
+    this.json = gltf.json;
+    this.fetcher = options.fetch || globalThis.fetch.bind(globalThis);
+    this.maxDepth = options.maxDepth ?? 256;
+  }
+  /** Load the root JSON or GLB container without fetching external resources. */
+  static async open(url, options = {}) {
+    if (options.maxDepth !== void 0 && (!Number.isSafeInteger(options.maxDepth) || options.maxDepth < 0)) {
+      throw new Error("maxDepth must be a nonnegative safe integer");
+    }
+    const fetcher = options.fetch || globalThis.fetch.bind(globalThis);
+    const response = await fetcher(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch glTF ${url}: HTTP ${response.status}`);
+    }
+    const bytes = await response.arrayBuffer();
+    url = response.url || url;
+    const baseUrl = new URL(".", url).href;
+    const { parse: parseGLTF } = await import("./gltf-loader.cjs");
+    const { EXTENSIONS } = await import("./lib/api/gltf-extensions.cjs");
+    const gltf = await parseGLTF(
+      bytes,
+      {
+        core: { baseUrl },
+        gltf: {
+          normalize: false,
+          excludeExtensions: EXTENSIONS.map((extension) => extension.name),
+          loadBuffers: false,
+          loadImages: false,
+          loadAudio: false,
+          loadFiles: false,
+          loadExternalAssets: false,
+          decompressMeshes: false
+        }
+      },
+      { url, fetch: fetcher }
+    );
+    return new _GLTFSource(url, gltf, options);
+  }
+  /** Return an unmodified glTF scene definition. */
+  getScene(index = this.json.scene ?? 0) {
+    this.assertOpen();
+    const scene = this.json.scenes?.[index];
+    if (!scene) throw new Error(`Invalid glTF scene index ${index}`);
+    return scene;
+  }
+  /** Return an unmodified glTF node definition. */
+  getNode(index) {
+    this.assertOpen();
+    const node = this.json.nodes?.[index];
+    if (!node) throw new Error(`Invalid glTF node index ${index}`);
+    return node;
+  }
+  /** Traverse a scene's native node indices in depth-first order. */
+  *traverse(sceneIndex = this.json.scene ?? 0) {
+    const scene = this.getScene(sceneIndex);
+    const active = /* @__PURE__ */ new Set();
+    const visit = function* (source, index, depth) {
+      if (depth > source.maxDepth) throw new Error("glTF node traversal depth exceeded");
+      if (active.has(index)) throw new Error(`Cycle in glTF node hierarchy at index ${index}`);
+      const node = source.getNode(index);
+      active.add(index);
+      try {
+        yield { index, node };
+        for (const child of node.children || []) yield* visit(source, child, depth + 1);
+      } finally {
+        active.delete(index);
+      }
+    };
+    for (const index of scene.nodes || []) yield* visit(this, index, 0);
+  }
+  /** Fetch an external or data-URI buffer, or return an embedded GLB buffer. */
+  async resolveBuffer(index) {
+    this.assertOpen();
+    const definition = this.json.buffers?.[index];
+    if (!definition) throw new Error(`Invalid glTF buffer index ${index}`);
+    const embedded = this.gltf.buffers[index];
+    if (embedded) {
+      if (embedded.byteLength < definition.byteLength)
+        throw new Error(`Truncated glTF buffer ${index}`);
+      embedded.byteLength = definition.byteLength;
+      return embedded;
+    }
+    if (!definition.uri) throw new Error(`glTF buffer ${index} has no embedded data or URI`);
+    const data = await this.fetchBytes(definition.uri);
+    if (data.byteLength < definition.byteLength) throw new Error(`Truncated glTF buffer ${index}`);
+    this.assertOpen();
+    const buffer = { arrayBuffer: data, byteOffset: 0, byteLength: definition.byteLength };
+    this.gltf.buffers[index] = buffer;
+    return buffer;
+  }
+  /** Resolve a glTF 2.1 file entry without loading unrelated resources. */
+  async resolveFile(index) {
+    this.assertOpen();
+    const definition = this.json.files?.[index];
+    if (!definition) throw new Error(`Invalid glTF file index ${index}`);
+    const existing = this.gltf.files?.[index];
+    if (existing) return existing;
+    if (!definition.mimeType) throw new Error(`glTF file ${index} lacks mimeType`);
+    if (definition.uri === void 0 === (definition.bufferView === void 0)) {
+      throw new Error(`glTF file ${index} must specify exactly one of uri or bufferView`);
+    }
+    let arrayBuffer;
+    let byteOffset = 0;
+    let byteLength;
+    if (definition.uri !== void 0) {
+      arrayBuffer = await this.fetchBytes(definition.uri);
+      byteLength = arrayBuffer.byteLength;
+    } else {
+      const view = this.json.bufferViews?.[definition.bufferView];
+      if (!view) throw new Error(`Invalid glTF file bufferView ${definition.bufferView}`);
+      const buffer = await this.resolveBuffer(view.buffer);
+      arrayBuffer = buffer.arrayBuffer;
+      const viewOffset = view.byteOffset ?? 0;
+      byteOffset = buffer.byteOffset + viewOffset;
+      byteLength = view.byteLength;
+      if (!Number.isSafeInteger(viewOffset) || viewOffset < 0 || !Number.isSafeInteger(byteLength) || byteLength < 0 || viewOffset + byteLength > buffer.byteLength || byteOffset + byteLength > arrayBuffer.byteLength) {
+        throw new Error("glTF file bufferView exceeds buffer");
+      }
+    }
+    this.assertOpen();
+    const result = {
+      arrayBuffer,
+      byteOffset,
+      byteLength,
+      mimeType: definition.mimeType,
+      name: definition.name,
+      ...definition.uri ? { url: new URL(definition.uri, this.url).href } : {}
+    };
+    this.gltf.files ||= new Array(this.json.files?.length || 0).fill(null);
+    this.gltf.files[index] = result;
+    return result;
+  }
+  /** Release source-owned cached bytes and cancel outstanding fetches. */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.controller.abort();
+    this.cache.clear();
+    this.pending.clear();
+    this.gltf.buffers.length = 0;
+    if (this.gltf.files) this.gltf.files.length = 0;
+    Reflect.deleteProperty(this.gltf, "_glb");
+    delete this.gltf.binary;
+  }
+  /** Reject operations after close. */
+  assertOpen() {
+    if (this.closed) throw new Error("GLTFSource is closed");
+  }
+  /** Fetch bytes once per URL, allowing failed requests to be retried. */
+  async fetchBytes(uri) {
+    this.assertOpen();
+    const key = new URL(uri, this.url).href;
+    const cached = this.cache.get(key);
+    if (cached) return cached;
+    const inFlight = this.pending.get(key);
+    if (inFlight) return inFlight;
+    const promise = (async () => {
+      const response = await this.fetcher(key, { signal: this.controller.signal });
+      if (!response.ok)
+        throw new Error(`Failed to fetch glTF resource ${key}: HTTP ${response.status}`);
+      const data = await response.arrayBuffer();
+      this.assertOpen();
+      this.cache.set(key, data);
+      return data;
+    })();
+    this.pending.set(key, promise);
+    try {
+      return await promise;
+    } finally {
+      this.pending.delete(key);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GLTFSource
+});
+//# sourceMappingURL=gltf-source.cjs.map

package/dist/gltf-source.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/gltf-source.ts", "../src/gltf/gltf-source.ts"],
+  "sourcesContent": ["export * from './gltf/gltf-source.js';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {GLTF, GLTFNode, GLTFScene} from './lib/types/gltf-json-schema';\nimport type {GLTFExternalBuffer, GLTFExternalFile, GLTFWithBuffers} from './lib/types/gltf-types';\n\n/** Options for a persistent, CPU-only glTF source. */\nexport type GLTFSourceOptions = {\n  /** Override the platform fetch implementation. */\n  fetch?: typeof fetch;\n  /** Maximum number of nested node references traversed. */\n  maxDepth?: number;\n};\n\n/**\n * Persistent, schema-preserving access to a glTF document and its resources.\n *\n * Opening reads the root document, but does not fetch external buffers, images or assets.\n * The source owns its resource cache and outstanding requests. No GPU resources are created.\n */\nexport class GLTFSource {\n  /** Canonical URL of the root document, including redirects. */\n  readonly url: string;\n  /** Parsed container and lazily resolved resources. */\n  readonly gltf: GLTFWithBuffers;\n  /** Original glTF JSON without extension decoding. */\n  readonly json: GLTF;\n  /** Fetch implementation used for lazy requests. */\n  private readonly fetcher: typeof fetch;\n  /** Maximum traversal depth relative to each scene root. */\n  private readonly maxDepth: number;\n  /** Requests shared by canonical resource URL. */\n  private readonly pending = new Map<string, Promise<ArrayBuffer>>();\n  /** Downloaded bytes shared by canonical resource URL. */\n  private readonly cache = new Map<string, ArrayBuffer>();\n  /** Cancellation signal shared by resource requests. */\n  private readonly controller = new AbortController();\n  /** Whether this source has been closed. */\n  private closed = false;\n\n  /** Initialize an open source around the parsed container. */\n  private constructor(url: string, gltf: GLTFWithBuffers, options: GLTFSourceOptions) {\n    this.url = url;\n    this.gltf = gltf;\n    this.json = gltf.json;\n    this.fetcher = options.fetch || globalThis.fetch.bind(globalThis);\n    this.maxDepth = options.maxDepth ?? 256;\n  }\n\n  /** Load the root JSON or GLB container without fetching external resources. */\n  static async open(url: string, options: GLTFSourceOptions = {}): Promise<GLTFSource> {\n    if (\n      options.maxDepth !== undefined &&\n      (!Number.isSafeInteger(options.maxDepth) || options.maxDepth < 0)\n    ) {\n      throw new Error('maxDepth must be a nonnegative safe integer');\n    }\n    const fetcher = options.fetch || globalThis.fetch.bind(globalThis);\n    const response = await fetcher(url);\n    if (!response.ok) {\n      throw new Error(`Failed to fetch glTF ${url}: HTTP ${response.status}`);\n    }\n    const bytes = await response.arrayBuffer();\n    url = response.url || url;\n    const baseUrl = new URL('.', url).href;\n    const {parse: parseGLTF} = await import('./gltf-loader');\n    const {EXTENSIONS} = await import('./lib/api/gltf-extensions');\n    const gltf = await parseGLTF(\n      bytes,\n      {\n        core: {baseUrl},\n        gltf: {\n          normalize: false,\n          excludeExtensions: EXTENSIONS.map(extension => extension.name),\n          loadBuffers: false,\n          loadImages: false,\n          loadAudio: false,\n          loadFiles: false,\n          loadExternalAssets: false,\n          decompressMeshes: false\n        }\n      },\n      {url, fetch: fetcher}\n    );\n    return new GLTFSource(url, gltf, options);\n  }\n\n  /** Return an unmodified glTF scene definition. */\n  getScene(index: number = this.json.scene ?? 0): GLTFScene {\n    this.assertOpen();\n    const scene = this.json.scenes?.[index];\n    if (!scene) throw new Error(`Invalid glTF scene index ${index}`);\n    return scene;\n  }\n\n  /** Return an unmodified glTF node definition. */\n  getNode(index: number): GLTFNode {\n    this.assertOpen();\n    const node = this.json.nodes?.[index];\n    if (!node) throw new Error(`Invalid glTF node index ${index}`);\n    return node;\n  }\n\n  /** Traverse a scene's native node indices in depth-first order. */\n  *traverse(\n    sceneIndex: number = this.json.scene ?? 0\n  ): IterableIterator<{index: number; node: GLTFNode}> {\n    const scene = this.getScene(sceneIndex);\n    const active = new Set<number>();\n    /** Visit one node while tracking only the current ancestry path. */\n    const visit = function* (\n      source: GLTFSource,\n      index: number,\n      depth: number\n    ): IterableIterator<{index: number; node: GLTFNode}> {\n      if (depth > source.maxDepth) throw new Error('glTF node traversal depth exceeded');\n      if (active.has(index)) throw new Error(`Cycle in glTF node hierarchy at index ${index}`);\n      const node = source.getNode(index);\n      active.add(index);\n      try {\n        yield {index, node};\n        for (const child of node.children || []) yield* visit(source, child, depth + 1);\n      } finally {\n        active.delete(index);\n      }\n    };\n    for (const index of scene.nodes || []) yield* visit(this, index, 0);\n  }\n\n  /** Fetch an external or data-URI buffer, or return an embedded GLB buffer. */\n  async resolveBuffer(index: number): Promise<GLTFExternalBuffer> {\n    this.assertOpen();\n    const definition = this.json.buffers?.[index];\n    if (!definition) throw new Error(`Invalid glTF buffer index ${index}`);\n    const embedded = this.gltf.buffers[index];\n    if (embedded) {\n      if (embedded.byteLength < definition.byteLength)\n        throw new Error(`Truncated glTF buffer ${index}`);\n      embedded.byteLength = definition.byteLength;\n      return embedded;\n    }\n    if (!definition.uri) throw new Error(`glTF buffer ${index} has no embedded data or URI`);\n    const data = await this.fetchBytes(definition.uri);\n    if (data.byteLength < definition.byteLength) throw new Error(`Truncated glTF buffer ${index}`);\n    this.assertOpen();\n    const buffer = {arrayBuffer: data, byteOffset: 0, byteLength: definition.byteLength};\n    this.gltf.buffers[index] = buffer;\n    return buffer;\n  }\n\n  /** Resolve a glTF 2.1 file entry without loading unrelated resources. */\n  async resolveFile(index: number): Promise<GLTFExternalFile> {\n    this.assertOpen();\n    const definition = this.json.files?.[index];\n    if (!definition) throw new Error(`Invalid glTF file index ${index}`);\n    const existing = this.gltf.files?.[index];\n    if (existing) return existing;\n    if (!definition.mimeType) throw new Error(`glTF file ${index} lacks mimeType`);\n    if ((definition.uri === undefined) === (definition.bufferView === undefined)) {\n      throw new Error(`glTF file ${index} must specify exactly one of uri or bufferView`);\n    }\n    let arrayBuffer: ArrayBuffer;\n    let byteOffset = 0;\n    let byteLength: number;\n    if (definition.uri !== undefined) {\n      arrayBuffer = await this.fetchBytes(definition.uri);\n      byteLength = arrayBuffer.byteLength;\n    } else {\n      const view = this.json.bufferViews?.[definition.bufferView!];\n      if (!view) throw new Error(`Invalid glTF file bufferView ${definition.bufferView}`);\n      const buffer = await this.resolveBuffer(view.buffer);\n      arrayBuffer = buffer.arrayBuffer;\n      const viewOffset = view.byteOffset ?? 0;\n      byteOffset = buffer.byteOffset + viewOffset;\n      byteLength = view.byteLength;\n      if (\n        !Number.isSafeInteger(viewOffset) ||\n        viewOffset < 0 ||\n        !Number.isSafeInteger(byteLength) ||\n        byteLength < 0 ||\n        viewOffset + byteLength > buffer.byteLength ||\n        byteOffset + byteLength > arrayBuffer.byteLength\n      ) {\n        throw new Error('glTF file bufferView exceeds buffer');\n      }\n    }\n    this.assertOpen();\n    const result: GLTFExternalFile = {\n      arrayBuffer,\n      byteOffset,\n      byteLength,\n      mimeType: definition.mimeType,\n      name: definition.name,\n      ...(definition.uri ? {url: new URL(definition.uri, this.url).href} : {})\n    };\n    this.gltf.files ||= new Array(this.json.files?.length || 0).fill(null);\n    this.gltf.files[index] = result;\n    return result;\n  }\n\n  /** Release source-owned cached bytes and cancel outstanding fetches. */\n  close(): void {\n    if (this.closed) return;\n    this.closed = true;\n    this.controller.abort();\n    this.cache.clear();\n    this.pending.clear();\n    this.gltf.buffers.length = 0;\n    if (this.gltf.files) this.gltf.files.length = 0;\n    Reflect.deleteProperty(this.gltf, '_glb');\n    delete this.gltf.binary;\n  }\n\n  /** Reject operations after close. */\n  private assertOpen(): void {\n    if (this.closed) throw new Error('GLTFSource is closed');\n  }\n\n  /** Fetch bytes once per URL, allowing failed requests to be retried. */\n  private async fetchBytes(uri: string): Promise<ArrayBuffer> {\n    this.assertOpen();\n    const key = new URL(uri, this.url).href;\n    const cached = this.cache.get(key);\n    if (cached) return cached;\n    const inFlight = this.pending.get(key);\n    if (inFlight) return inFlight;\n    const promise = (async () => {\n      const response = await this.fetcher(key, {signal: this.controller.signal});\n      if (!response.ok)\n        throw new Error(`Failed to fetch glTF resource ${key}: HTTP ${response.status}`);\n      const data = await response.arrayBuffer();\n      this.assertOpen();\n      this.cache.set(key, data);\n      return data;\n    })();\n    this.pending.set(key, promise);\n    try {\n      return await promise;\n    } finally {\n      this.pending.delete(key);\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/gltf-source.d.ts

@@ -0,0 +1,2 @@
+export * from './gltf/gltf-source.js';
+//# sourceMappingURL=gltf-source.d.ts.map

package/dist/gltf-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-source.d.ts","sourceRoot":"","sources":["../src/gltf-source.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/gltf-source.js

@@ -0,0 +1,2 @@
+export * from './gltf/gltf-source.js';
+//# sourceMappingURL=gltf-source.js.map

package/dist/gltf-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-source.js","sourceRoot":"","sources":["../src/gltf-source.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/gltf-writer.cjs

@@ -0,0 +1,69 @@
+"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-writer.ts
+var gltf_writer_exports = {};
+__export(gltf_writer_exports, {
+  GLTFWriter: () => GLTFWriter
+});
+module.exports = __toCommonJS(gltf_writer_exports);
+
+// src/gltf/gltf-writer.ts
+var import_version = require("./lib/utils/version.cjs");
+var import_encode_gltf = require("./lib/encoders/encode-gltf.cjs");
+var import_encode_gltf_draco = require("./lib/encoders/encode-gltf-draco.cjs");
+var import_gltf_extensions = require("./lib/api/gltf-extensions.cjs");
+var import_gltf_format = require("./gltf-format.cjs");
+var GLTFWriter = {
+  dataType: null,
+  batchType: null,
+  ...import_gltf_format.GLTFFormat,
+  version: import_version.VERSION,
+  options: {
+    gltf: {}
+  },
+  encode: async (gltf, options = {}) => {
+    const compressed = await (0, import_encode_gltf_draco.compressGLTFWithDraco)(gltf, options);
+    const encodeOptions = { ...options };
+    encodeOptions.gltf = options.gltf ? { ...options.gltf, draco: void 0 } : void 0;
+    return encodeSync(compressed, encodeOptions);
+  },
+  encodeSync
+};
+function encodeSync(gltf, options = {}) {
+  if (options.gltf?.draco?.enabled) {
+    throw new Error(
+      "GLTFWriter Draco compression is asynchronous; use encode() instead of encodeSync()"
+    );
+  }
+  const { byteOffset = 0 } = options;
+  const gltfToEncode = (0, import_gltf_extensions.encodeExtensions)(gltf);
+  gltf.buffers = gltfToEncode.buffers;
+  gltf.binary = gltfToEncode.binary;
+  const byteLength = (0, import_encode_gltf.encodeGLTFSync)(gltfToEncode, null, byteOffset, options);
+  const arrayBuffer = new ArrayBuffer(byteLength);
+  const dataView = new DataView(arrayBuffer);
+  (0, import_encode_gltf.encodeGLTFSync)(gltfToEncode, dataView, byteOffset, options);
+  return arrayBuffer;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GLTFWriter
+});
+//# sourceMappingURL=gltf-writer.cjs.map

package/dist/gltf-writer.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/gltf-writer.ts", "../src/gltf/gltf-writer.ts"],
+  "sourcesContent": ["export * from './gltf/gltf-writer.js';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {WriterOptions, WriterWithEncoder} from '@loaders.gl/core/loader-utils';\nimport {VERSION} from './lib/utils/version';\nimport {encodeGLTFSync} from './lib/encoders/encode-gltf';\nimport type {GLTFWithBuffers} from './lib/types/gltf-types';\nimport {compressGLTFWithDraco, type GLTFDracoWriterOptions} from './lib/encoders/encode-gltf-draco';\nimport {encodeExtensions} from './lib/api/gltf-extensions';\nimport {GLTFFormat} from './gltf-format';\n\nexport type GLTFWriterOptions = WriterOptions & {\n  gltf?: {\n    /** Optional glTF-specific encoding features. */\n    draco?: GLTFDracoWriterOptions;\n  };\n  byteOffset?: number;\n};\n\n/**\n * GLTF exporter\n */\nexport const GLTFWriter = {\n  dataType: null as unknown as any,\n  batchType: null as never,\n\n  ...GLTFFormat,\n  version: VERSION,\n  options: {\n    gltf: {}\n  },\n\n  encode: async (gltf: GLTFWithBuffers, options: GLTFWriterOptions = {}) => {\n    const compressed = await compressGLTFWithDraco(gltf, options);\n    const encodeOptions = {...options};\n    encodeOptions.gltf = options.gltf ? {...options.gltf, draco: undefined} : undefined;\n    return encodeSync(compressed, encodeOptions);\n  },\n  encodeSync\n} as WriterWithEncoder<any, never, GLTFWriterOptions>;\n\nfunction encodeSync(gltf: GLTFWithBuffers, options: GLTFWriterOptions = {}) {\n  if (options.gltf?.draco?.enabled) {\n    throw new Error(\n      'GLTFWriter Draco compression is asynchronous; use encode() instead of encodeSync()'\n    );\n  }\n  const {byteOffset = 0} = options;\n  const gltfToEncode = encodeExtensions(gltf);\n  // Extension encoders repack JSON buffer references; keep the input container in sync.\n  gltf.buffers = gltfToEncode.buffers;\n  gltf.binary = gltfToEncode.binary;\n\n  // Calculate length, then create arraybuffer and encode\n  const byteLength = encodeGLTFSync(gltfToEncode, null, byteOffset, options);\n  const arrayBuffer = new ArrayBuffer(byteLength);\n  const dataView = new DataView(arrayBuffer);\n  encodeGLTFSync(gltfToEncode, dataView, byteOffset, options);\n\n  return arrayBuffer;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACKA,qBAAsB;AACtB,yBAA6B;AAE7B,+BAAiE;AACjE,6BAA+B;AAC/B,yBAAyB;AAalB,IAAM,aAAa;AAAA,EACxB,UAAU;AAAA,EACV,WAAW;AAAA,EAEX,GAAG;AAAA,EACH,SAAS;AAAA,EACT,SAAS;AAAA,IACP,MAAM,CAAC;AAAA,EACT;AAAA,EAEA,QAAQ,OAAO,MAAuB,UAA6B,CAAC,MAAM;AACxE,UAAM,aAAa,UAAM,gDAAsB,MAAM,OAAO;AAC5D,UAAM,gBAAgB,EAAC,GAAG,QAAO;AACjC,kBAAc,OAAO,QAAQ,OAAO,EAAC,GAAG,QAAQ,MAAM,OAAO,OAAS,IAAI;AAC1E,WAAO,WAAW,YAAY,aAAa;AAAA,EAC7C;AAAA,EACA;AACF;AAEA,SAAS,WAAW,MAAuB,UAA6B,CAAC,GAAG;AAC1E,MAAI,QAAQ,MAAM,OAAO,SAAS;AAChC,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,QAAM,EAAC,aAAa,EAAC,IAAI;AACzB,QAAM,mBAAe,yCAAiB,IAAI;AAE1C,OAAK,UAAU,aAAa;AAC5B,OAAK,SAAS,aAAa;AAG3B,QAAM,iBAAa,mCAAe,cAAc,MAAM,YAAY,OAAO;AACzE,QAAM,cAAc,IAAI,YAAY,UAAU;AAC9C,QAAM,WAAW,IAAI,SAAS,WAAW;AACzC,yCAAe,cAAc,UAAU,YAAY,OAAO;AAE1D,SAAO;AACT;",
+  "names": []
+}

package/dist/gltf-writer.d.ts

@@ -0,0 +1,2 @@
+export * from './gltf/gltf-writer.js';
+//# sourceMappingURL=gltf-writer.d.ts.map

package/dist/gltf-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-writer.d.ts","sourceRoot":"","sources":["../src/gltf-writer.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/gltf-writer.js

@@ -0,0 +1,2 @@
+export * from './gltf/gltf-writer.js';
+//# sourceMappingURL=gltf-writer.js.map

package/dist/gltf-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-writer.js","sourceRoot":"","sources":["../src/gltf-writer.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/index.cjs

@@ -21,6 +21,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DRACO_EXTERNAL_LIBRARIES: () => import_draco_libraries.DRACO_EXTERNAL_LIBRARIES,
+  DRACO_EXTERNAL_LIBRARY_URLS: () => import_draco_libraries.DRACO_EXTERNAL_LIBRARY_URLS,
+  DracoFormat: () => import_draco_format.DracoFormat,
+  DracoLoader: () => import_draco_loader_types.DracoLoader,
+  DracoWorkerLoader: () => import_draco_loader_types.DracoWorkerLoader,
   GLBFormat: () => import_gltf_format.GLBFormat,
   GLBLoader: () => import_glb_loader_types.GLBLoader,
   GLBWriter: () => import_glb_writer.GLBWriter,
@@ -30,6 +35,7 @@ __export(index_exports, {
   MTLFormat: () => import_mtl_format.MTLFormat,
   MTLLoader: () => import_mtl_loader_types.MTLLoader,
   MTLWorkerLoader: () => import_mtl_loader_types.MTLWorkerLoader,
+  MaterialXLoader: () => import_materialx_loader_types.MaterialXLoader,
   OBJFormat: () => import_obj_format.OBJFormat,
   OBJLoader: () => import_obj_loader_types.OBJLoader,
   OBJWorkerLoader: () => import_obj_loader_types.OBJWorkerLoader,
@@ -47,8 +53,17 @@ var import_gltf_writer = require("./gltf/gltf-writer.cjs");
 var import_glb_loader_types = require("./gltf/glb-loader-types.cjs");
 var import_glb_writer = require("./gltf/glb-writer.cjs");
 var import_gltf_format = require("./gltf/gltf-format.cjs");
+var import_draco_loader_types = require("./draco/draco-loader-types.cjs");
+var import_draco_format = require("./draco/draco-format.cjs");
+var import_draco_libraries = require("./draco/draco-libraries.cjs");
+var import_materialx_loader_types = require("./materialx-loader-types.cjs");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DRACO_EXTERNAL_LIBRARIES,
+  DRACO_EXTERNAL_LIBRARY_URLS,
+  DracoFormat,
+  DracoLoader,
+  DracoWorkerLoader,
   GLBFormat,
   GLBLoader,
   GLBWriter,
@@ -58,6 +73,7 @@ var import_gltf_format = require("./gltf/gltf-format.cjs");
   MTLFormat,
   MTLLoader,
   MTLWorkerLoader,
+  MaterialXLoader,
   OBJFormat,
   OBJLoader,
   OBJWorkerLoader,

package/dist/index.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/index.ts"],
-  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nexport * from './usd/index';\nexport type * from './gltf/index';\nexport type * from './obj/index';\nexport {OBJLoader, OBJWorkerLoader} from './obj/obj-loader-types';\nexport {MTLLoader, MTLWorkerLoader} from './obj/mtl-loader-types';\nexport {OBJFormat} from './obj/obj-format';\nexport {MTLFormat} from './obj/mtl-format';\nexport {OBJWriter} from './obj/obj-writer';\nexport {GLTFLoader} from './gltf/gltf-loader-types';\nexport {GLTFWriter} from './gltf/gltf-writer';\nexport {GLBLoader} from './gltf/glb-loader-types';\nexport {GLBWriter} from './gltf/glb-writer';\nexport {GLTFFormat, GLBFormat} from './gltf/gltf-format';\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,0BAAc,4BAJd;AAOA,8BAAyC;AACzC,8BAAyC;AACzC,wBAAwB;AACxB,wBAAwB;AACxB,wBAAwB;AACxB,+BAAyB;AACzB,yBAAyB;AACzB,8BAAwB;AACxB,wBAAwB;AACxB,yBAAoC;",
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nexport * from './usd/index';\nexport type * from './gltf/index';\nexport type * from './obj/index';\nexport {OBJLoader, OBJWorkerLoader} from './obj/obj-loader-types';\nexport {MTLLoader, MTLWorkerLoader} from './obj/mtl-loader-types';\nexport {OBJFormat} from './obj/obj-format';\nexport {MTLFormat} from './obj/mtl-format';\nexport {OBJWriter} from './obj/obj-writer';\nexport {GLTFLoader} from './gltf/gltf-loader-types';\nexport {GLTFWriter} from './gltf/gltf-writer';\nexport {GLBLoader} from './gltf/glb-loader-types';\nexport {GLBWriter} from './gltf/glb-writer';\nexport {GLTFFormat, GLBFormat} from './gltf/gltf-format';\n\nexport {DracoLoader, DracoWorkerLoader} from './draco/draco-loader-types';\nexport {DracoFormat} from './draco/draco-format';\nexport type * from './draco/index';\nexport {DRACO_EXTERNAL_LIBRARIES, DRACO_EXTERNAL_LIBRARY_URLS} from './draco/draco-libraries';\n\nexport {MaterialXLoader} from './materialx-loader-types';\nexport type {MaterialXDocument, MaterialXElement} from './materialx/parse-materialx';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,0BAAc,4BAJd;AAOA,8BAAyC;AACzC,8BAAyC;AACzC,wBAAwB;AACxB,wBAAwB;AACxB,wBAAwB;AACxB,+BAAyB;AACzB,yBAAyB;AACzB,8BAAwB;AACxB,wBAAwB;AACxB,yBAAoC;AAEpC,gCAA6C;AAC7C,0BAA0B;AAE1B,6BAAoE;AAEpE,oCAA8B;",
   "names": []
 }

package/dist/index.d.ts

@@ -11,4 +11,10 @@ export { GLTFWriter } from "./gltf/gltf-writer.js";
 export { GLBLoader } from "./gltf/glb-loader-types.js";
 export { GLBWriter } from "./gltf/glb-writer.js";
 export { GLTFFormat, GLBFormat } from "./gltf/gltf-format.js";
+export { DracoLoader, DracoWorkerLoader } from "./draco/draco-loader-types.js";
+export { DracoFormat } from "./draco/draco-format.js";
+export type * from "./draco/index.js";
+export { DRACO_EXTERNAL_LIBRARIES, DRACO_EXTERNAL_LIBRARY_URLS } from "./draco/draco-libraries.js";
+export { MaterialXLoader } from "./materialx-loader-types.js";
+export type { MaterialXDocument, MaterialXElement } from "./materialx/parse-materialx.js";
 //# sourceMappingURL=index.d.ts.map