@loaders.gl/gltf 3.1.0-alpha.2 → 3.1.0-beta.1

package/dist/glb-loader.js

@@ -1,34 +1,39 @@
-import { VERSION } from './lib/utils/version';
-import parseGLBSync from './lib/parsers/parse-glb';
-export const GLBLoader = {
-  name: 'GLB',
-  id: 'glb',
-  module: 'gltf',
-  version: VERSION,
-  extensions: ['glb'],
-  mimeTypes: ['model/gltf-binary'],
-  binary: true,
-  parse,
-  parseSync,
-  options: {
-    glb: {
-      strict: false
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._TypecheckGLBLoader = exports.GLBLoader = void 0;
+const version_1 = require("./lib/utils/version");
+const parse_glb_1 = __importDefault(require("./lib/parsers/parse-glb"));
+/**
+ * GLB Loader -
+ * GLB is the binary container format for GLTF
+ */
+exports.GLBLoader = {
+    name: 'GLB',
+    id: 'glb',
+    module: 'gltf',
+    version: version_1.VERSION,
+    extensions: ['glb'],
+    mimeTypes: ['model/gltf-binary'],
+    binary: true,
+    parse,
+    parseSync,
+    options: {
+        glb: {
+            strict: false // Enables deprecated XVIZ support (illegal CHUNK formats)
+        }
     }
-  }
 };
-
 async function parse(arrayBuffer, options) {
-  return parseSync(arrayBuffer, options);
+    return parseSync(arrayBuffer, options);
 }
-
 function parseSync(arrayBuffer, options) {
-  const {
-    byteOffset = 0
-  } = options || {};
-  const glb = {};
-  parseGLBSync(glb, arrayBuffer, byteOffset, options === null || options === void 0 ? void 0 : options.glb);
-  return glb;
+    const { byteOffset = 0 } = options || {};
+    const glb = {};
+    (0, parse_glb_1.default)(glb, arrayBuffer, byteOffset, options?.glb);
+    return glb;
 }
-
-export const _TypecheckGLBLoader = GLBLoader;
-//# sourceMappingURL=glb-loader.js.map
+// TYPE TESTS - TODO find a better way than exporting junk
+exports._TypecheckGLBLoader = exports.GLBLoader;

package/dist/glb-writer.d.ts

@@ -0,0 +1,22 @@
+import type { Writer } from '@loaders.gl/loader-utils';
+/**
+ * GLB exporter
+ * GLB is the binary container format for GLTF
+ */
+export declare const GLBWriter: {
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    extensions: string[];
+    mimeTypes: string[];
+    binary: boolean;
+    encodeSync: typeof encodeSync;
+    options: {
+        glb: {};
+    };
+};
+declare function encodeSync(glb: any, options: any): ArrayBuffer;
+export declare const _TypecheckGLBLoader: Writer;
+export {};
+//# sourceMappingURL=glb-writer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glb-writer.d.ts","sourceRoot":"","sources":["../src/glb-writer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAIrD;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;CAerB,CAAC;AAEF,iBAAS,UAAU,CAAC,GAAG,KAAA,EAAE,OAAO,KAAA,eAY/B;AAGD,eAAO,MAAM,mBAAmB,EAAE,MAAkB,CAAC"}

package/dist/glb-writer.js

@@ -1,29 +1,37 @@
-import { VERSION } from './lib/utils/version';
-import encodeGLBSync from './lib/encoders/encode-glb';
-export const GLBWriter = {
-  name: 'GLB',
-  id: 'glb',
-  module: 'gltf',
-  version: VERSION,
-  extensions: ['glb'],
-  mimeTypes: ['model/gltf-binary'],
-  binary: true,
-  encodeSync,
-  options: {
-    glb: {}
-  }
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._TypecheckGLBLoader = exports.GLBWriter = void 0;
+const version_1 = require("./lib/utils/version");
+const encode_glb_1 = __importDefault(require("./lib/encoders/encode-glb"));
+/**
+ * GLB exporter
+ * GLB is the binary container format for GLTF
+ */
+exports.GLBWriter = {
+    name: 'GLB',
+    id: 'glb',
+    module: 'gltf',
+    version: version_1.VERSION,
+    extensions: ['glb'],
+    mimeTypes: ['model/gltf-binary'],
+    binary: true,
+    encodeSync,
+    options: {
+        glb: {}
+    }
 };
-
 function encodeSync(glb, options) {
-  const {
-    byteOffset = 0
-  } = options;
-  const byteLength = encodeGLBSync(glb, null, byteOffset, options);
-  const arrayBuffer = new ArrayBuffer(byteLength);
-  const dataView = new DataView(arrayBuffer);
-  encodeGLBSync(glb, dataView, byteOffset, options);
-  return arrayBuffer;
+    const { byteOffset = 0 } = options;
+    // Calculate length and allocate buffer
+    const byteLength = (0, encode_glb_1.default)(glb, null, byteOffset, options);
+    const arrayBuffer = new ArrayBuffer(byteLength);
+    // Encode into buffer
+    const dataView = new DataView(arrayBuffer);
+    (0, encode_glb_1.default)(glb, dataView, byteOffset, options);
+    return arrayBuffer;
 }
-
-export const _TypecheckGLBLoader = GLBWriter;
-//# sourceMappingURL=glb-writer.js.map
+// TYPE TESTS - TODO find a better way than exporting junk
+exports._TypecheckGLBLoader = exports.GLBWriter;

package/dist/gltf-loader.d.ts

@@ -0,0 +1,18 @@
+import type { LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
+import type { DracoLoaderOptions } from '@loaders.gl/draco';
+import type { ImageLoaderOptions } from '@loaders.gl/images';
+import type { TextureLoaderOptions } from '@loaders.gl/textures';
+import type { GLTFParseOptions } from './lib/parsers/parse-gltf';
+import { GLBLoaderOptions } from './glb-loader';
+/**
+ * GLTF loader options
+ */
+export declare type GLTFLoaderOptions = LoaderOptions & ImageLoaderOptions & TextureLoaderOptions & GLBLoaderOptions & DracoLoaderOptions & {
+    gltf?: GLTFParseOptions;
+};
+/**
+ * GLTF loader
+ */
+export declare const GLTFLoader: LoaderWithParser;
+export declare function parse(arrayBuffer: any, options: GLTFLoaderOptions | undefined, context: any): Promise<Record<string, any>>;
+//# 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,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC9E,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,mBAAmB,CAAC;AAE1D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAG/D,OAAO,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAE9C;;GAEG;AACH,oBAAY,iBAAiB,GAAG,aAAa,GAC3C,kBAAkB,GAClB,oBAAoB,GACpB,gBAAgB,GAChB,kBAAkB,GAAG;IACnB,IAAI,CAAC,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,gBAkCxB,CAAC;AAEF,wBAAsB,KAAK,CAAC,WAAW,KAAA,EAAE,OAAO,+BAAwB,EAAE,OAAO,KAAA,gCAShF"}

package/dist/gltf-loader.js

@@ -1,47 +1,50 @@
-import { VERSION } from './lib/utils/version';
-import { parseGLTF } from './lib/parsers/parse-gltf';
-export const GLTFLoader = {
-  name: 'glTF',
-  id: 'gltf',
-  module: 'gltf',
-  version: VERSION,
-  extensions: ['gltf', 'glb'],
-  mimeTypes: ['model/gltf+json', 'model/gltf-binary'],
-  text: true,
-  binary: true,
-  tests: ['glTF'],
-  parse,
-  options: {
-    gltf: {
-      normalize: true,
-      loadBuffers: true,
-      loadImages: true,
-      decompressMeshes: true,
-      postProcess: true
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.GLTFLoader = void 0;
+const version_1 = require("./lib/utils/version");
+const parse_gltf_1 = require("./lib/parsers/parse-gltf");
+/**
+ * GLTF loader
+ */
+exports.GLTFLoader = {
+    name: 'glTF',
+    id: 'gltf',
+    module: 'gltf',
+    version: version_1.VERSION,
+    extensions: ['gltf', 'glb'],
+    mimeTypes: ['model/gltf+json', 'model/gltf-binary'],
+    text: true,
+    binary: true,
+    tests: ['glTF'],
+    parse,
+    options: {
+        gltf: {
+            normalize: true,
+            loadBuffers: true,
+            loadImages: true,
+            decompressMeshes: true,
+            postProcess: true // Postprocess glTF and return json structure directly
+        },
+        // common?
+        log: console // eslint-disable-line
     },
-    log: console
-  },
-  deprecatedOptions: {
-    fetchImages: 'gltf.loadImages',
-    createImages: 'gltf.loadImages',
-    decompress: 'gltf.decompressMeshes',
-    postProcess: 'gltf.postProcess',
-    gltf: {
-      decompress: 'gltf.decompressMeshes'
+    deprecatedOptions: {
+        fetchImages: 'gltf.loadImages',
+        createImages: 'gltf.loadImages',
+        decompress: 'gltf.decompressMeshes',
+        postProcess: 'gltf.postProcess',
+        gltf: {
+            decompress: 'gltf.decompressMeshes'
+        }
     }
-  }
 };
-export async function parse(arrayBuffer, options = {}, context) {
-  options = { ...GLTFLoader.options,
-    ...options
-  };
-  options.gltf = { ...GLTFLoader.options.gltf,
-    ...options.gltf
-  };
-  const {
-    byteOffset = 0
-  } = options;
-  const gltf = {};
-  return await parseGLTF(gltf, arrayBuffer, byteOffset, options, context);
+async function parse(arrayBuffer, options = {}, context) {
+    // Apps can call the parse method directly, we so apply default options here
+    options = { ...exports.GLTFLoader.options, ...options };
+    // @ts-ignore
+    options.gltf = { ...exports.GLTFLoader.options.gltf, ...options.gltf };
+    const { byteOffset = 0 } = options;
+    const gltf = {};
+    return await (0, parse_gltf_1.parseGLTF)(gltf, arrayBuffer, byteOffset, options, context);
 }
-//# sourceMappingURL=gltf-loader.js.map
+exports.parse = parse;

package/dist/gltf-writer.d.ts

@@ -0,0 +1,25 @@
+import type { Writer } from '@loaders.gl/loader-utils';
+export declare type GLTFWriterOptions = {
+    gltf?: {};
+    byteOffset?: number;
+};
+/**
+ * GLTF exporter
+ */
+export declare const GLTFWriter: {
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    extensions: string[];
+    mimeTypes: string[];
+    binary: boolean;
+    encodeSync: typeof encodeSync;
+    options: {
+        gltf: {};
+    };
+};
+declare function encodeSync(gltf: any, options?: GLTFWriterOptions): ArrayBuffer;
+export declare const _TypecheckGLBLoader: Writer;
+export {};
+//# 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,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAIrD,oBAAY,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,EAAE,CAAC;IACV,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;CAetB,CAAC;AAEF,iBAAS,UAAU,CAAC,IAAI,KAAA,EAAE,OAAO,GAAE,iBAAsB,eAUxD;AAGD,eAAO,MAAM,mBAAmB,EAAE,MAAmB,CAAC"}

package/dist/gltf-writer.js

@@ -1,29 +1,32 @@
-import { VERSION } from './lib/utils/version';
-import { encodeGLTFSync } from './lib/encoders/encode-gltf';
-export const GLTFWriter = {
-  name: 'glTF',
-  id: 'gltf',
-  module: 'gltf',
-  version: VERSION,
-  extensions: ['glb'],
-  mimeTypes: ['model/gltf-binary'],
-  binary: true,
-  encodeSync,
-  options: {
-    gltf: {}
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._TypecheckGLBLoader = exports.GLTFWriter = void 0;
+const version_1 = require("./lib/utils/version");
+const encode_gltf_1 = require("./lib/encoders/encode-gltf");
+/**
+ * GLTF exporter
+ */
+exports.GLTFWriter = {
+    name: 'glTF',
+    id: 'gltf',
+    module: 'gltf',
+    version: version_1.VERSION,
+    extensions: ['glb'],
+    mimeTypes: ['model/gltf-binary'],
+    binary: true,
+    encodeSync,
+    options: {
+        gltf: {}
+    }
 };
-
 function encodeSync(gltf, options = {}) {
-  const {
-    byteOffset = 0
-  } = options;
-  const byteLength = encodeGLTFSync(gltf, null, byteOffset, options);
-  const arrayBuffer = new ArrayBuffer(byteLength);
-  const dataView = new DataView(arrayBuffer);
-  encodeGLTFSync(gltf, dataView, byteOffset, options);
-  return arrayBuffer;
+    const { byteOffset = 0 } = options;
+    // Calculate length, then create arraybuffer and encode
+    const byteLength = (0, encode_gltf_1.encodeGLTFSync)(gltf, null, byteOffset, options);
+    const arrayBuffer = new ArrayBuffer(byteLength);
+    const dataView = new DataView(arrayBuffer);
+    (0, encode_gltf_1.encodeGLTFSync)(gltf, dataView, byteOffset, options);
+    return arrayBuffer;
 }
-
-export const _TypecheckGLBLoader = GLTFWriter;
-//# sourceMappingURL=gltf-writer.js.map
+// TYPE TESTS - TODO find a better way than exporting junk
+exports._TypecheckGLBLoader = exports.GLTFWriter;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export type { GLB } from './lib/types/glb-types';
+export type { GLTF, GLTFAccessor, GLTFBuffer, GLTFBufferView, GLTFMeshPrimitive, GLTFMesh, GLTFNode, GLTFMaterial, GLTFSampler, GLTFScene, GLTFSkin, GLTFTexture, GLTFImage, GLTF_KHR_binary_glTF, GLTF_KHR_draco_mesh_compression, GLTF_KHR_texture_basisu, GLTF_EXT_meshopt_compression, GLTF_EXT_texture_webp } from './lib/types/gltf-types';
+export { GLTFLoader } from './gltf-loader';
+export { GLTFWriter } from './gltf-writer';
+export { GLBLoader } from './glb-loader';
+export { GLBWriter } from './glb-writer';
+export { default as GLTFScenegraph } from './lib/api/gltf-scenegraph';
+export { postProcessGLTF } from './lib/api/post-process-gltf';
+export type { Mesh } from './lib/types/gltf-json-schema';
+export type { GLTFObject } from './lib/types/gltf-types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAC,GAAG,EAAC,MAAM,uBAAuB,CAAC;AAC/C,YAAY,EACV,IAAI,EACJ,YAAY,EACZ,UAAU,EACV,cAAc,EACd,iBAAiB,EACjB,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,SAAS,EACT,QAAQ,EACR,WAAW,EACX,SAAS,EAET,oBAAoB,EACpB,+BAA+B,EAC/B,uBAAuB,EACvB,4BAA4B,EAC5B,qBAAqB,EACtB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAGzC,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AACvC,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAGvC,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAC,eAAe,EAAC,MAAM,6BAA6B,CAAC;AAC5D,YAAY,EAAC,IAAI,EAAC,MAAM,8BAA8B,CAAC;AACvD,YAAY,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -1,8 +1,21 @@
-export { KHR_DRACO_MESH_COMPRESSION } from './lib/gltf-utils/gltf-constants';
-export { GLTFLoader } from './gltf-loader';
-export { GLTFWriter } from './gltf-writer';
-export { GLBLoader } from './glb-loader';
-export { GLBWriter } from './glb-writer';
-export { default as GLTFScenegraph } from './lib/api/gltf-scenegraph';
-export { postProcessGLTF } from './lib/api/post-process-gltf';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postProcessGLTF = exports.GLTFScenegraph = exports.GLBWriter = exports.GLBLoader = exports.GLTFWriter = exports.GLTFLoader = void 0;
+// glTF loader/writer definition objects
+var gltf_loader_1 = require("./gltf-loader");
+Object.defineProperty(exports, "GLTFLoader", { enumerable: true, get: function () { return gltf_loader_1.GLTFLoader; } });
+var gltf_writer_1 = require("./gltf-writer");
+Object.defineProperty(exports, "GLTFWriter", { enumerable: true, get: function () { return gltf_writer_1.GLTFWriter; } });
+// GLB Loader & Writer (for custom formats that want to leverage the GLB binary "envelope")
+var glb_loader_1 = require("./glb-loader");
+Object.defineProperty(exports, "GLBLoader", { enumerable: true, get: function () { return glb_loader_1.GLBLoader; } });
+var glb_writer_1 = require("./glb-writer");
+Object.defineProperty(exports, "GLBWriter", { enumerable: true, get: function () { return glb_writer_1.GLBWriter; } });
+// glTF Data Access Helper Class
+var gltf_scenegraph_1 = require("./lib/api/gltf-scenegraph");
+Object.defineProperty(exports, "GLTFScenegraph", { enumerable: true, get: function () { return __importDefault(gltf_scenegraph_1).default; } });
+var post_process_gltf_1 = require("./lib/api/post-process-gltf");
+Object.defineProperty(exports, "postProcessGLTF", { enumerable: true, get: function () { return post_process_gltf_1.postProcessGLTF; } });

package/dist/lib/api/gltf-extensions.d.ts

@@ -0,0 +1,26 @@
+import { GLTF } from '../types/gltf-types';
+import type { GLTFLoaderOptions } from '../../gltf-loader';
+declare type GLTFExtensionPlugin = {
+    name: string;
+    preprocess?: (gltfData: {
+        json: GLTF;
+    }, options: GLTFLoaderOptions, context: any) => void;
+    decode?: (gltfData: {
+        json: GLTF;
+    }, options: GLTFLoaderOptions, context: any) => Promise<void>;
+    encode?: (gltfData: {
+        json: GLTF;
+    }, options: GLTFLoaderOptions) => void;
+};
+/**
+ * List of extensions processed by the GLTFLoader
+ * Note that may extensions can only be handled on the rendering stage and are left out here
+ * These are just extensions that can be handled fully or partially during loading.
+ */
+export declare const EXTENSIONS: GLTFExtensionPlugin[];
+/** Call before any resource loading starts */
+export declare function preprocessExtensions(gltf: any, options?: GLTFLoaderOptions, context?: any): void;
+/** Call after resource loading */
+export declare function decodeExtensions(gltf: any, options?: GLTFLoaderOptions, context?: any): Promise<void>;
+export {};
+//# sourceMappingURL=gltf-extensions.d.ts.map

package/dist/lib/api/gltf-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-extensions.d.ts","sourceRoot":"","sources":["../../../src/lib/api/gltf-extensions.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,IAAI,EAAC,MAAM,qBAAqB,CAAC;AACzC,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAkBzD,aAAK,mBAAmB,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE;QAAC,IAAI,EAAE,IAAI,CAAA;KAAC,EAAE,OAAO,EAAE,iBAAiB,EAAE,OAAO,KAAA,KAAK,IAAI,CAAC;IACnF,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE;QAAC,IAAI,EAAE,IAAI,CAAA;KAAC,EAAE,OAAO,EAAE,iBAAiB,EAAE,OAAO,KAAA,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxF,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE;QAAC,IAAI,EAAE,IAAI,CAAA;KAAC,EAAE,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACvE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,mBAAmB,EAc3C,CAAC;AAEF,8CAA8C;AAC9C,wBAAgB,oBAAoB,CAAC,IAAI,KAAA,EAAE,OAAO,GAAE,iBAAsB,EAAE,OAAO,CAAC,KAAA,QAKnF;AAED,kCAAkC;AAClC,wBAAsB,gBAAgB,CAAC,IAAI,KAAA,EAAE,OAAO,GAAE,iBAAsB,EAAE,OAAO,CAAC,KAAA,iBAOrF"}

package/dist/lib/api/gltf-extensions.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeExtensions = exports.preprocessExtensions = exports.EXTENSIONS = void 0;
+// GLTF 1.0 extensions (decode only)
+// import * as KHR_binary_gltf from './KHR_draco_mesh_compression.js';
+// GLTF 2.0 Khronos extensions (decode/encode)
+const EXT_meshopt_compression = __importStar(require("../extensions/EXT_meshopt_compression"));
+const EXT_texture_webp = __importStar(require("../extensions/EXT_texture_webp"));
+const KHR_texture_basisu = __importStar(require("../extensions/KHR_texture_basisu"));
+const KHR_draco_mesh_compression = __importStar(require("../extensions/KHR_draco_mesh_compression"));
+// Deprecated. These should be handled by rendering library (e.g. luma.gl), not the loader.
+const KHR_lights_punctual = __importStar(require("../extensions/deprecated/KHR_lights_punctual"));
+const KHR_materials_unlit = __importStar(require("../extensions/deprecated/KHR_materials_unlit"));
+const KHR_techniques_webgl = __importStar(require("../extensions/deprecated/KHR_techniques_webgl"));
+/**
+ * List of extensions processed by the GLTFLoader
+ * Note that may extensions can only be handled on the rendering stage and are left out here
+ * These are just extensions that can be handled fully or partially during loading.
+ */
+exports.EXTENSIONS = [
+    // 1.0
+    // KHR_binary_gltf is handled separately - must be processed before other parsing starts
+    // KHR_binary_gltf,
+    // 2.0
+    EXT_meshopt_compression,
+    EXT_texture_webp,
+    // Basisu should come after webp, we want basisu to be preferred if both are provided
+    KHR_texture_basisu,
+    KHR_draco_mesh_compression,
+    KHR_lights_punctual,
+    KHR_materials_unlit,
+    KHR_techniques_webgl
+];
+/** Call before any resource loading starts */
+function preprocessExtensions(gltf, options = {}, context) {
+    const extensions = exports.EXTENSIONS.filter((extension) => useExtension(extension.name, options));
+    for (const extension of extensions) {
+        extension.preprocess?.(gltf, options, context);
+    }
+}
+exports.preprocessExtensions = preprocessExtensions;
+/** Call after resource loading */
+async function decodeExtensions(gltf, options = {}, context) {
+    const extensions = exports.EXTENSIONS.filter((extension) => useExtension(extension.name, options));
+    for (const extension of extensions) {
+        // Note: We decode async extensions sequentially, this might not be necessary
+        // Currently we only have Draco, but when we add Basis we may revisit
+        await extension.decode?.(gltf, options, context);
+    }
+}
+exports.decodeExtensions = decodeExtensions;
+function useExtension(extensionName, options) {
+    const excludes = options?.gltf?.excludeExtensions || {};
+    const exclude = extensionName in excludes && !excludes[extensionName];
+    return !exclude;
+}