@loaders.gl/draco 4.3.4 → 4.4.0-alpha.10

package/dist/draco-worker-node.js

@@ -156,9 +156,9 @@ var require_inherits = __commonJS({
   }
 });
 
-// ../../node_modules/string_decoder/index.js
+// ../../node_modules/contentstream/node_modules/string_decoder/index.js
 var require_string_decoder = __commonJS({
-  "../../node_modules/string_decoder/index.js"(exports) {
+  "../../node_modules/contentstream/node_modules/string_decoder/index.js"(exports) {
     var Buffer2 = require("buffer").Buffer;
     var isBufferEncoding = Buffer2.isEncoding || function(encoding) {
       switch (encoding && encoding.toLowerCase()) {
@@ -1685,6 +1685,144 @@ var require_stream_duplex2 = __commonJS({
   }
 });
 
+// ../../node_modules/gif-encoder/node_modules/string_decoder/index.js
+var require_string_decoder2 = __commonJS({
+  "../../node_modules/gif-encoder/node_modules/string_decoder/index.js"(exports) {
+    var Buffer2 = require("buffer").Buffer;
+    var isBufferEncoding = Buffer2.isEncoding || function(encoding) {
+      switch (encoding && encoding.toLowerCase()) {
+        case "hex":
+        case "utf8":
+        case "utf-8":
+        case "ascii":
+        case "binary":
+        case "base64":
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+        case "raw":
+          return true;
+        default:
+          return false;
+      }
+    };
+    function assertEncoding(encoding) {
+      if (encoding && !isBufferEncoding(encoding)) {
+        throw new Error("Unknown encoding: " + encoding);
+      }
+    }
+    var StringDecoder = exports.StringDecoder = function(encoding) {
+      this.encoding = (encoding || "utf8").toLowerCase().replace(/[-_]/, "");
+      assertEncoding(encoding);
+      switch (this.encoding) {
+        case "utf8":
+          this.surrogateSize = 3;
+          break;
+        case "ucs2":
+        case "utf16le":
+          this.surrogateSize = 2;
+          this.detectIncompleteChar = utf16DetectIncompleteChar;
+          break;
+        case "base64":
+          this.surrogateSize = 3;
+          this.detectIncompleteChar = base64DetectIncompleteChar;
+          break;
+        default:
+          this.write = passThroughWrite;
+          return;
+      }
+      this.charBuffer = new Buffer2(6);
+      this.charReceived = 0;
+      this.charLength = 0;
+    };
+    StringDecoder.prototype.write = function(buffer) {
+      var charStr = "";
+      while (this.charLength) {
+        var available = buffer.length >= this.charLength - this.charReceived ? this.charLength - this.charReceived : buffer.length;
+        buffer.copy(this.charBuffer, this.charReceived, 0, available);
+        this.charReceived += available;
+        if (this.charReceived < this.charLength) {
+          return "";
+        }
+        buffer = buffer.slice(available, buffer.length);
+        charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+        var charCode = charStr.charCodeAt(charStr.length - 1);
+        if (charCode >= 55296 && charCode <= 56319) {
+          this.charLength += this.surrogateSize;
+          charStr = "";
+          continue;
+        }
+        this.charReceived = this.charLength = 0;
+        if (buffer.length === 0) {
+          return charStr;
+        }
+        break;
+      }
+      this.detectIncompleteChar(buffer);
+      var end = buffer.length;
+      if (this.charLength) {
+        buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
+        end -= this.charReceived;
+      }
+      charStr += buffer.toString(this.encoding, 0, end);
+      var end = charStr.length - 1;
+      var charCode = charStr.charCodeAt(end);
+      if (charCode >= 55296 && charCode <= 56319) {
+        var size = this.surrogateSize;
+        this.charLength += size;
+        this.charReceived += size;
+        this.charBuffer.copy(this.charBuffer, size, 0, size);
+        buffer.copy(this.charBuffer, 0, 0, size);
+        return charStr.substring(0, end);
+      }
+      return charStr;
+    };
+    StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+      var i2 = buffer.length >= 3 ? 3 : buffer.length;
+      for (; i2 > 0; i2--) {
+        var c2 = buffer[buffer.length - i2];
+        if (i2 == 1 && c2 >> 5 == 6) {
+          this.charLength = 2;
+          break;
+        }
+        if (i2 <= 2 && c2 >> 4 == 14) {
+          this.charLength = 3;
+          break;
+        }
+        if (i2 <= 3 && c2 >> 3 == 30) {
+          this.charLength = 4;
+          break;
+        }
+      }
+      this.charReceived = i2;
+    };
+    StringDecoder.prototype.end = function(buffer) {
+      var res = "";
+      if (buffer && buffer.length)
+        res = this.write(buffer);
+      if (this.charReceived) {
+        var cr2 = this.charReceived;
+        var buf = this.charBuffer;
+        var enc = this.encoding;
+        res += buf.slice(0, cr2).toString(enc);
+      }
+      return res;
+    };
+    function passThroughWrite(buffer) {
+      return buffer.toString(this.encoding);
+    }
+    function utf16DetectIncompleteChar(buffer) {
+      this.charReceived = buffer.length % 2;
+      this.charLength = this.charReceived ? 2 : 0;
+    }
+    function base64DetectIncompleteChar(buffer) {
+      this.charReceived = buffer.length % 3;
+      this.charLength = this.charReceived ? 3 : 0;
+    }
+  }
+});
+
 // ../../node_modules/gif-encoder/node_modules/readable-stream/lib/_stream_readable.js
 var require_stream_readable2 = __commonJS({
   "../../node_modules/gif-encoder/node_modules/readable-stream/lib/_stream_readable.js"(exports, module2) {
@@ -1739,7 +1877,7 @@ var require_stream_readable2 = __commonJS({
       this.encoding = null;
       if (options.encoding) {
         if (!StringDecoder)
-          StringDecoder = require_string_decoder().StringDecoder;
+          StringDecoder = require_string_decoder2().StringDecoder;
         this.decoder = new StringDecoder(options.encoding);
         this.encoding = options.encoding;
       }
@@ -1811,7 +1949,7 @@ var require_stream_readable2 = __commonJS({
     }
     Readable5.prototype.setEncoding = function(enc) {
       if (!StringDecoder)
-        StringDecoder = require_string_decoder().StringDecoder;
+        StringDecoder = require_string_decoder2().StringDecoder;
       this._readableState.decoder = new StringDecoder(enc);
       this._readableState.encoding = enc;
       return this;
@@ -7024,13 +7162,13 @@ var require_iota = __commonJS({
 var require_is_buffer = __commonJS({
   "../../node_modules/is-buffer/index.js"(exports, module2) {
     module2.exports = function(obj) {
-      return obj != null && (isBuffer3(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
+      return obj != null && (isBuffer2(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
     };
-    function isBuffer3(obj) {
+    function isBuffer2(obj) {
       return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
     }
     function isSlowBuffer(obj) {
-      return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer3(obj.slice(0, 0));
+      return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer2(obj.slice(0, 0));
     }
   }
 });
@@ -7039,7 +7177,7 @@ var require_is_buffer = __commonJS({
 var require_ndarray = __commonJS({
   "../../node_modules/ndarray/ndarray.js"(exports, module2) {
     var iota = require_iota();
-    var isBuffer3 = require_is_buffer();
+    var isBuffer2 = require_is_buffer();
     var hasTypedArrays = typeof Float64Array !== "undefined";
     function compare1st(a2, b2) {
       return a2[0] - b2[0];
@@ -7201,7 +7339,7 @@ var require_ndarray = __commonJS({
       return procedure(CACHED_CONSTRUCTORS[dtype], order);
     }
     function arrayDType(data) {
-      if (isBuffer3(data)) {
+      if (isBuffer2(data)) {
         return "buffer";
       }
       if (hasTypedArrays) {
@@ -33594,7 +33732,7 @@ var require_openssh_cert = __commonJS({
       write,
       /* Internal private API */
       fromBuffer,
-      toBuffer
+      toBuffer: toBuffer3
     };
     var assert3 = require_assert();
     var SSHBuffer = require_ssh_buffer();
@@ -33734,7 +33872,7 @@ var require_openssh_cert = __commonJS({
       if (cert.signatures.openssh === void 0)
         cert.signatures.openssh = {};
       try {
-        var blob = toBuffer(cert, true);
+        var blob = toBuffer3(cert, true);
       } catch (e2) {
         delete cert.signatures.openssh;
         return false;
@@ -33752,7 +33890,7 @@ var require_openssh_cert = __commonJS({
       if (cert.signatures.openssh === void 0)
         cert.signatures.openssh = {};
       try {
-        var blob = toBuffer(cert, true);
+        var blob = toBuffer3(cert, true);
       } catch (e2) {
         delete cert.signatures.openssh;
         done(e2);
@@ -33777,13 +33915,13 @@ var require_openssh_cert = __commonJS({
     function write(cert, options) {
       if (options === void 0)
         options = {};
-      var blob = toBuffer(cert);
+      var blob = toBuffer3(cert);
       var out = getCertType(cert.subjectKey) + " " + blob.toString("base64");
       if (options.comment)
         out = out + " " + options.comment;
       return out;
     }
-    function toBuffer(cert, noSig) {
+    function toBuffer3(cert, noSig) {
       assert3.object(cert.signatures.openssh, "signature for openssh format");
       var sig = cert.signatures.openssh;
       if (sig.nonce === void 0)
@@ -47316,7 +47454,7 @@ var require_utils3 = __commonJS({
     var isRegExp = function isRegExp2(obj) {
       return Object.prototype.toString.call(obj) === "[object RegExp]";
     };
-    var isBuffer3 = function isBuffer4(obj) {
+    var isBuffer2 = function isBuffer3(obj) {
       if (obj === null || typeof obj === "undefined") {
         return false;
       }
@@ -47328,7 +47466,7 @@ var require_utils3 = __commonJS({
       compact,
       decode: decode2,
       encode: encode2,
-      isBuffer: isBuffer3,
+      isBuffer: isBuffer2,
       isRegExp,
       merge
     };
@@ -57750,11 +57888,11 @@ var require_data_uri_to_buffer = __commonJS({
 // ../../node_modules/parse-data-uri/index.js
 var require_parse_data_uri = __commonJS({
   "../../node_modules/parse-data-uri/index.js"(exports, module2) {
-    var toBuffer = require_data_uri_to_buffer();
+    var toBuffer3 = require_data_uri_to_buffer();
     function parseDataUri(dataUri) {
       return {
         mimeType: normalizeMimeType(parseMimeType(dataUri)),
-        data: toBuffer(dataUri)
+        data: toBuffer3(dataUri)
       };
     }
     function parseMimeType(uri) {
@@ -59668,6 +59806,9 @@ function getPixelsAsync(buffer, mimeType) {
   );
 }
 
+// ../loader-utils/src/lib/javascript-utils/is-type.ts
+var isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+
 // ../worker-utils/src/lib/env-utils/version.ts
 function getVersion() {
   var _a;
@@ -59678,8 +59819,9 @@ function getVersion() {
         "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
       );
       globalThis._loadersgl_.version = NPM_TAG;
+      warningIssued = true;
     } else {
-      globalThis._loadersgl_.version = "4.3.3";
+      globalThis._loadersgl_.version = "4.4.0-alpha.10";
     }
   }
   return globalThis._loadersgl_.version;
@@ -59850,6 +59992,9 @@ async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryN
   return await loadLibraryPromises[libraryUrl];
 }
 function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+  if (options == null ? void 0 : options.core) {
+    throw new Error("loadLibrary: options.core must be pre-normalized");
+  }
   if (!options.useLocalLibraries && library.startsWith("http")) {
     return library;
   }
@@ -59875,10 +60020,20 @@ async function loadLibraryFromFile(libraryUrl) {
     return await loadAsArrayBuffer(libraryUrl);
   }
   if (!isBrowser2) {
+    const { requireFromFile: requireFromFile2 } = globalThis.loaders || {};
     try {
-      const { requireFromFile: requireFromFile2 } = globalThis.loaders || {};
-      return await (requireFromFile2 == null ? void 0 : requireFromFile2(libraryUrl));
+      const result = await (requireFromFile2 == null ? void 0 : requireFromFile2(libraryUrl));
+      if (result || !libraryUrl.includes("/dist/libs/")) {
+        return result;
+      }
+      return await (requireFromFile2 == null ? void 0 : requireFromFile2(libraryUrl.replace("/dist/libs/", "/src/libs/")));
     } catch (error) {
+      if (libraryUrl.includes("/dist/libs/")) {
+        try {
+          return await (requireFromFile2 == null ? void 0 : requireFromFile2(libraryUrl.replace("/dist/libs/", "/src/libs/")));
+        } catch {
+        }
+      }
       console.error(error);
       return null;
     }
@@ -59914,7 +60069,14 @@ async function loadAsArrayBuffer(url) {
     const response = await fetch(url);
     return await response.arrayBuffer();
   }
-  return await readFileAsArrayBuffer2(url);
+  try {
+    return await readFileAsArrayBuffer2(url);
+  } catch {
+    if (url.includes("/dist/libs/")) {
+      return await readFileAsArrayBuffer2(url.replace("/dist/libs/", "/src/libs/"));
+    }
+    throw new Error(`Failed to load ArrayBuffer from ${url}`);
+  }
 }
 async function loadAsText(url) {
   const { readFileAsText: readFileAsText2 } = globalThis.loaders || {};
@@ -59922,7 +60084,14 @@ async function loadAsText(url) {
     const response = await fetch(url);
     return await response.text();
   }
-  return await readFileAsText2(url);
+  try {
+    return await readFileAsText2(url);
+  } catch {
+    if (url.includes("/dist/libs/")) {
+      return await readFileAsText2(url.replace("/dist/libs/", "/src/libs/"));
+    }
+    throw new Error(`Failed to load text from ${url}`);
+  }
 }
 
 // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
@@ -60001,7 +60170,10 @@ async function parseData({
   options = {
     ...options,
     modules: loader && loader.options && loader.options.modules || {},
-    worker: false
+    core: {
+      ...options.core,
+      worker: false
+    }
   };
   return await parser(data, { ...options }, context, loader);
 }
@@ -60028,10 +60200,26 @@ function concatenateArrayBuffersFromArray(sources) {
 async function concatenateArrayBuffersAsync(asyncIterator) {
   const arrayBuffers = [];
   for await (const chunk of asyncIterator) {
-    arrayBuffers.push(chunk);
+    arrayBuffers.push(copyToArrayBuffer(chunk));
   }
   return concatenateArrayBuffers(...arrayBuffers);
 }
+function copyToArrayBuffer(chunk) {
+  if (chunk instanceof ArrayBuffer) {
+    return chunk;
+  }
+  if (ArrayBuffer.isView(chunk)) {
+    const { buffer, byteOffset, byteLength } = chunk;
+    return copyFromBuffer(buffer, byteOffset, byteLength);
+  }
+  return copyFromBuffer(chunk);
+}
+function copyFromBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+  const view = new Uint8Array(buffer, byteOffset, byteLength);
+  const copy = new Uint8Array(view.length);
+  copy.set(view);
+  return copy.buffer;
+}
 
 // ../loader-utils/src/lib/path-utils/file-aliases.ts
 var pathPrefix = "";
@@ -60049,6 +60237,66 @@ function resolvePath(filename) {
   return filename;
 }
 
+// ../loader-utils/src/lib/node/buffer.ts
+function toArrayBuffer(buffer) {
+  if (Buffer.isBuffer(buffer)) {
+    const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
+    return typedArray.slice().buffer;
+  }
+  return buffer;
+}
+
+// ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+function isBuffer(value) {
+  return value && typeof value === "object" && value.isBuffer;
+}
+function toArrayBuffer2(data) {
+  if (isBuffer(data)) {
+    return toArrayBuffer(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return data;
+  }
+  if (isSharedArrayBuffer(data)) {
+    return copyToArrayBuffer2(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    const buffer = data.buffer;
+    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+      return buffer;
+    }
+    return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  }
+  if (typeof data === "string") {
+    const text = data;
+    const uint8Array = new TextEncoder().encode(text);
+    return uint8Array.buffer;
+  }
+  if (data && typeof data === "object" && data._toArrayBuffer) {
+    return data._toArrayBuffer();
+  }
+  throw new Error("toArrayBuffer");
+}
+function ensureArrayBuffer(bufferSource) {
+  if (bufferSource instanceof ArrayBuffer) {
+    return bufferSource;
+  }
+  if (isSharedArrayBuffer(bufferSource)) {
+    return copyToArrayBuffer2(bufferSource);
+  }
+  const { buffer, byteOffset, byteLength } = bufferSource;
+  if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+    return buffer;
+  }
+  return copyToArrayBuffer2(buffer, byteOffset, byteLength);
+}
+function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+  const view = new Uint8Array(buffer, byteOffset, byteLength);
+  const copy = new Uint8Array(view.length);
+  copy.set(view);
+  return copy.buffer;
+}
+
 // ../polyfills/src/filesystems/node-file.ts
 var import_fs = __toESM(require("fs"), 1);
 var NodeFile = class {
@@ -60174,8 +60422,6 @@ var import_stream = require("stream");
 
 // ../polyfills/src/filesystems/stream-utils.node.ts
 var import_zlib = __toESM(require("zlib"), 1);
-var isArrayBuffer = (x2) => x2 && x2 instanceof ArrayBuffer;
-var isBuffer = (x2) => x2 && x2 instanceof Buffer;
 function decompressReadStream(readStream, headers) {
   switch (headers == null ? void 0 : headers.get("content-encoding")) {
     case "br":
@@ -60197,7 +60443,7 @@ async function concatenateReadStream(readStream) {
       if (typeof chunk === "string") {
         reject(new Error("Read stream not binary"));
       }
-      arrayBufferChunks.push(toArrayBuffer(chunk));
+      arrayBufferChunks.push(toArrayBuffer2(chunk));
     });
     readStream.on("end", () => {
       const arrayBuffer = concatenateArrayBuffers2(arrayBufferChunks);
@@ -60218,27 +60464,6 @@ function concatenateArrayBuffers2(sources) {
   }
   return result.buffer;
 }
-function toArrayBuffer(data) {
-  if (isArrayBuffer(data)) {
-    return data;
-  }
-  if (isBuffer(data)) {
-    const typedArray = new Uint8Array(data);
-    return typedArray.buffer;
-  }
-  if (ArrayBuffer.isView(data)) {
-    return data.buffer;
-  }
-  if (typeof data === "string") {
-    const text = data;
-    const uint8Array = new TextEncoder().encode(text);
-    return uint8Array.buffer;
-  }
-  if (data && typeof data === "object" && data._toArrayBuffer) {
-    return data._toArrayBuffer();
-  }
-  throw new Error(`toArrayBuffer(${JSON.stringify(data, null, 2).slice(10)})`);
-}
 
 // ../polyfills/src/filesystems/fetch-node.ts
 var isBoolean = (x2) => typeof x2 === "boolean";
@@ -60252,10 +60477,10 @@ async function fetchNode(url, options) {
   noqueryUrl = resolvePath(noqueryUrl);
   const responseHeaders = new Headers();
   if (url.endsWith(".gz")) {
-    responseHeaders["content-encoding"] = "gzip";
+    responseHeaders.set("content-encoding", "gzip");
   }
   if (url.endsWith(".br")) {
-    responseHeaders["content-encoding"] = "br";
+    responseHeaders.set("content-encoding", "br");
   }
   try {
     const body = await new Promise((resolve, reject) => {
@@ -62936,7 +63161,7 @@ async function readFileAsArrayBuffer(filename) {
     return await response.arrayBuffer();
   }
   const buffer = import_fs3.default.readFileSync(filename);
-  return buffer.buffer;
+  return ensureArrayBuffer(buffer.buffer);
 }
 async function readFileAsText(filename) {
   if (filename.startsWith("http")) {
@@ -63150,8 +63375,6 @@ var import_http = __toESM(require("http"), 1);
 var import_https = __toESM(require("https"), 1);
 
 // ../polyfills/src/fetch/decode-data-uri.ts
-var isArrayBuffer2 = (x2) => x2 && x2 instanceof ArrayBuffer;
-var isBuffer2 = (x2) => x2 && x2 instanceof Buffer;
 function decodeDataUri(uri) {
   const dataIndex = uri.indexOf(",");
   let buffer;
@@ -63170,27 +63393,6 @@ function decodeDataUri(uri) {
   }
   return { arrayBuffer: toArrayBuffer2(buffer), mimeType };
 }
-function toArrayBuffer2(data) {
-  if (isArrayBuffer2(data)) {
-    return data;
-  }
-  if (isBuffer2(data)) {
-    const typedArray = new Uint8Array(data);
-    return typedArray.buffer;
-  }
-  if (ArrayBuffer.isView(data)) {
-    return data.buffer;
-  }
-  if (typeof data === "string") {
-    const text = data;
-    const uint8Array = new TextEncoder().encode(text);
-    return uint8Array.buffer;
-  }
-  if (data && typeof data === "object" && data._toArrayBuffer) {
-    return data._toArrayBuffer();
-  }
-  throw new Error(`toArrayBuffer(${JSON.stringify(data, null, 2).slice(10)})`);
-}
 
 // ../polyfills/src/fetch/fetch-polyfill.ts
 var isDataURL = (url) => url.startsWith("data:");
@@ -63343,35 +63545,126 @@ if (nodeVersion2 < 18) {
   }
 }
 
-// src/lib/utils/version.ts
-var VERSION2 = true ? "4.3.3" : "latest";
-
-// src/draco-loader.ts
-var DracoLoader = {
-  dataType: null,
-  batchType: null,
-  name: "Draco",
-  id: "draco",
-  module: "draco",
-  // shapes: ['mesh'],
-  version: VERSION2,
-  worker: true,
-  extensions: ["drc"],
-  mimeTypes: ["application/octet-stream"],
-  binary: true,
-  tests: ["DRACO"],
-  options: {
-    draco: {
-      decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
-      // 'js' for IE11
-      libraryPath: "libs/",
-      extraAttributes: {},
-      attributeNameEntry: void 0
+// src/lib/draco-module-loader.ts
+var DRACO_DECODER_VERSION = "1.5.6";
+var DRACO_ENCODER_VERSION = "1.4.1";
+var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
+var DRACO_EXTERNAL_LIBRARIES = {
+  /** The primary Draco3D encoder, javascript wrapper part */
+  DECODER: "draco_wasm_wrapper.js",
+  /** The primary draco decoder, compiled web assembly part */
+  DECODER_WASM: "draco_decoder.wasm",
+  /** Fallback decoder for non-webassebly environments. Very big bundle, lower performance */
+  FALLBACK_DECODER: "draco_decoder.js",
+  /** Draco encoder */
+  ENCODER: "draco_encoder.js"
+};
+var DRACO_EXTERNAL_LIBRARY_URLS = {
+  [DRACO_EXTERNAL_LIBRARIES.DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER}`,
+  [DRACO_EXTERNAL_LIBRARIES.DECODER_WASM]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER_WASM}`,
+  [DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER}`,
+  [DRACO_EXTERNAL_LIBRARIES.ENCODER]: `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/${DRACO_EXTERNAL_LIBRARIES.ENCODER}`
+};
+var loadDecoderPromise;
+async function loadDracoDecoderModule(options = {}, type) {
+  const modules = options.modules || {};
+  if (modules.draco3d) {
+    loadDecoderPromise ||= modules.draco3d.createDecoderModule({}).then((draco) => {
+      return { draco };
+    });
+  } else {
+    loadDecoderPromise ||= loadDracoDecoder(options, type);
+  }
+  return await loadDecoderPromise;
+}
+function getLibraryExport(library, exportName) {
+  if (library && typeof library === "object") {
+    if (library.default) {
+      return library.default;
+    }
+    if (library[exportName]) {
+      return library[exportName];
     }
   }
-};
+  return library;
+}
+async function loadDracoDecoder(options, type) {
+  let DracoDecoderModule;
+  let wasmBinary;
+  switch (type) {
+    case "js":
+      DracoDecoderModule = await loadLibrary(
+        DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER],
+        "draco",
+        options,
+        DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER
+      );
+      break;
+    case "wasm":
+    default:
+      try {
+        [DracoDecoderModule, wasmBinary] = await Promise.all([
+          await loadLibrary(
+            DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
+            "draco",
+            options,
+            DRACO_EXTERNAL_LIBRARIES.DECODER
+          ),
+          await loadLibrary(
+            DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
+            "draco",
+            options,
+            DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
+          )
+        ]);
+      } catch {
+        DracoDecoderModule = null;
+        wasmBinary = null;
+      }
+  }
+  DracoDecoderModule = getLibraryExport(DracoDecoderModule, "DracoDecoderModule");
+  DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
+  if (!DracoDecoderModule && !isBrowser2) {
+    [DracoDecoderModule, wasmBinary] = await Promise.all([
+      await loadLibrary(
+        DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
+        "draco",
+        { ...options, useLocalLibraries: true },
+        DRACO_EXTERNAL_LIBRARIES.DECODER
+      ),
+      await loadLibrary(
+        DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
+        "draco",
+        { ...options, useLocalLibraries: true },
+        DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
+      )
+    ]);
+    DracoDecoderModule = getLibraryExport(DracoDecoderModule, "DracoDecoderModule");
+    DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
+  }
+  return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);
+}
+function initializeDracoDecoder(DracoDecoderModule, wasmBinary) {
+  if (typeof DracoDecoderModule !== "function") {
+    throw new Error("DracoDecoderModule could not be loaded");
+  }
+  const options = {};
+  if (wasmBinary) {
+    options.wasmBinary = wasmBinary;
+  }
+  return new Promise((resolve) => {
+    DracoDecoderModule({
+      ...options,
+      onModuleLoaded: (draco) => resolve({ draco })
+      // Module is Promise-like. Wrap in object to avoid loop.
+    });
+  });
+}
+
+// src/lib/utils/version.ts
+var VERSION2 = true ? "4.4.0-alpha.10" : "latest";
 
-// ../schema/src/lib/table/simple-table/data-type.ts
+// ../schema-utils/src/lib/schema/data-type.ts
 function getDataTypeFromTypedArray(array) {
   switch (array.constructor) {
     case Int8Array:
@@ -63396,7 +63689,7 @@ function getDataTypeFromTypedArray(array) {
   }
 }
 
-// ../schema/src/lib/mesh/mesh-utils.ts
+// ../schema-utils/src/lib/mesh/mesh-utils.ts
 function getMeshBoundingBox(attributes) {
   let minX = Infinity;
   let minY = Infinity;
@@ -63423,7 +63716,7 @@ function getMeshBoundingBox(attributes) {
   ];
 }
 
-// ../schema/src/lib/mesh/deduce-mesh-schema.ts
+// ../schema-utils/src/lib/mesh/deduce-mesh-schema.ts
 function deduceMeshField(name, attribute, optionalMetadata) {
   const type = getDataTypeFromTypedArray(attribute.value);
   const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
@@ -63647,6 +63940,7 @@ var DracoParser = class {
         case "triangle-strip":
           return {
             topology: "triangle-strip",
+            // TODO - mode is wrong?
             mode: 4,
             // GL.TRIANGLES
             attributes,
@@ -63659,6 +63953,7 @@ var DracoParser = class {
         default:
           return {
             topology: "triangle-list",
+            // TODO - mode is wrong?
             mode: 5,
             // GL.TRIANGLE_STRIP
             attributes,
@@ -63943,91 +64238,40 @@ function getUint32Array(dracoArray) {
   return intArray;
 }
 
-// src/lib/draco-module-loader.ts
-var DRACO_DECODER_VERSION = "1.5.6";
-var DRACO_ENCODER_VERSION = "1.4.1";
-var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
-var DRACO_EXTERNAL_LIBRARIES = {
-  /** The primary Draco3D encoder, javascript wrapper part */
-  DECODER: "draco_wasm_wrapper.js",
-  /** The primary draco decoder, compiled web assembly part */
-  DECODER_WASM: "draco_decoder.wasm",
-  /** Fallback decoder for non-webassebly environments. Very big bundle, lower performance */
-  FALLBACK_DECODER: "draco_decoder.js",
-  /** Draco encoder */
-  ENCODER: "draco_encoder.js"
-};
-var DRACO_EXTERNAL_LIBRARY_URLS = {
-  [DRACO_EXTERNAL_LIBRARIES.DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER}`,
-  [DRACO_EXTERNAL_LIBRARIES.DECODER_WASM]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER_WASM}`,
-  [DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER}`,
-  [DRACO_EXTERNAL_LIBRARIES.ENCODER]: `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/${DRACO_EXTERNAL_LIBRARIES.ENCODER}`
-};
-var loadDecoderPromise;
-async function loadDracoDecoderModule(options) {
-  const modules = options.modules || {};
-  if (modules.draco3d) {
-    loadDecoderPromise ||= modules.draco3d.createDecoderModule({}).then((draco) => {
-      return { draco };
-    });
-  } else {
-    loadDecoderPromise ||= loadDracoDecoder(options);
-  }
-  return await loadDecoderPromise;
-}
-async function loadDracoDecoder(options) {
-  let DracoDecoderModule;
-  let wasmBinary;
-  switch (options.draco && options.draco.decoderType) {
-    case "js":
-      DracoDecoderModule = await loadLibrary(
-        DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER],
-        "draco",
-        options,
-        DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER
-      );
-      break;
-    case "wasm":
-    default:
-      [DracoDecoderModule, wasmBinary] = await Promise.all([
-        await loadLibrary(
-          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
-          "draco",
-          options,
-          DRACO_EXTERNAL_LIBRARIES.DECODER
-        ),
-        await loadLibrary(
-          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
-          "draco",
-          options,
-          DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
-        )
-      ]);
-  }
-  DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
-  return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);
-}
-function initializeDracoDecoder(DracoDecoderModule, wasmBinary) {
-  const options = {};
-  if (wasmBinary) {
-    options.wasmBinary = wasmBinary;
+// src/draco-loader.ts
+var DracoWorkerLoader = {
+  dataType: null,
+  batchType: null,
+  name: "Draco",
+  id: "draco",
+  module: "draco",
+  // shapes: ['mesh'],
+  version: VERSION2,
+  worker: true,
+  extensions: ["drc"],
+  mimeTypes: ["application/octet-stream"],
+  binary: true,
+  tests: ["DRACO"],
+  options: {
+    draco: {
+      decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
+      // 'js' for IE11
+      libraryPath: "libs/",
+      extraAttributes: {},
+      attributeNameEntry: void 0
+    }
   }
-  return new Promise((resolve) => {
-    DracoDecoderModule({
-      ...options,
-      onModuleLoaded: (draco) => resolve({ draco })
-      // Module is Promise-like. Wrap in object to avoid loop.
-    });
-  });
-}
-
-// src/index.ts
-var DracoLoader2 = {
-  ...DracoLoader,
+};
+var DracoLoader = {
+  ...DracoWorkerLoader,
   parse
 };
 async function parse(arrayBuffer, options) {
-  const { draco } = await loadDracoDecoderModule(options);
+  var _a;
+  const { draco } = await loadDracoDecoderModule(
+    options == null ? void 0 : options.core,
+    ((_a = options == null ? void 0 : options.draco) == null ? void 0 : _a.decoderType) || "wasm"
+  );
   const dracoParser = new DracoParser(draco);
   try {
     return dracoParser.parseSync(arrayBuffer, options == null ? void 0 : options.draco);
@@ -64037,7 +64281,7 @@ async function parse(arrayBuffer, options) {
 }
 
 // src/workers/draco-worker-node.ts
-createLoaderWorker(DracoLoader2);
+createLoaderWorker(DracoLoader);
 /*! Bundled license information:
 
 is-buffer/index.js: