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

package/dist/esm/meshopt/meshopt-encoder.ts.disabled

@@ -0,0 +1,409 @@
+// This file is part of gltfpack and is distributed under the terms of MIT License.
+
+/**
+ * Initialize the library with the Wasm module (library.wasm)
+ *
+ * @param wasm Promise with contents of library.wasm
+ *
+ * Note: this is called automatically in node.js
+ */
+function init(wasm) {
+	if (ready) {
+		throw new Error("init must be called once");
+	}
+
+	ready = Promise.resolve(wasm)
+		.then(function (buffer) {
+			return WebAssembly.instantiate(buffer, { wasi_snapshot_preview1: wasi });
+		})
+		.then(function (result) {
+			instance = result.instance;
+			instance.exports.__wasm_call_ctors();
+		});
+}
+
+/**
+ * Pack the requested glTF data using the requested command line and access interface.
+ *
+ * @param args An array of strings with the input arguments; the paths for input and output files are interpreted by the interface
+ * @param iface An interface to the system that will be used to service file requests and other system calls
+ * @return Promise that indicates completion of the operation
+ *
+ * iface should contain the following methods:
+ * read(path): Given a path, return a Uint8Array with the contents of that path
+ * write(path, data): Write the specified Uint8Array to the provided path
+ *
+ * When texture compression is requested using external compressor such as toktx, iface must provide two additional methods:
+ * execute(command): Run the requested command and return the return code
+ * unlink(path): Remove the requested file (will be called with paths to temp files after texture compression finishes)
+ */
+function pack(args, iface) {
+	if (!ready) {
+		throw new Error("init must be called before pack");
+	}
+
+	var argv = args.slice();
+	argv.unshift("gltfpack");
+
+	return ready.then(function () {
+		var buf = uploadArgv(argv);
+
+		output.position = 0;
+		output.size = 0;
+
+		interface = iface;
+		var result = instance.exports.pack(argv.length, buf);
+		interface = undefined;
+
+		instance.exports.free(buf);
+
+		var log = getString(output.data.buffer, 0, output.size);
+
+		if (result != 0) {
+			throw new Error(log);
+		} else {
+			return log;
+		}
+	});
+}
+
+// Library implementation (here be dragons)
+var WASI_EBADF = 8;
+var WASI_EINVAL = 28;
+var WASI_EIO = 29;
+var WASI_ENOSYS = 52;
+
+var ready;
+var instance;
+var interface;
+
+var output = { data: new Uint8Array(), position: 0, size: 0 };
+var fds = { 1: output, 2: output, 3: { mount: "/", path: "/" }, 4: { mount: "/gltfpack-$pwd", path: "" } };
+
+var wasi = {
+	proc_exit: function(rval) {
+	},
+
+	fd_close: function(fd) {
+		if (!fds[fd]) {
+			return WASI_EBADF;
+		}
+
+		try {
+			if (fds[fd].close) {
+				fds[fd].close();
+			}
+			fds[fd] = undefined;
+			return 0;
+		} catch (err) {
+			fds[fd] = undefined;
+			return WASI_EIO;
+		}
+	},
+
+	fd_fdstat_get: function(fd, stat) {
+		if (!fds[fd]) {
+			return WASI_EBADF;
+		}
+
+		var heap = getHeap();
+		heap.setUint8(stat + 0, fds[fd].path !== undefined ? 3 : 4);
+		heap.setUint16(stat + 2, 0, true);
+		heap.setUint32(stat + 8, 0, true);
+		heap.setUint32(stat + 12, 0, true);
+		heap.setUint32(stat + 16, 0, true);
+		heap.setUint32(stat + 20, 0, true);
+		return 0;
+	},
+
+	path_open32: function(parent_fd, dirflags, path, path_len, oflags, fs_rights_base, fs_rights_inheriting, fdflags, opened_fd) {
+		if (!fds[parent_fd] || fds[parent_fd].path === undefined) {
+			return WASI_EBADF;
+		}
+
+		var heap = getHeap();
+
+		var file = {};
+		file.name = fds[parent_fd].path + getString(heap.buffer, path, path_len);
+		file.position = 0;
+
+		if (oflags & 1) {
+			file.data = new Uint8Array(4096);
+			file.size = 0;
+			file.close = function () {
+				interface.write(file.name, new Uint8Array(file.data.buffer, 0, file.size));
+			};
+		} else {
+			try {
+				file.data = interface.read(file.name);
+
+				if (!file.data) {
+					return WASI_EIO;
+				}
+
+				file.size = file.data.length;
+			} catch (err) {
+				return WASI_EIO;
+			}
+		}
+
+		var fd = nextFd();
+		fds[fd] = file;
+
+		heap.setUint32(opened_fd, fd, true);
+		return 0;
+	},
+
+	path_unlink_file: function(parent_fd, path, path_len) {
+		if (!fds[parent_fd] || fds[parent_fd].path === undefined) {
+			return WASI_EBADF;
+		}
+
+		var heap = getHeap();
+		var name = fds[parent_fd].path + getString(heap.buffer, path, path_len);
+
+		try {
+			interface.unlink(name);
+			return 0;
+		} catch (err) {
+			return WASI_EIO;
+		}
+	},
+
+	path_filestat_get: function(parent_fd, flags, path, path_len, buf) {
+		if (!fds[parent_fd] || fds[parent_fd].path === undefined) {
+			return WASI_EBADF;
+		}
+
+		var heap = getHeap();
+		var name = getString(heap.buffer, path, path_len);
+
+		var heap = getHeap();
+		for (var i = 0; i < 64; ++i)
+			heap.setUint8(buf + i, 0);
+
+		heap.setUint8(buf + 16, name == "." ? 3 : 4);
+		return 0;
+	},
+
+	fd_prestat_get: function(fd, buf) {
+		if (!fds[fd] || fds[fd].path === undefined) {
+			return WASI_EBADF;
+		}
+
+		var path_buf = stringBuffer(fds[fd].mount);
+
+		var heap = getHeap();
+		heap.setUint8(buf, 0);
+		heap.setUint32(buf + 4, path_buf.length, true);
+		return 0;
+	},
+
+	fd_prestat_dir_name: function(fd, path, path_len) {
+		if (!fds[fd] || fds[fd].path === undefined) {
+			return WASI_EBADF;
+		}
+
+		var path_buf = stringBuffer(fds[fd].mount);
+
+		if (path_len != path_buf.length) {
+			return WASI_EINVAL;
+		}
+
+		var heap = getHeap();
+		new Uint8Array(heap.buffer).set(path_buf, path);
+		return 0;
+	},
+
+	path_remove_directory: function(parent_fd, path, path_len) {
+		return WASI_EINVAL;
+	},
+
+	fd_fdstat_set_flags: function(fd, flags) {
+		return WASI_ENOSYS;
+	},
+
+	fd_seek32: function(fd, offset, whence, newoffset) {
+		if (!fds[fd]) {
+			return WASI_EBADF;
+		}
+
+		var newposition;
+
+		switch (whence) {
+		case 0:
+			newposition = offset;
+			break;
+
+		case 1:
+			newposition = fds[fd].position + offset;
+			break;
+
+		case 2:
+			newposition = fds[fd].size;
+			break;
+
+		default:
+			return WASI_EINVAL;
+		}
+
+		if (newposition > fds[fd].size) {
+			return WASI_EINVAL;
+		}
+
+		fds[fd].position = newposition;
+
+		var heap = getHeap();
+		heap.setUint32(newoffset, newposition, true);
+		return 0;
+	},
+
+	fd_read: function(fd, iovs, iovs_len, nread) {
+		if (!fds[fd]) {
+			return WASI_EBADF;
+		}
+
+		var heap = getHeap();
+		var read = 0;
+
+		for (var i = 0; i < iovs_len; ++i) {
+			var buf = heap.getUint32(iovs + 8 * i + 0, true);
+			var buf_len = heap.getUint32(iovs + 8 * i + 4, true);
+
+			var readi = Math.min(fds[fd].size - fds[fd].position, buf_len);
+
+			new Uint8Array(heap.buffer).set(fds[fd].data.subarray(fds[fd].position, fds[fd].position + readi), buf);
+
+			fds[fd].position += readi;
+			read += readi;
+		}
+
+		heap.setUint32(nread, read, true);
+		return 0;
+	},
+
+	fd_write: function(fd, iovs, iovs_len, nwritten) {
+		if (!fds[fd]) {
+			return WASI_EBADF;
+		}
+
+		var heap = getHeap();
+		var written = 0;
+
+		for (var i = 0; i < iovs_len; ++i) {
+			var buf = heap.getUint32(iovs + 8 * i + 0, true);
+			var buf_len = heap.getUint32(iovs + 8 * i + 4, true);
+
+			if (fds[fd].position + buf_len > fds[fd].data.length) {
+				fds[fd].data = growArray(fds[fd].data, fds[fd].position + buf_len);
+			}
+
+			fds[fd].data.set(new Uint8Array(heap.buffer, buf, buf_len), fds[fd].position);
+			fds[fd].position += buf_len;
+			fds[fd].size = Math.max(fds[fd].position, fds[fd].size);
+
+			written += buf_len;
+		}
+
+		heap.setUint32(nwritten, written, true);
+		return 0;
+	},
+
+	path_readlink: function(fd, path, path_len, buf, buf_len, bufused) {
+		if (fd !== -1) {
+			return WASI_ENOSYS;
+		}
+
+		var heap = getHeap();
+		var command = getString(heap.buffer, path, path_len);
+
+		try {
+			return interface.execute(command);
+		} catch (err) {
+			return WASI_ENOSYS;
+		}
+	},
+};
+
+function nextFd() {
+	for (var i = 1; ; ++i) {
+		if (fds[i] === undefined) {
+			return i;
+		}
+	}
+}
+
+function getHeap() {
+	return new DataView(instance.exports.memory.buffer);
+}
+
+function getString(buffer, offset, length) {
+	return new TextDecoder().decode(new Uint8Array(buffer, offset, length));
+}
+
+function stringBuffer(string) {
+	return new TextEncoder().encode(string);
+}
+
+function growArray(data, len) {
+	var new_length = Math.max(1, data.length);
+	while (new_length < len) {
+		new_length *= 2;
+	}
+
+	var new_data = new Uint8Array(new_length);
+	new_data.set(data);
+
+	return new_data;
+}
+
+function uploadArgv(argv) {
+	var buf_size = argv.length * 4;
+	for (var i = 0; i < argv.length; ++i) {
+		buf_size += stringBuffer(argv[i]).length + 1;
+	}
+
+	var buf = instance.exports.malloc(buf_size);
+	var argp = buf + argv.length * 4;
+
+	var heap = getHeap();
+
+	for (var i = 0; i < argv.length; ++i) {
+		var item = stringBuffer(argv[i]);
+
+		heap.setUint32(buf + i * 4, argp, true);
+		new Uint8Array(heap.buffer).set(item, argp);
+		heap.setUint8(argp + item.length, 0);
+
+		argp += item.length + 1;
+	}
+
+	return buf;
+}
+
+// Automatic initialization for node.js
+if (typeof window === 'undefined' && typeof process !== 'undefined' && process.release.name === 'node') {
+	var fs = require('fs');
+	var util = require('util');
+
+	// Node versions before v12 don't support TextEncoder/TextDecoder natively, but util. provides compatible replacements
+	if (typeof TextEncoder === 'undefined' && typeof TextDecoder === 'undefined') {
+		TextEncoder = util.TextEncoder;
+		TextDecoder = util.TextDecoder;
+	}
+
+	init(fs.readFileSync(__dirname + '/library.wasm'));
+}
+
+// UMD
+(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        define([], factory);
+    } else if (typeof module === 'object' && module.exports) {
+        module.exports = factory();
+    } else {
+        root.gltfpack = factory();
+  }
+}(typeof self !== 'undefined' ? self : this, function () {
+    return { init, pack };
+}));

package/dist/esm/webp/webp.js

@@ -0,0 +1,29 @@
+const WEBP_TEST_IMAGES = {
+  lossy: 'UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA',
+  lossless: 'UklGRhoAAABXRUJQVlA4TA0AAAAvAAAAEAcQERGIiP4HAA==',
+  alpha: 'UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAARBxAR/Q9ERP8DAABWUDggGAAAABQBAJ0BKgEAAQAAAP4AAA3AAP7mtQAAAA==',
+  animation: 'UklGRlIAAABXRUJQVlA4WAoAAAASAAAAAAAAAAAAQU5JTQYAAAD/////AABBTk1GJgAAAAAAAAAAAAAAAAAAAGQAAABWUDhMDQAAAC8AAAAQBxAREYiI/gcA'
+};
+const WEBP_FEATURES = ['lossy', 'lossless', 'alpha', 'animation'];
+export async function isWebPSupported(features = WEBP_FEATURES) {
+  const promises = features.map(feature => checkWebPFeature(feature));
+  const statuses = await Promise.all(promises);
+  return statuses.every(_ => _);
+}
+
+async function checkWebPFeature(feature) {
+  if (typeof Image === 'undefined') {
+    return false;
+  }
+
+  return await new Promise((resolve, reject) => {
+    const img = new Image();
+
+    img.onload = () => resolve(img.width > 0 && img.height > 0);
+
+    img.onerror = () => resolve(false);
+
+    img.src = "data:image/webp;base64,".concat(WEBP_TEST_IMAGES[feature]);
+  });
+}
+//# sourceMappingURL=webp.js.map

package/dist/esm/webp/webp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/webp/webp.ts"],"names":["WEBP_TEST_IMAGES","lossy","lossless","alpha","animation","WEBP_FEATURES","isWebPSupported","features","promises","map","feature","checkWebPFeature","statuses","Promise","all","every","_","Image","resolve","reject","img","onload","width","height","onerror","src"],"mappings":"AAAA,MAAMA,gBAAgB,GAAG;AACvBC,EAAAA,KAAK,EAAE,0DADgB;AAEvBC,EAAAA,QAAQ,EAAE,kDAFa;AAGvBC,EAAAA,KAAK,EACH,kHAJqB;AAKvBC,EAAAA,SAAS,EACP;AANqB,CAAzB;AAWA,MAAMC,aAA4B,GAAG,CAAC,OAAD,EAAU,UAAV,EAAsB,OAAtB,EAA+B,WAA/B,CAArC;AAMA,OAAO,eAAeC,eAAf,CAA+BC,QAAuB,GAAGF,aAAzD,EAA0F;AAC/F,QAAMG,QAAQ,GAAGD,QAAQ,CAACE,GAAT,CAAcC,OAAD,IAAaC,gBAAgB,CAACD,OAAD,CAA1C,CAAjB;AACA,QAAME,QAAQ,GAAG,MAAMC,OAAO,CAACC,GAAR,CAAYN,QAAZ,CAAvB;AACA,SAAOI,QAAQ,CAACG,KAAT,CAAgBC,CAAD,IAAOA,CAAtB,CAAP;AACD;;AASD,eAAeL,gBAAf,CAAgCD,OAAhC,EAAwE;AACtE,MAAI,OAAOO,KAAP,KAAiB,WAArB,EAAkC;AAChC,WAAO,KAAP;AACD;;AACD,SAAO,MAAM,IAAIJ,OAAJ,CAAY,CAACK,OAAD,EAAUC,MAAV,KAAqB;AAC5C,UAAMC,GAAG,GAAG,IAAIH,KAAJ,EAAZ;;AACAG,IAAAA,GAAG,CAACC,MAAJ,GAAa,MAAMH,OAAO,CAACE,GAAG,CAACE,KAAJ,GAAY,CAAZ,IAAiBF,GAAG,CAACG,MAAJ,GAAa,CAA/B,CAA1B;;AACAH,IAAAA,GAAG,CAACI,OAAJ,GAAc,MAAMN,OAAO,CAAC,KAAD,CAA3B;;AACAE,IAAAA,GAAG,CAACK,GAAJ,oCAAoCzB,gBAAgB,CAACU,OAAD,CAApD;AACD,GALY,CAAb;AAMD","sourcesContent":["const WEBP_TEST_IMAGES = {\n  lossy: 'UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA',\n  lossless: 'UklGRhoAAABXRUJQVlA4TA0AAAAvAAAAEAcQERGIiP4HAA==',\n  alpha:\n    'UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAARBxAR/Q9ERP8DAABWUDggGAAAABQBAJ0BKgEAAQAAAP4AAA3AAP7mtQAAAA==',\n  animation:\n    'UklGRlIAAABXRUJQVlA4WAoAAAASAAAAAAAAAAAAQU5JTQYAAAD/////AABBTk1GJgAAAAAAAAAAAAAAAAAAAGQAAABWUDhMDQAAAC8AAAAQBxAREYiI/gcA'\n};\n\nexport type WebPFeature = 'lossy' | 'lossless' | 'alpha' | 'animation';\n\nconst WEBP_FEATURES: WebPFeature[] = ['lossy', 'lossless', 'alpha', 'animation'];\n\n/**\n * Checks if WebP is supported\n * @param features Array, can include 'lossy', 'lossless', 'alpha' or 'animation'\n */\nexport async function isWebPSupported(features: WebPFeature[] = WEBP_FEATURES): Promise<boolean> {\n  const promises = features.map((feature) => checkWebPFeature(feature));\n  const statuses = await Promise.all(promises);\n  return statuses.every((_) => _);\n}\n\n/**\n * Checks if a specific WebP feature is supported\n * @param feature 'feature' can be one of 'lossy', 'lossless', 'alpha' or 'animation'.\n *\n * Based on Google's official recommended checks\n * @see https://developers.google.com/speed/webp/faq#how_can_i_detect_browser_support_for_webp\n */\nasync function checkWebPFeature(feature: WebPFeature): Promise<boolean> {\n  if (typeof Image === 'undefined') {\n    return false;\n  }\n  return await new Promise((resolve, reject) => {\n    const img = new Image();\n    img.onload = () => resolve(img.width > 0 && img.height > 0);\n    img.onerror = () => resolve(false);\n    img.src = `data:image/webp;base64,${WEBP_TEST_IMAGES[feature]}`;\n  });\n}\n"],"file":"webp.js"}

package/dist/glb-loader.d.ts

@@ -0,0 +1,13 @@
+import type { LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
+import type { GLBParseOptions } from './lib/parsers/parse-glb';
+export declare type GLBLoaderOptions = LoaderOptions & {
+    glb?: GLBParseOptions;
+    byteOffset?: number;
+};
+/**
+ * GLB Loader -
+ * GLB is the binary container format for GLTF
+ */
+export declare const GLBLoader: LoaderWithParser;
+export declare const _TypecheckGLBLoader: LoaderWithParser;
+//# sourceMappingURL=glb-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glb-loader.d.ts","sourceRoot":"","sources":["../src/glb-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE9E,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,yBAAyB,CAAC;AAI7D,oBAAY,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE,eAAe,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,gBAevB,CAAC;AAcF,eAAO,MAAM,mBAAmB,EAAE,gBAA4B,CAAC"}

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"}