@loaders.gl/3d-tiles 3.1.0-beta.2 → 3.1.1

package/dist/bundle.js

@@ -1,5 +1,10 @@
 (() => {
+  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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
   var __esm = (fn, res) => function __init() {
     return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
@@ -12,6 +17,17 @@
     for (var name8 in all)
       __defProp(target, name8, { get: all[name8], enumerable: true });
   };
+  var __reExport = (target, module2, desc) => {
+    if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+      for (let key of __getOwnPropNames(module2))
+        if (!__hasOwnProp.call(target, key) && key !== "default")
+          __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+    }
+    return target;
+  };
+  var __toModule = (module2) => {
+    return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+  };
 
   // ../loader-utils/src/lib/env-utils/assert.ts
   function assert2(condition, message) {
@@ -48,7 +64,7 @@
   var DEFAULT_VERSION, VERSION;
   var init_version = __esm({
     "../worker-utils/src/lib/env-utils/version.ts"() {
-      DEFAULT_VERSION = "beta";
+      DEFAULT_VERSION = "latest";
       VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : DEFAULT_VERSION;
       if (typeof __VERSION__ === "undefined") {
         console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
@@ -89,8 +105,423 @@
     }
   });
 
+  // ../worker-utils/src/lib/worker-farm/worker-job.ts
+  var WorkerJob;
+  var init_worker_job = __esm({
+    "../worker-utils/src/lib/worker-farm/worker-job.ts"() {
+      init_assert2();
+      WorkerJob = class {
+        constructor(jobName, workerThread) {
+          this.name = jobName;
+          this.workerThread = workerThread;
+          this.isRunning = true;
+          this._resolve = () => {
+          };
+          this._reject = () => {
+          };
+          this.result = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+          });
+        }
+        postMessage(type, payload) {
+          this.workerThread.postMessage({
+            source: "loaders.gl",
+            type,
+            payload
+          });
+        }
+        done(value) {
+          assert3(this.isRunning);
+          this.isRunning = false;
+          this._resolve(value);
+        }
+        error(error) {
+          assert3(this.isRunning);
+          this.isRunning = false;
+          this._reject(error);
+        }
+      };
+    }
+  });
+
+  // ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
+  function getLoadableWorkerURL(props) {
+    assert3(props.source && !props.url || !props.source && props.url);
+    let workerURL = workerURLCache.get(props.source || props.url);
+    if (!workerURL) {
+      if (props.url) {
+        workerURL = getLoadableWorkerURLFromURL(props.url);
+        workerURLCache.set(props.url, workerURL);
+      }
+      if (props.source) {
+        workerURL = getLoadableWorkerURLFromSource(props.source);
+        workerURLCache.set(props.source, workerURL);
+      }
+    }
+    assert3(workerURL);
+    return workerURL;
+  }
+  function getLoadableWorkerURLFromURL(url) {
+    if (!url.startsWith("http")) {
+      return url;
+    }
+    const workerSource = buildScriptSource(url);
+    return getLoadableWorkerURLFromSource(workerSource);
+  }
+  function getLoadableWorkerURLFromSource(workerSource) {
+    const blob = new Blob([workerSource], { type: "application/javascript" });
+    return URL.createObjectURL(blob);
+  }
+  function buildScriptSource(workerUrl) {
+    return `try {
+  importScripts('${workerUrl}');
+} catch (error) {
+  console.error(error);
+  throw error;
+}`;
+  }
+  var workerURLCache;
+  var init_get_loadable_worker_url = __esm({
+    "../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts"() {
+      init_assert2();
+      workerURLCache = new Map();
+    }
+  });
+
+  // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
+  function getTransferList(object, recursive = true, transfers) {
+    const transfersSet = transfers || new Set();
+    if (!object) {
+    } else if (isTransferable(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList(object[key], recursive, transfersSet);
+      }
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
+  }
+  function isTransferable(object) {
+    if (!object) {
+      return false;
+    }
+    if (object instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
+    }
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
+    }
+    return false;
+  }
+  var init_get_transfer_list = __esm({
+    "../worker-utils/src/lib/worker-utils/get-transfer-list.ts"() {
+    }
+  });
+
+  // ../worker-utils/src/lib/worker-farm/worker-thread.ts
+  var NOOP, WorkerThread;
+  var init_worker_thread = __esm({
+    "../worker-utils/src/lib/worker-farm/worker-thread.ts"() {
+      init_assert2();
+      init_get_loadable_worker_url();
+      init_get_transfer_list();
+      NOOP = () => {
+      };
+      WorkerThread = class {
+        constructor(props) {
+          this.terminated = false;
+          this._loadableURL = "";
+          const { name: name8, source, url } = props;
+          assert3(source || url);
+          this.name = name8;
+          this.source = source;
+          this.url = url;
+          this.onMessage = NOOP;
+          this.onError = (error) => console.log(error);
+          this.worker = this._createBrowserWorker();
+        }
+        static isSupported() {
+          return typeof Worker !== "undefined";
+        }
+        destroy() {
+          this.onMessage = NOOP;
+          this.onError = NOOP;
+          this.worker.terminate();
+          this.terminated = true;
+        }
+        get isRunning() {
+          return Boolean(this.onMessage);
+        }
+        postMessage(data, transferList) {
+          transferList = transferList || getTransferList(data);
+          this.worker.postMessage(data, transferList);
+        }
+        _getErrorFromErrorEvent(event) {
+          let message = "Failed to load ";
+          message += `worker ${this.name} from ${this.url}. `;
+          if (event.message) {
+            message += `${event.message} in `;
+          }
+          if (event.lineno) {
+            message += `:${event.lineno}:${event.colno}`;
+          }
+          return new Error(message);
+        }
+        _createBrowserWorker() {
+          this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url });
+          const worker = new Worker(this._loadableURL, { name: this.name });
+          worker.onmessage = (event) => {
+            if (!event.data) {
+              this.onError(new Error("No data received"));
+            } else {
+              this.onMessage(event.data);
+            }
+          };
+          worker.onerror = (error) => {
+            this.onError(this._getErrorFromErrorEvent(error));
+            this.terminated = true;
+          };
+          worker.onmessageerror = (event) => console.error(event);
+          return worker;
+        }
+      };
+    }
+  });
+
+  // ../worker-utils/src/lib/worker-farm/worker-pool.ts
+  var WorkerPool;
+  var init_worker_pool = __esm({
+    "../worker-utils/src/lib/worker-farm/worker-pool.ts"() {
+      init_globals2();
+      init_worker_thread();
+      init_worker_job();
+      WorkerPool = class {
+        constructor(props) {
+          this.name = "unnamed";
+          this.maxConcurrency = 1;
+          this.maxMobileConcurrency = 1;
+          this.onDebug = () => {
+          };
+          this.reuseWorkers = true;
+          this.props = {};
+          this.jobQueue = [];
+          this.idleQueue = [];
+          this.count = 0;
+          this.isDestroyed = false;
+          this.source = props.source;
+          this.url = props.url;
+          this.setProps(props);
+        }
+        destroy() {
+          this.idleQueue.forEach((worker) => worker.destroy());
+          this.isDestroyed = true;
+        }
+        setProps(props) {
+          this.props = { ...this.props, ...props };
+          if (props.name !== void 0) {
+            this.name = props.name;
+          }
+          if (props.maxConcurrency !== void 0) {
+            this.maxConcurrency = props.maxConcurrency;
+          }
+          if (props.maxMobileConcurrency !== void 0) {
+            this.maxMobileConcurrency = props.maxMobileConcurrency;
+          }
+          if (props.reuseWorkers !== void 0) {
+            this.reuseWorkers = props.reuseWorkers;
+          }
+          if (props.onDebug !== void 0) {
+            this.onDebug = props.onDebug;
+          }
+        }
+        async startJob(name8, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+          const startPromise = new Promise((onStart) => {
+            this.jobQueue.push({ name: name8, onMessage: onMessage2, onError, onStart });
+            return this;
+          });
+          this._startQueuedJob();
+          return await startPromise;
+        }
+        async _startQueuedJob() {
+          if (!this.jobQueue.length) {
+            return;
+          }
+          const workerThread = this._getAvailableWorker();
+          if (!workerThread) {
+            return;
+          }
+          const queuedJob = this.jobQueue.shift();
+          if (queuedJob) {
+            this.onDebug({
+              message: "Starting job",
+              name: queuedJob.name,
+              workerThread,
+              backlog: this.jobQueue.length
+            });
+            const job = new WorkerJob(queuedJob.name, workerThread);
+            workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
+            workerThread.onError = (error) => queuedJob.onError(job, error);
+            queuedJob.onStart(job);
+            try {
+              await job.result;
+            } finally {
+              this.returnWorkerToQueue(workerThread);
+            }
+          }
+        }
+        returnWorkerToQueue(worker) {
+          const shouldDestroyWorker = this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
+          if (shouldDestroyWorker) {
+            worker.destroy();
+            this.count--;
+          } else {
+            this.idleQueue.push(worker);
+          }
+          if (!this.isDestroyed) {
+            this._startQueuedJob();
+          }
+        }
+        _getAvailableWorker() {
+          if (this.idleQueue.length > 0) {
+            return this.idleQueue.shift() || null;
+          }
+          if (this.count < this._getMaxConcurrency()) {
+            this.count++;
+            const name8 = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
+            return new WorkerThread({ name: name8, source: this.source, url: this.url });
+          }
+          return null;
+        }
+        _getMaxConcurrency() {
+          return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
+        }
+      };
+    }
+  });
+
+  // ../worker-utils/src/lib/worker-farm/worker-farm.ts
+  var DEFAULT_PROPS, WorkerFarm;
+  var init_worker_farm = __esm({
+    "../worker-utils/src/lib/worker-farm/worker-farm.ts"() {
+      init_worker_pool();
+      init_worker_thread();
+      DEFAULT_PROPS = {
+        maxConcurrency: 3,
+        maxMobileConcurrency: 1,
+        onDebug: () => {
+        },
+        reuseWorkers: true
+      };
+      WorkerFarm = class {
+        constructor(props) {
+          this.workerPools = new Map();
+          this.props = { ...DEFAULT_PROPS };
+          this.setProps(props);
+          this.workerPools = new Map();
+        }
+        static isSupported() {
+          return WorkerThread.isSupported();
+        }
+        static getWorkerFarm(props = {}) {
+          WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});
+          WorkerFarm._workerFarm.setProps(props);
+          return WorkerFarm._workerFarm;
+        }
+        destroy() {
+          for (const workerPool of this.workerPools.values()) {
+            workerPool.destroy();
+          }
+        }
+        setProps(props) {
+          this.props = { ...this.props, ...props };
+          for (const workerPool of this.workerPools.values()) {
+            workerPool.setProps(this._getWorkerPoolProps());
+          }
+        }
+        getWorkerPool(options) {
+          const { name: name8, source, url } = options;
+          let workerPool = this.workerPools.get(name8);
+          if (!workerPool) {
+            workerPool = new WorkerPool({
+              name: name8,
+              source,
+              url
+            });
+            workerPool.setProps(this._getWorkerPoolProps());
+            this.workerPools.set(name8, workerPool);
+          }
+          return workerPool;
+        }
+        _getWorkerPoolProps() {
+          return {
+            maxConcurrency: this.props.maxConcurrency,
+            maxMobileConcurrency: this.props.maxMobileConcurrency,
+            reuseWorkers: this.props.reuseWorkers,
+            onDebug: this.props.onDebug
+          };
+        }
+      };
+    }
+  });
+
+  // ../worker-utils/src/lib/worker-api/get-worker-url.ts
+  function getWorkerURL(worker, options = {}) {
+    const workerOptions = options[worker.id] || {};
+    const workerFile = `${worker.id}-worker.js`;
+    let url = workerOptions.workerUrl;
+    if (!url && worker.id === "compression") {
+      url = options.workerUrl;
+    }
+    if (options._workerType === "test") {
+      url = `modules/${worker.module}/dist/${workerFile}`;
+    }
+    if (!url) {
+      let version = worker.version;
+      if (version === "latest") {
+        version = NPM_TAG;
+      }
+      const versionTag = version ? `@${version}` : "";
+      url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+    }
+    assert3(url);
+    return url;
+  }
+  var NPM_TAG;
+  var init_get_worker_url = __esm({
+    "../worker-utils/src/lib/worker-api/get-worker-url.ts"() {
+      init_assert2();
+      NPM_TAG = "latest";
+    }
+  });
+
+  // ../worker-utils/src/lib/worker-api/validate-worker-version.ts
+  function validateWorkerVersion(worker, coreVersion = VERSION) {
+    assert3(worker, "no worker provided");
+    const workerVersion = worker.version;
+    if (!coreVersion || !workerVersion) {
+      return false;
+    }
+    return true;
+  }
+  var init_validate_worker_version = __esm({
+    "../worker-utils/src/lib/worker-api/validate-worker-version.ts"() {
+      init_assert2();
+      init_version();
+    }
+  });
+
   // (disabled):../worker-utils/src/lib/node/require-utils.node
-  var init_require_utils = __esm({
+  var require_require_utils = __commonJS({
     "(disabled):../worker-utils/src/lib/node/require-utils.node"() {
     }
   });
@@ -129,7 +560,11 @@
       return await response2.arrayBuffer();
     }
     if (!isBrowser2) {
-      return node.requireFromFile && await node.requireFromFile(libraryUrl);
+      try {
+        return node && node.requireFromFile && await node.requireFromFile(libraryUrl);
+      } catch {
+        return null;
+      }
     }
     if (isWorker) {
       return importScripts(libraryUrl);
@@ -156,14 +591,14 @@
     document.body.appendChild(script);
     return null;
   }
-  var LATEST, VERSION2, loadLibraryPromises;
+  var node, LATEST, VERSION2, loadLibraryPromises;
   var init_library_utils = __esm({
     "../worker-utils/src/lib/library-utils/library-utils.ts"() {
       init_globals2();
-      init_require_utils();
+      node = __toModule(require_require_utils());
       init_assert2();
       init_version();
-      LATEST = "beta";
+      LATEST = "latest";
       VERSION2 = typeof VERSION !== "undefined" ? VERSION : LATEST;
       loadLibraryPromises = {};
     }
@@ -172,10 +607,63 @@
   // ../worker-utils/src/index.ts
   var init_src = __esm({
     "../worker-utils/src/index.ts"() {
+      init_assert2();
+      init_worker_farm();
+      init_get_worker_url();
+      init_validate_worker_version();
       init_library_utils();
     }
   });
 
+  // ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
+  function canParseWithWorker(loader, options) {
+    if (!WorkerFarm.isSupported()) {
+      return false;
+    }
+    return loader.worker && options?.worker;
+  }
+  async function parseWithWorker(loader, data, options, context, parseOnMainThread) {
+    const name8 = loader.id;
+    const url = getWorkerURL(loader, options);
+    const workerFarm = WorkerFarm.getWorkerFarm(options);
+    const workerPool = workerFarm.getWorkerPool({ name: name8, url });
+    options = JSON.parse(JSON.stringify(options));
+    const job = await workerPool.startJob("process-on-worker", onMessage.bind(null, parseOnMainThread));
+    job.postMessage("process", {
+      input: data,
+      options
+    });
+    const result = await job.result;
+    return await result.result;
+  }
+  async function onMessage(parseOnMainThread, job, type, payload) {
+    switch (type) {
+      case "done":
+        job.done(payload);
+        break;
+      case "error":
+        job.error(new Error(payload.error));
+        break;
+      case "process":
+        const { id, input, options } = payload;
+        try {
+          const result = await parseOnMainThread(input, options);
+          job.postMessage("done", { id, result });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "unknown error";
+          job.postMessage("error", { id, error: message });
+        }
+        break;
+      default:
+        console.warn(`parse-with-worker unknown message ${type}`);
+    }
+  }
+  var init_parse_with_worker = __esm({
+    "../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts"() {
+      init_src();
+    }
+  });
+
   // ../loader-utils/src/lib/binary-utils/get-first-characters.ts
   function getFirstCharacters(data, length4 = 5) {
     if (typeof data === "string") {
@@ -218,7 +706,71 @@
     }
   });
 
+  // ../loader-utils/src/lib/binary-utils/buffer-utils.ts
+  function isBuffer(value) {
+    return value && typeof value === "object" && value.isBuffer;
+  }
+  function bufferToArrayBuffer(buffer) {
+    if (isBuffer(buffer)) {
+      const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
+      return typedArray.slice().buffer;
+    }
+    return buffer;
+  }
+  var init_buffer_utils = __esm({
+    "../loader-utils/src/lib/binary-utils/buffer-utils.ts"() {
+    }
+  });
+
   // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
+  function toArrayBuffer(data) {
+    if (isBuffer(data)) {
+      return bufferToArrayBuffer(data);
+    }
+    if (data instanceof ArrayBuffer) {
+      return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+        return data.buffer;
+      }
+      return data.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 compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
+    byteLength = byteLength || arrayBuffer1.byteLength;
+    if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
+      return false;
+    }
+    const array1 = new Uint8Array(arrayBuffer1);
+    const array2 = new Uint8Array(arrayBuffer2);
+    for (let i2 = 0; i2 < array1.length; ++i2) {
+      if (array1[i2] !== array2[i2]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function concatenateArrayBuffers(...sources) {
+    const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+    const byteLength = sourceArrays.reduce((length4, typedArray) => length4 + typedArray.byteLength, 0);
+    const result = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const sourceArray of sourceArrays) {
+      result.set(sourceArray, offset);
+      offset += sourceArray.byteLength;
+    }
+    return result.buffer;
+  }
   function sliceArrayBuffer(arrayBuffer, byteOffset, byteLength) {
     const subArray = byteLength !== void 0 ? new Uint8Array(arrayBuffer).subarray(byteOffset, byteOffset + byteLength) : new Uint8Array(arrayBuffer).subarray(byteOffset);
     const arrayCopy = new Uint8Array(subArray);
@@ -226,6 +778,7 @@
   }
   var init_array_buffer_utils = __esm({
     "../loader-utils/src/lib/binary-utils/array-buffer-utils.ts"() {
+      init_buffer_utils();
     }
   });
 
@@ -312,6 +865,20 @@
     }
   });
 
+  // ../loader-utils/src/lib/iterators/async-iteration.ts
+  async function concatenateArrayBuffersAsync(asyncIterator) {
+    const arrayBuffers = [];
+    for await (const chunk of asyncIterator) {
+      arrayBuffers.push(chunk);
+    }
+    return concatenateArrayBuffers(...arrayBuffers);
+  }
+  var init_async_iteration = __esm({
+    "../loader-utils/src/lib/iterators/async-iteration.ts"() {
+      init_array_buffer_utils();
+    }
+  });
+
   // ../loader-utils/src/lib/path-utils/file-aliases.ts
   function resolvePath(filename2) {
     for (const alias in fileAliases) {
@@ -371,11 +938,13 @@
     "../loader-utils/src/index.ts"() {
       init_assert();
       init_globals();
+      init_parse_with_worker();
       init_parse_json();
       init_array_buffer_utils();
       init_memory_copy_utils();
       init_binary_copy_utils();
       init_encode_utils();
+      init_async_iteration();
       init_file_aliases();
       init_path();
     }
@@ -904,11 +1473,11 @@
     out[1] = m[1] * x + m[5] * y + m[13];
     return out;
   }
-  var forEach;
+  var forEach2;
   var init_vec2 = __esm({
     "../../node_modules/gl-matrix/esm/vec2.js"() {
       init_common2();
-      forEach = function() {
+      forEach2 = function() {
         var vec = create();
         return function(a2, stride, offset, count, fn, arg) {
           var i2, l2;
@@ -1184,12 +1753,12 @@
     var ax = a2[0], ay = a2[1], az = a2[2], bx = b[0], by = b[1], bz = b[2], mag1 = Math.sqrt(ax * ax + ay * ay + az * az), mag2 = Math.sqrt(bx * bx + by * by + bz * bz), mag = mag1 * mag2, cosine = mag && dot(a2, b) / mag;
     return Math.acos(Math.min(Math.max(cosine, -1), 1));
   }
-  var len, forEach2;
+  var len, forEach3;
   var init_vec3 = __esm({
     "../../node_modules/gl-matrix/esm/vec3.js"() {
       init_common2();
       len = length;
-      forEach2 = function() {
+      forEach3 = function() {
         var vec = create2();
         return function(a2, stride, offset, count, fn, arg) {
           var i2, l2;
@@ -2353,11 +2922,11 @@
     out[3] = a2[3];
     return out;
   }
-  var forEach3;
+  var forEach4;
   var init_vec4 = __esm({
     "../../node_modules/gl-matrix/esm/vec4.js"() {
       init_common2();
-      forEach3 = function() {
+      forEach4 = function() {
         var vec = create4();
         return function(a2, stride, offset, count, fn, arg) {
           var i2, l2;
@@ -3649,11 +4218,21 @@
   });
 
   // ../core/src/javascript-utils/is-type.ts
-  var isResponse, isBlob;
+  var isBoolean, isFunction, isObject, isPureObject, isIterable, isAsyncIterable, isResponse, isBlob, isBuffer2, isReadableDOMStream, isReadableNodeStream, isReadableStream;
   var init_is_type = __esm({
     "../core/src/javascript-utils/is-type.ts"() {
+      isBoolean = (x) => typeof x === "boolean";
+      isFunction = (x) => typeof x === "function";
+      isObject = (x) => x !== null && typeof x === "object";
+      isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
+      isIterable = (x) => x && typeof x[Symbol.iterator] === "function";
+      isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === "function";
       isResponse = (x) => typeof Response !== "undefined" && x instanceof Response || x && x.arrayBuffer && x.text && x.json;
       isBlob = (x) => typeof Blob !== "undefined" && x instanceof Blob;
+      isBuffer2 = (x) => x && typeof x === "object" && x.isBuffer;
+      isReadableDOMStream = (x) => typeof ReadableStream !== "undefined" && x instanceof ReadableStream || isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader);
+      isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
+      isReadableStream = (x) => isReadableDOMStream(x) || isReadableNodeStream(x);
     }
   });
 
@@ -3762,6 +4341,26 @@
     Object.defineProperty(response, "url", { value: url });
     return response;
   }
+  async function checkResponse(response) {
+    if (!response.ok) {
+      const message = await getResponseError(response);
+      throw new Error(message);
+    }
+  }
+  async function getResponseError(response) {
+    let message = `Failed to fetch resource ${response.url} (${response.status}): `;
+    try {
+      const contentType = response.headers.get("Content-Type");
+      let text = response.statusText;
+      if (contentType.includes("application/json")) {
+        text += ` ${await response.text()}`;
+      }
+      message += text;
+      message = message.length > 60 ? `${message.slice(60)}...` : message;
+    } catch (error) {
+    }
+    return message;
+  }
   async function getInitialDataUrl(resource) {
     const INITIAL_DATA_LENGTH = 5;
     if (typeof resource === "string") {
@@ -3816,10 +4415,1367 @@
     }
   });
 
+  // ../../node_modules/probe.gl/dist/esm/env/is-electron.js
+  function isElectron(mockUserAgent) {
+    if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
+      return true;
+    }
+    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions.electron)) {
+      return true;
+    }
+    const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent;
+    const userAgent = mockUserAgent || realUserAgent;
+    if (userAgent && userAgent.indexOf("Electron") >= 0) {
+      return true;
+    }
+    return false;
+  }
+  var init_is_electron = __esm({
+    "../../node_modules/probe.gl/dist/esm/env/is-electron.js"() {
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/esm/env/is-browser.js
+  function isBrowser3() {
+    const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
+    return !isNode || isElectron();
+  }
+  var init_is_browser = __esm({
+    "../../node_modules/probe.gl/dist/esm/env/is-browser.js"() {
+      init_is_electron();
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/esm/env/globals.js
+  var globals4, self_3, window_3, global_4, document_3, process_;
+  var init_globals3 = __esm({
+    "../../node_modules/probe.gl/dist/esm/env/globals.js"() {
+      globals4 = {
+        self: typeof self !== "undefined" && self,
+        window: typeof window !== "undefined" && window,
+        global: typeof global !== "undefined" && global,
+        document: typeof document !== "undefined" && document,
+        process: typeof process === "object" && process
+      };
+      self_3 = globals4.self || globals4.window || globals4.global;
+      window_3 = globals4.window || globals4.self || globals4.global;
+      global_4 = globals4.global || globals4.self || globals4.window;
+      document_3 = globals4.document || {};
+      process_ = globals4.process || {};
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/esm/utils/globals.js
+  var VERSION3, isBrowser4;
+  var init_globals4 = __esm({
+    "../../node_modules/probe.gl/dist/esm/utils/globals.js"() {
+      init_is_browser();
+      init_globals3();
+      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+      isBrowser4 = isBrowser3();
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/esm/utils/local-storage.js
+  function getStorage(type) {
+    try {
+      const storage = window[type];
+      const x = "__storage_test__";
+      storage.setItem(x, x);
+      storage.removeItem(x);
+      return storage;
+    } catch (e) {
+      return null;
+    }
+  }
+  var LocalStorage;
+  var init_local_storage = __esm({
+    "../../node_modules/probe.gl/dist/esm/utils/local-storage.js"() {
+      LocalStorage = class {
+        constructor(id, defaultSettings, type = "sessionStorage") {
+          this.storage = getStorage(type);
+          this.id = id;
+          this.config = {};
+          Object.assign(this.config, defaultSettings);
+          this._loadConfiguration();
+        }
+        getConfiguration() {
+          return this.config;
+        }
+        setConfiguration(configuration) {
+          this.config = {};
+          return this.updateConfiguration(configuration);
+        }
+        updateConfiguration(configuration) {
+          Object.assign(this.config, configuration);
+          if (this.storage) {
+            const serialized = JSON.stringify(this.config);
+            this.storage.setItem(this.id, serialized);
+          }
+          return this;
+        }
+        _loadConfiguration() {
+          let configuration = {};
+          if (this.storage) {
+            const serializedConfiguration = this.storage.getItem(this.id);
+            configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
+          }
+          Object.assign(this.config, configuration);
+          return this;
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/esm/utils/formatters.js
+  function formatTime(ms) {
+    let formatted;
+    if (ms < 10) {
+      formatted = "".concat(ms.toFixed(2), "ms");
+    } else if (ms < 100) {
+      formatted = "".concat(ms.toFixed(1), "ms");
+    } else if (ms < 1e3) {
+      formatted = "".concat(ms.toFixed(0), "ms");
+    } else {
+      formatted = "".concat((ms / 1e3).toFixed(2), "s");
+    }
+    return formatted;
+  }
+  function leftPad(string, length4 = 8) {
+    const padLength = Math.max(length4 - string.length, 0);
+    return "".concat(" ".repeat(padLength)).concat(string);
+  }
+  function formatImage(image, message, scale5, maxWidth = 600) {
+    const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29");
+    if (image.width > maxWidth) {
+      scale5 = Math.min(scale5, maxWidth / image.width);
+    }
+    const width = image.width * scale5;
+    const height = image.height * scale5;
+    const style = ["font-size:1px;", "padding:".concat(Math.floor(height / 2), "px ").concat(Math.floor(width / 2), "px;"), "line-height:".concat(height, "px;"), "background:url(".concat(imageUrl, ");"), "background-size:".concat(width, "px ").concat(height, "px;"), "color:transparent;"].join("");
+    return ["".concat(message, " %c+"), style];
+  }
+  var init_formatters = __esm({
+    "../../node_modules/probe.gl/dist/esm/utils/formatters.js"() {
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/esm/utils/color.js
+  function getColor(color) {
+    return typeof color === "string" ? COLOR[color.toUpperCase()] || COLOR.WHITE : color;
+  }
+  function addColor(string, color, background) {
+    if (!isBrowser4 && typeof string === "string") {
+      if (color) {
+        color = getColor(color);
+        string = "[".concat(color, "m").concat(string, "");
+      }
+      if (background) {
+        color = getColor(background);
+        string = "[".concat(background + 10, "m").concat(string, "");
+      }
+    }
+    return string;
+  }
+  var COLOR;
+  var init_color = __esm({
+    "../../node_modules/probe.gl/dist/esm/utils/color.js"() {
+      init_globals4();
+      COLOR = {
+        BLACK: 30,
+        RED: 31,
+        GREEN: 32,
+        YELLOW: 33,
+        BLUE: 34,
+        MAGENTA: 35,
+        CYAN: 36,
+        WHITE: 37,
+        BRIGHT_BLACK: 90,
+        BRIGHT_RED: 91,
+        BRIGHT_GREEN: 92,
+        BRIGHT_YELLOW: 93,
+        BRIGHT_BLUE: 94,
+        BRIGHT_MAGENTA: 95,
+        BRIGHT_CYAN: 96,
+        BRIGHT_WHITE: 97
+      };
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/esm/utils/autobind.js
+  function autobind(obj, predefined = ["constructor"]) {
+    const proto = Object.getPrototypeOf(obj);
+    const propNames = Object.getOwnPropertyNames(proto);
+    for (const key of propNames) {
+      if (typeof obj[key] === "function") {
+        if (!predefined.find((name8) => key === name8)) {
+          obj[key] = obj[key].bind(obj);
+        }
+      }
+    }
+  }
+  var init_autobind = __esm({
+    "../../node_modules/probe.gl/dist/esm/utils/autobind.js"() {
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/esm/utils/assert.js
+  function assert5(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failed");
+    }
+  }
+  var init_assert4 = __esm({
+    "../../node_modules/probe.gl/dist/esm/utils/assert.js"() {
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/esm/utils/hi-res-timestamp.js
+  function getHiResTimestamp() {
+    let timestamp;
+    if (isBrowser4 && window_3.performance) {
+      timestamp = window_3.performance.now();
+    } else if (process_.hrtime) {
+      const timeParts = process_.hrtime();
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
+    }
+    return timestamp;
+  }
+  var init_hi_res_timestamp = __esm({
+    "../../node_modules/probe.gl/dist/esm/utils/hi-res-timestamp.js"() {
+      init_globals4();
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/esm/lib/log.js
+  function noop2() {
+  }
+  function getTableHeader(table) {
+    for (const key in table) {
+      for (const title in table[key]) {
+        return title || "untitled";
+      }
+    }
+    return "empty";
+  }
+  function normalizeLogLevel(logLevel) {
+    if (!logLevel) {
+      return 0;
+    }
+    let resolvedLevel;
+    switch (typeof logLevel) {
+      case "number":
+        resolvedLevel = logLevel;
+        break;
+      case "object":
+        resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+        break;
+      default:
+        return 0;
+    }
+    assert5(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+    return resolvedLevel;
+  }
+  function normalizeArguments(opts) {
+    const {
+      logLevel,
+      message
+    } = opts;
+    opts.logLevel = normalizeLogLevel(logLevel);
+    const args = opts.args ? Array.from(opts.args) : [];
+    while (args.length && args.shift() !== message) {
+    }
+    opts.args = args;
+    switch (typeof logLevel) {
+      case "string":
+      case "function":
+        if (message !== void 0) {
+          args.unshift(message);
+        }
+        opts.message = logLevel;
+        break;
+      case "object":
+        Object.assign(opts, logLevel);
+        break;
+      default:
+    }
+    if (typeof opts.message === "function") {
+      opts.message = opts.message();
+    }
+    const messageType = typeof opts.message;
+    assert5(messageType === "string" || messageType === "object");
+    return Object.assign(opts, opts.opts);
+  }
+  function decorateMessage(id, message, opts) {
+    if (typeof message === "string") {
+      const time = opts.time ? leftPad(formatTime(opts.total)) : "";
+      message = opts.time ? "".concat(id, ": ").concat(time, "  ").concat(message) : "".concat(id, ": ").concat(message);
+      message = addColor(message, opts.color, opts.background);
+    }
+    return message;
+  }
+  function logImageInNode({
+    image,
+    message = "",
+    scale: scale5 = 1
+  }) {
+    let asciify = null;
+    try {
+      asciify = module.require("asciify-image");
+    } catch (error) {
+    }
+    if (asciify) {
+      return () => asciify(image, {
+        fit: "box",
+        width: "".concat(Math.round(80 * scale5), "%")
+      }).then((data) => console.log(data));
+    }
+    return noop2;
+  }
+  function logImageInBrowser({
+    image,
+    message = "",
+    scale: scale5 = 1
+  }) {
+    if (typeof image === "string") {
+      const img = new Image();
+      img.onload = () => {
+        const args = formatImage(img, message, scale5);
+        console.log(...args);
+      };
+      img.src = image;
+      return noop2;
+    }
+    const element = image.nodeName || "";
+    if (element.toLowerCase() === "img") {
+      console.log(...formatImage(image, message, scale5));
+      return noop2;
+    }
+    if (element.toLowerCase() === "canvas") {
+      const img = new Image();
+      img.onload = () => console.log(...formatImage(img, message, scale5));
+      img.src = image.toDataURL();
+      return noop2;
+    }
+    return noop2;
+  }
+  var originalConsole, DEFAULT_SETTINGS, cache, ONCE, Log;
+  var init_log = __esm({
+    "../../node_modules/probe.gl/dist/esm/lib/log.js"() {
+      init_globals4();
+      init_local_storage();
+      init_formatters();
+      init_color();
+      init_autobind();
+      init_assert4();
+      init_hi_res_timestamp();
+      originalConsole = {
+        debug: isBrowser4 ? console.debug || console.log : console.log,
+        log: console.log,
+        info: console.info,
+        warn: console.warn,
+        error: console.error
+      };
+      DEFAULT_SETTINGS = {
+        enabled: true,
+        level: 0
+      };
+      cache = {};
+      ONCE = {
+        once: true
+      };
+      Log = class {
+        constructor({
+          id
+        } = {
+          id: ""
+        }) {
+          this.id = id;
+          this.VERSION = VERSION3;
+          this._startTs = getHiResTimestamp();
+          this._deltaTs = getHiResTimestamp();
+          this.LOG_THROTTLE_TIMEOUT = 0;
+          this._storage = new LocalStorage("__probe-".concat(this.id, "__"), DEFAULT_SETTINGS);
+          this.userData = {};
+          this.timeStamp("".concat(this.id, " started"));
+          autobind(this);
+          Object.seal(this);
+        }
+        set level(newLevel) {
+          this.setLevel(newLevel);
+        }
+        get level() {
+          return this.getLevel();
+        }
+        isEnabled() {
+          return this._storage.config.enabled;
+        }
+        getLevel() {
+          return this._storage.config.level;
+        }
+        getTotal() {
+          return Number((getHiResTimestamp() - this._startTs).toPrecision(10));
+        }
+        getDelta() {
+          return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10));
+        }
+        set priority(newPriority) {
+          this.level = newPriority;
+        }
+        get priority() {
+          return this.level;
+        }
+        getPriority() {
+          return this.level;
+        }
+        enable(enabled = true) {
+          this._storage.updateConfiguration({
+            enabled
+          });
+          return this;
+        }
+        setLevel(level) {
+          this._storage.updateConfiguration({
+            level
+          });
+          return this;
+        }
+        assert(condition, message) {
+          assert5(condition, message);
+        }
+        warn(message) {
+          return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE);
+        }
+        error(message) {
+          return this._getLogFunction(0, message, originalConsole.error, arguments);
+        }
+        deprecated(oldUsage, newUsage) {
+          return this.warn("`".concat(oldUsage, "` is deprecated and will be removed in a later version. Use `").concat(newUsage, "` instead"));
+        }
+        removed(oldUsage, newUsage) {
+          return this.error("`".concat(oldUsage, "` has been removed. Use `").concat(newUsage, "` instead"));
+        }
+        probe(logLevel, message) {
+          return this._getLogFunction(logLevel, message, originalConsole.log, arguments, {
+            time: true,
+            once: true
+          });
+        }
+        log(logLevel, message) {
+          return this._getLogFunction(logLevel, message, originalConsole.debug, arguments);
+        }
+        info(logLevel, message) {
+          return this._getLogFunction(logLevel, message, console.info, arguments);
+        }
+        once(logLevel, message) {
+          return this._getLogFunction(logLevel, message, originalConsole.debug || originalConsole.info, arguments, ONCE);
+        }
+        table(logLevel, table, columns) {
+          if (table) {
+            return this._getLogFunction(logLevel, table, console.table || noop2, columns && [columns], {
+              tag: getTableHeader(table)
+            });
+          }
+          return noop2;
+        }
+        image({
+          logLevel,
+          priority,
+          image,
+          message = "",
+          scale: scale5 = 1
+        }) {
+          if (!this._shouldLog(logLevel || priority)) {
+            return noop2;
+          }
+          return isBrowser4 ? logImageInBrowser({
+            image,
+            message,
+            scale: scale5
+          }) : logImageInNode({
+            image,
+            message,
+            scale: scale5
+          });
+        }
+        settings() {
+          if (console.table) {
+            console.table(this._storage.config);
+          } else {
+            console.log(this._storage.config);
+          }
+        }
+        get(setting) {
+          return this._storage.config[setting];
+        }
+        set(setting, value) {
+          this._storage.updateConfiguration({
+            [setting]: value
+          });
+        }
+        time(logLevel, message) {
+          return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
+        }
+        timeEnd(logLevel, message) {
+          return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
+        }
+        timeStamp(logLevel, message) {
+          return this._getLogFunction(logLevel, message, console.timeStamp || noop2);
+        }
+        group(logLevel, message, opts = {
+          collapsed: false
+        }) {
+          opts = normalizeArguments({
+            logLevel,
+            message,
+            opts
+          });
+          const {
+            collapsed
+          } = opts;
+          opts.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
+          return this._getLogFunction(opts);
+        }
+        groupCollapsed(logLevel, message, opts = {}) {
+          return this.group(logLevel, message, Object.assign({}, opts, {
+            collapsed: true
+          }));
+        }
+        groupEnd(logLevel) {
+          return this._getLogFunction(logLevel, "", console.groupEnd || noop2);
+        }
+        withGroup(logLevel, message, func) {
+          this.group(logLevel, message)();
+          try {
+            func();
+          } finally {
+            this.groupEnd(logLevel)();
+          }
+        }
+        trace() {
+          if (console.trace) {
+            console.trace();
+          }
+        }
+        _shouldLog(logLevel) {
+          return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
+        }
+        _getLogFunction(logLevel, message, method, args = [], opts) {
+          if (this._shouldLog(logLevel)) {
+            opts = normalizeArguments({
+              logLevel,
+              message,
+              args,
+              opts
+            });
+            method = method || opts.method;
+            assert5(method);
+            opts.total = this.getTotal();
+            opts.delta = this.getDelta();
+            this._deltaTs = getHiResTimestamp();
+            const tag = opts.tag || opts.message;
+            if (opts.once) {
+              if (!cache[tag]) {
+                cache[tag] = getHiResTimestamp();
+              } else {
+                return noop2;
+              }
+            }
+            message = decorateMessage(this.id, opts.message, opts);
+            return method.bind(console, message, ...opts.args);
+          }
+          return noop2;
+        }
+      };
+      Log.VERSION = VERSION3;
+    }
+  });
+
+  // ../../node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js
+  var init_hi_res_timestamp2 = __esm({
+    "../../node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js"() {
+    }
+  });
+
+  // ../../node_modules/@probe.gl/stats/dist/esm/lib/stat.js
+  var init_stat = __esm({
+    "../../node_modules/@probe.gl/stats/dist/esm/lib/stat.js"() {
+      init_hi_res_timestamp2();
+    }
+  });
+
+  // ../../node_modules/@probe.gl/stats/dist/esm/lib/stats.js
+  var init_stats = __esm({
+    "../../node_modules/@probe.gl/stats/dist/esm/lib/stats.js"() {
+      init_stat();
+    }
+  });
+
+  // ../../node_modules/@probe.gl/stats/dist/esm/index.js
+  var init_esm3 = __esm({
+    "../../node_modules/@probe.gl/stats/dist/esm/index.js"() {
+      init_stats();
+      init_stat();
+      init_hi_res_timestamp2();
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/esm/index.js
+  var esm_default;
+  var init_esm4 = __esm({
+    "../../node_modules/probe.gl/dist/esm/index.js"() {
+      init_log();
+      init_log();
+      init_esm3();
+      esm_default = new Log({
+        id: "probe.gl"
+      });
+    }
+  });
+
+  // ../core/src/lib/loader-utils/loggers.ts
+  var probeLog, NullLog, ConsoleLog;
+  var init_loggers = __esm({
+    "../core/src/lib/loader-utils/loggers.ts"() {
+      init_esm4();
+      probeLog = new Log({ id: "loaders.gl" });
+      NullLog = class {
+        log() {
+          return () => {
+          };
+        }
+        info() {
+          return () => {
+          };
+        }
+        warn() {
+          return () => {
+          };
+        }
+        error() {
+          return () => {
+          };
+        }
+      };
+      ConsoleLog = class {
+        constructor() {
+          this.console = console;
+        }
+        log(...args) {
+          return this.console.log.bind(this.console, ...args);
+        }
+        info(...args) {
+          return this.console.info.bind(this.console, ...args);
+        }
+        warn(...args) {
+          return this.console.warn.bind(this.console, ...args);
+        }
+        error(...args) {
+          return this.console.error.bind(this.console, ...args);
+        }
+      };
+    }
+  });
+
+  // ../core/src/lib/loader-utils/option-defaults.ts
+  var DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS;
+  var init_option_defaults = __esm({
+    "../core/src/lib/loader-utils/option-defaults.ts"() {
+      init_loggers();
+      DEFAULT_LOADER_OPTIONS = {
+        fetch: null,
+        mimeType: void 0,
+        nothrow: false,
+        log: new ConsoleLog(),
+        CDN: "https://unpkg.com/@loaders.gl",
+        worker: true,
+        maxConcurrency: 3,
+        maxMobileConcurrency: 1,
+        reuseWorkers: true,
+        _workerType: "",
+        limit: 0,
+        _limitMB: 0,
+        batchSize: "auto",
+        batchDebounceMs: 0,
+        metadata: false,
+        transforms: []
+      };
+      REMOVED_LOADER_OPTIONS = {
+        throws: "nothrow",
+        dataType: "(no longer used)",
+        uri: "baseUri",
+        method: "fetch.method",
+        headers: "fetch.headers",
+        body: "fetch.body",
+        mode: "fetch.mode",
+        credentials: "fetch.credentials",
+        cache: "fetch.cache",
+        redirect: "fetch.redirect",
+        referrer: "fetch.referrer",
+        referrerPolicy: "fetch.referrerPolicy",
+        integrity: "fetch.integrity",
+        keepalive: "fetch.keepalive",
+        signal: "fetch.signal"
+      };
+    }
+  });
+
+  // ../core/src/lib/loader-utils/option-utils.ts
+  function getGlobalLoaderState() {
+    globalThis.loaders = globalThis.loaders || {};
+    const { loaders } = globalThis;
+    loaders._state = loaders._state || {};
+    return loaders._state;
+  }
+  function normalizeOptions(options, loader, loaders, url) {
+    loaders = loaders || [];
+    loaders = Array.isArray(loaders) ? loaders : [loaders];
+    validateOptions(options, loaders);
+    return normalizeOptionsInternal(loader, options, url);
+  }
+  function getFetchFunction(options, context) {
+    const globalOptions = getGlobalLoaderOptions();
+    const fetchOptions = options || globalOptions;
+    if (typeof fetchOptions.fetch === "function") {
+      return fetchOptions.fetch;
+    }
+    if (isObject(fetchOptions.fetch)) {
+      return (url) => fetchFile(url, fetchOptions);
+    }
+    if (context?.fetch) {
+      return context?.fetch;
+    }
+    return fetchFile;
+  }
+  function validateOptions(options, loaders) {
+    validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders);
+    for (const loader of loaders) {
+      const idOptions = options && options[loader.id] || {};
+      const loaderOptions = loader.options && loader.options[loader.id] || {};
+      const deprecatedOptions = loader.deprecatedOptions && loader.deprecatedOptions[loader.id] || {};
+      validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders);
+    }
+  }
+  function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, loaders) {
+    const loaderName = id || "Top level";
+    const prefix = id ? `${id}.` : "";
+    for (const key in options) {
+      const isSubOptions = !id && isObject(options[key]);
+      const isBaseUriOption = key === "baseUri" && !id;
+      const isWorkerUrlOption = key === "workerUrl" && id;
+      if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) {
+        if (key in deprecatedOptions) {
+          probeLog.warn(`${loaderName} loader option '${prefix}${key}' no longer supported, use '${deprecatedOptions[key]}'`)();
+        } else if (!isSubOptions) {
+          const suggestion = findSimilarOption(key, loaders);
+          probeLog.warn(`${loaderName} loader option '${prefix}${key}' not recognized. ${suggestion}`)();
+        }
+      }
+    }
+  }
+  function findSimilarOption(optionKey, loaders) {
+    const lowerCaseOptionKey = optionKey.toLowerCase();
+    let bestSuggestion = "";
+    for (const loader of loaders) {
+      for (const key in loader.options) {
+        if (optionKey === key) {
+          return `Did you mean '${loader.id}.${key}'?`;
+        }
+        const lowerCaseKey = key.toLowerCase();
+        const isPartialMatch = lowerCaseOptionKey.startsWith(lowerCaseKey) || lowerCaseKey.startsWith(lowerCaseOptionKey);
+        if (isPartialMatch) {
+          bestSuggestion = bestSuggestion || `Did you mean '${loader.id}.${key}'?`;
+        }
+      }
+    }
+    return bestSuggestion;
+  }
+  function normalizeOptionsInternal(loader, options, url) {
+    const loaderDefaultOptions = loader.options || {};
+    const mergedOptions = { ...loaderDefaultOptions };
+    addUrlOptions(mergedOptions, url);
+    if (mergedOptions.log === null) {
+      mergedOptions.log = new NullLog();
+    }
+    mergeNestedFields(mergedOptions, getGlobalLoaderOptions());
+    mergeNestedFields(mergedOptions, options);
+    return mergedOptions;
+  }
+  function mergeNestedFields(mergedOptions, options) {
+    for (const key in options) {
+      if (key in options) {
+        const value = options[key];
+        if (isPureObject(value) && isPureObject(mergedOptions[key])) {
+          mergedOptions[key] = {
+            ...mergedOptions[key],
+            ...options[key]
+          };
+        } else {
+          mergedOptions[key] = options[key];
+        }
+      }
+    }
+  }
+  function addUrlOptions(options, url) {
+    if (url && !("baseUri" in options)) {
+      options.baseUri = url;
+    }
+  }
+  var getGlobalLoaderOptions;
+  var init_option_utils = __esm({
+    "../core/src/lib/loader-utils/option-utils.ts"() {
+      init_is_type();
+      init_fetch_file();
+      init_loggers();
+      init_option_defaults();
+      getGlobalLoaderOptions = () => {
+        const state = getGlobalLoaderState();
+        state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
+        return state.globalOptions;
+      };
+    }
+  });
+
+  // ../core/src/lib/loader-utils/normalize-loader.ts
+  function isLoaderObject(loader) {
+    if (!loader) {
+      return false;
+    }
+    if (Array.isArray(loader)) {
+      loader = loader[0];
+    }
+    const hasExtensions = Array.isArray(loader?.extensions);
+    return hasExtensions;
+  }
+  function normalizeLoader(loader) {
+    assert2(loader, "null loader");
+    assert2(isLoaderObject(loader), "invalid loader");
+    let options;
+    if (Array.isArray(loader)) {
+      options = loader[1];
+      loader = loader[0];
+      loader = {
+        ...loader,
+        options: { ...loader.options, ...options }
+      };
+    }
+    if (loader?.parseTextSync || loader?.parseText) {
+      loader.text = true;
+    }
+    if (!loader.text) {
+      loader.binary = true;
+    }
+    return loader;
+  }
+  var init_normalize_loader = __esm({
+    "../core/src/lib/loader-utils/normalize-loader.ts"() {
+      init_src2();
+    }
+  });
+
+  // ../core/src/lib/api/register-loaders.ts
+  function getRegisteredLoaders() {
+    return getGlobalLoaderRegistry();
+  }
+  var getGlobalLoaderRegistry;
+  var init_register_loaders = __esm({
+    "../core/src/lib/api/register-loaders.ts"() {
+      init_option_utils();
+      getGlobalLoaderRegistry = () => {
+        const state = getGlobalLoaderState();
+        state.loaderRegistry = state.loaderRegistry || [];
+        return state.loaderRegistry;
+      };
+    }
+  });
+
+  // ../core/src/lib/api/select-loader.ts
+  async function selectLoader(data, loaders = [], options, context) {
+    if (!validHTTPResponse(data)) {
+      return null;
+    }
+    let loader = selectLoaderSync(data, loaders, { ...options, nothrow: true }, context);
+    if (loader) {
+      return loader;
+    }
+    if (isBlob(data)) {
+      data = await data.slice(0, 10).arrayBuffer();
+      loader = selectLoaderSync(data, loaders, options, context);
+    }
+    if (!loader && !options?.nothrow) {
+      throw new Error(getNoValidLoaderMessage(data));
+    }
+    return loader;
+  }
+  function selectLoaderSync(data, loaders = [], options, context) {
+    if (!validHTTPResponse(data)) {
+      return null;
+    }
+    if (loaders && !Array.isArray(loaders)) {
+      return normalizeLoader(loaders);
+    }
+    let candidateLoaders = [];
+    if (loaders) {
+      candidateLoaders = candidateLoaders.concat(loaders);
+    }
+    if (!options?.ignoreRegisteredLoaders) {
+      candidateLoaders.push(...getRegisteredLoaders());
+    }
+    normalizeLoaders(candidateLoaders);
+    const loader = selectLoaderInternal(data, candidateLoaders, options, context);
+    if (!loader && !options?.nothrow) {
+      throw new Error(getNoValidLoaderMessage(data));
+    }
+    return loader;
+  }
+  function selectLoaderInternal(data, loaders, options, context) {
+    const { url, type } = getResourceUrlAndType(data);
+    const testUrl = url || context?.url;
+    let loader = null;
+    if (options?.mimeType) {
+      loader = findLoaderByMIMEType(loaders, options?.mimeType);
+    }
+    loader = loader || findLoaderByUrl(loaders, testUrl);
+    loader = loader || findLoaderByMIMEType(loaders, type);
+    loader = loader || findLoaderByInitialBytes(loaders, data);
+    loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
+    return loader;
+  }
+  function validHTTPResponse(data) {
+    if (data instanceof Response) {
+      if (data.status === 204) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function getNoValidLoaderMessage(data) {
+    const { url, type } = getResourceUrlAndType(data);
+    let message = "No valid loader found (";
+    message += url ? `${path_exports.filename(url)}, ` : "no url provided, ";
+    message += `MIME type: ${type ? `"${type}"` : "not provided"}, `;
+    const firstCharacters = data ? getFirstCharacters2(data) : "";
+    message += firstCharacters ? ` first bytes: "${firstCharacters}"` : "first bytes: not available";
+    message += ")";
+    return message;
+  }
+  function normalizeLoaders(loaders) {
+    for (const loader of loaders) {
+      normalizeLoader(loader);
+    }
+  }
+  function findLoaderByUrl(loaders, url) {
+    const match = url && EXT_PATTERN.exec(url);
+    const extension = match && match[1];
+    return extension ? findLoaderByExtension(loaders, extension) : null;
+  }
+  function findLoaderByExtension(loaders, extension) {
+    extension = extension.toLowerCase();
+    for (const loader of loaders) {
+      for (const loaderExtension of loader.extensions) {
+        if (loaderExtension.toLowerCase() === extension) {
+          return loader;
+        }
+      }
+    }
+    return null;
+  }
+  function findLoaderByMIMEType(loaders, mimeType) {
+    for (const loader of loaders) {
+      if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {
+        return loader;
+      }
+      if (mimeType === `application/x.${loader.id}`) {
+        return loader;
+      }
+    }
+    return null;
+  }
+  function findLoaderByInitialBytes(loaders, data) {
+    if (!data) {
+      return null;
+    }
+    for (const loader of loaders) {
+      if (typeof data === "string") {
+        if (testDataAgainstText(data, loader)) {
+          return loader;
+        }
+      } else if (ArrayBuffer.isView(data)) {
+        if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) {
+          return loader;
+        }
+      } else if (data instanceof ArrayBuffer) {
+        const byteOffset = 0;
+        if (testDataAgainstBinary(data, byteOffset, loader)) {
+          return loader;
+        }
+      }
+    }
+    return null;
+  }
+  function testDataAgainstText(data, loader) {
+    if (loader.testText) {
+      return loader.testText(data);
+    }
+    const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
+    return tests.some((test) => data.startsWith(test));
+  }
+  function testDataAgainstBinary(data, byteOffset, loader) {
+    const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
+    return tests.some((test) => testBinary(data, byteOffset, loader, test));
+  }
+  function testBinary(data, byteOffset, loader, test) {
+    if (test instanceof ArrayBuffer) {
+      return compareArrayBuffers(test, data, test.byteLength);
+    }
+    switch (typeof test) {
+      case "function":
+        return test(data, loader);
+      case "string":
+        const magic = getMagicString2(data, byteOffset, test.length);
+        return test === magic;
+      default:
+        return false;
+    }
+  }
+  function getFirstCharacters2(data, length4 = 5) {
+    if (typeof data === "string") {
+      return data.slice(0, length4);
+    } else if (ArrayBuffer.isView(data)) {
+      return getMagicString2(data.buffer, data.byteOffset, length4);
+    } else if (data instanceof ArrayBuffer) {
+      const byteOffset = 0;
+      return getMagicString2(data, byteOffset, length4);
+    }
+    return "";
+  }
+  function getMagicString2(arrayBuffer, byteOffset, length4) {
+    if (arrayBuffer.byteLength < byteOffset + length4) {
+      return "";
+    }
+    const dataView = new DataView(arrayBuffer);
+    let magic = "";
+    for (let i2 = 0; i2 < length4; i2++) {
+      magic += String.fromCharCode(dataView.getUint8(byteOffset + i2));
+    }
+    return magic;
+  }
+  var EXT_PATTERN;
+  var init_select_loader = __esm({
+    "../core/src/lib/api/select-loader.ts"() {
+      init_src2();
+      init_normalize_loader();
+      init_resource_utils();
+      init_register_loaders();
+      init_is_type();
+      EXT_PATTERN = /\.([^.]+)$/;
+    }
+  });
+
+  // ../core/src/iterators/make-iterator/make-string-iterator.ts
+  function* makeStringIterator(string, options) {
+    const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;
+    let offset = 0;
+    const textEncoder = new TextEncoder();
+    while (offset < string.length) {
+      const chunkLength = Math.min(string.length - offset, chunkSize);
+      const chunk = string.slice(offset, offset + chunkLength);
+      offset += chunkLength;
+      yield textEncoder.encode(chunk);
+    }
+  }
+  var DEFAULT_CHUNK_SIZE;
+  var init_make_string_iterator = __esm({
+    "../core/src/iterators/make-iterator/make-string-iterator.ts"() {
+      DEFAULT_CHUNK_SIZE = 256 * 1024;
+    }
+  });
+
+  // ../core/src/iterators/make-iterator/make-array-buffer-iterator.ts
+  function* makeArrayBufferIterator(arrayBuffer, options = {}) {
+    const { chunkSize = DEFAULT_CHUNK_SIZE2 } = options;
+    let byteOffset = 0;
+    while (byteOffset < arrayBuffer.byteLength) {
+      const chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);
+      const chunk = new ArrayBuffer(chunkByteLength);
+      const sourceArray = new Uint8Array(arrayBuffer, byteOffset, chunkByteLength);
+      const chunkArray = new Uint8Array(chunk);
+      chunkArray.set(sourceArray);
+      byteOffset += chunkByteLength;
+      yield chunk;
+    }
+  }
+  var DEFAULT_CHUNK_SIZE2;
+  var init_make_array_buffer_iterator = __esm({
+    "../core/src/iterators/make-iterator/make-array-buffer-iterator.ts"() {
+      DEFAULT_CHUNK_SIZE2 = 256 * 1024;
+    }
+  });
+
+  // ../core/src/iterators/make-iterator/make-blob-iterator.ts
+  async function* makeBlobIterator(blob, options) {
+    const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE3;
+    let offset = 0;
+    while (offset < blob.size) {
+      const end = offset + chunkSize;
+      const chunk = await blob.slice(offset, end).arrayBuffer();
+      offset = end;
+      yield chunk;
+    }
+  }
+  var DEFAULT_CHUNK_SIZE3;
+  var init_make_blob_iterator = __esm({
+    "../core/src/iterators/make-iterator/make-blob-iterator.ts"() {
+      DEFAULT_CHUNK_SIZE3 = 1024 * 1024;
+    }
+  });
+
+  // ../core/src/iterators/make-iterator/make-stream-iterator.ts
+  function makeStreamIterator(stream, options) {
+    return isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
+  }
+  async function* makeBrowserStreamIterator(stream, options) {
+    const reader = stream.getReader();
+    let nextBatchPromise;
+    try {
+      while (true) {
+        const currentBatchPromise = nextBatchPromise || reader.read();
+        if (options?._streamReadAhead) {
+          nextBatchPromise = reader.read();
+        }
+        const { done, value } = await currentBatchPromise;
+        if (done) {
+          return;
+        }
+        yield toArrayBuffer(value);
+      }
+    } catch (error) {
+      reader.releaseLock();
+    }
+  }
+  async function* makeNodeStreamIterator(stream, options) {
+    for await (const chunk of stream) {
+      yield toArrayBuffer(chunk);
+    }
+  }
+  var init_make_stream_iterator = __esm({
+    "../core/src/iterators/make-iterator/make-stream-iterator.ts"() {
+      init_src2();
+    }
+  });
+
+  // ../core/src/iterators/make-iterator/make-iterator.ts
+  function makeIterator(data, options) {
+    if (typeof data === "string") {
+      return makeStringIterator(data, options);
+    }
+    if (data instanceof ArrayBuffer) {
+      return makeArrayBufferIterator(data, options);
+    }
+    if (isBlob(data)) {
+      return makeBlobIterator(data, options);
+    }
+    if (isReadableStream(data)) {
+      return makeStreamIterator(data, options);
+    }
+    if (isResponse(data)) {
+      const response = data;
+      return makeStreamIterator(response.body, options);
+    }
+    throw new Error("makeIterator");
+  }
+  var init_make_iterator = __esm({
+    "../core/src/iterators/make-iterator/make-iterator.ts"() {
+      init_make_string_iterator();
+      init_make_array_buffer_iterator();
+      init_make_blob_iterator();
+      init_make_stream_iterator();
+      init_is_type();
+    }
+  });
+
+  // ../core/src/lib/loader-utils/get-data.ts
+  function getArrayBufferOrStringFromDataSync(data, loader, options) {
+    if (loader.text && typeof data === "string") {
+      return data;
+    }
+    if (isBuffer2(data)) {
+      data = data.buffer;
+    }
+    if (data instanceof ArrayBuffer) {
+      const arrayBuffer = data;
+      if (loader.text && !loader.binary) {
+        const textDecoder = new TextDecoder("utf8");
+        return textDecoder.decode(arrayBuffer);
+      }
+      return arrayBuffer;
+    }
+    if (ArrayBuffer.isView(data)) {
+      if (loader.text && !loader.binary) {
+        const textDecoder = new TextDecoder("utf8");
+        return textDecoder.decode(data);
+      }
+      let arrayBuffer = data.buffer;
+      const byteLength = data.byteLength || data.length;
+      if (data.byteOffset !== 0 || byteLength !== arrayBuffer.byteLength) {
+        arrayBuffer = arrayBuffer.slice(data.byteOffset, data.byteOffset + byteLength);
+      }
+      return arrayBuffer;
+    }
+    throw new Error(ERR_DATA);
+  }
+  async function getArrayBufferOrStringFromData(data, loader, options) {
+    const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data);
+    if (typeof data === "string" || isArrayBuffer) {
+      return getArrayBufferOrStringFromDataSync(data, loader, options);
+    }
+    if (isBlob(data)) {
+      data = await makeResponse(data);
+    }
+    if (isResponse(data)) {
+      const response = data;
+      await checkResponse(response);
+      return loader.binary ? await response.arrayBuffer() : await response.text();
+    }
+    if (isReadableStream(data)) {
+      data = makeIterator(data, options);
+    }
+    if (isIterable(data) || isAsyncIterable(data)) {
+      return concatenateArrayBuffersAsync(data);
+    }
+    throw new Error(ERR_DATA);
+  }
+  var ERR_DATA;
+  var init_get_data = __esm({
+    "../core/src/lib/loader-utils/get-data.ts"() {
+      init_src2();
+      init_is_type();
+      init_make_iterator();
+      init_response_utils();
+      ERR_DATA = "Cannot convert supplied data type";
+    }
+  });
+
+  // ../core/src/lib/loader-utils/loader-context.ts
+  function getLoaderContext(context, options, previousContext = null) {
+    if (previousContext) {
+      return previousContext;
+    }
+    const resolvedContext = {
+      fetch: getFetchFunction(options, context),
+      ...context
+    };
+    if (!Array.isArray(resolvedContext.loaders)) {
+      resolvedContext.loaders = null;
+    }
+    return resolvedContext;
+  }
+  function getLoadersFromContext(loaders, context) {
+    if (!context && loaders && !Array.isArray(loaders)) {
+      return loaders;
+    }
+    let candidateLoaders;
+    if (loaders) {
+      candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];
+    }
+    if (context && context.loaders) {
+      const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
+      candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
+    }
+    return candidateLoaders && candidateLoaders.length ? candidateLoaders : null;
+  }
+  var init_loader_context = __esm({
+    "../core/src/lib/loader-utils/loader-context.ts"() {
+      init_option_utils();
+    }
+  });
+
+  // ../core/src/lib/api/parse.ts
+  async function parse(data, loaders, options, context) {
+    assert3(!context || typeof context === "object");
+    if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
+      context = void 0;
+      options = loaders;
+      loaders = void 0;
+    }
+    data = await data;
+    options = options || {};
+    const { url } = getResourceUrlAndType(data);
+    const typedLoaders = loaders;
+    const candidateLoaders = getLoadersFromContext(typedLoaders, context);
+    const loader = await selectLoader(data, candidateLoaders, options);
+    if (!loader) {
+      return null;
+    }
+    options = normalizeOptions(options, loader, candidateLoaders, url);
+    context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context);
+    return await parseWithLoader(loader, data, options, context);
+  }
+  async function parseWithLoader(loader, data, options, context) {
+    validateWorkerVersion(loader);
+    data = await getArrayBufferOrStringFromData(data, loader, options);
+    if (loader.parseTextSync && typeof data === "string") {
+      options.dataType = "text";
+      return loader.parseTextSync(data, options, context, loader);
+    }
+    if (canParseWithWorker(loader, options)) {
+      return await parseWithWorker(loader, data, options, context, parse);
+    }
+    if (loader.parseText && typeof data === "string") {
+      return await loader.parseText(data, options, context, loader);
+    }
+    if (loader.parse) {
+      return await loader.parse(data, options, context, loader);
+    }
+    assert3(!loader.parseSync);
+    throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
+  }
+  var init_parse = __esm({
+    "../core/src/lib/api/parse.ts"() {
+      init_src();
+      init_src2();
+      init_normalize_loader();
+      init_option_utils();
+      init_get_data();
+      init_loader_context();
+      init_resource_utils();
+      init_select_loader();
+    }
+  });
+
+  // ../core/src/lib/api/load.ts
+  async function load(url, loaders, options, context) {
+    if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+      context = void 0;
+      options = loaders;
+      loaders = void 0;
+    }
+    const fetch2 = getFetchFunction(options);
+    let data = url;
+    if (typeof url === "string") {
+      data = await fetch2(url);
+    }
+    if (isBlob(url)) {
+      data = await fetch2(url);
+    }
+    return await parse(data, loaders, options);
+  }
+  var init_load = __esm({
+    "../core/src/lib/api/load.ts"() {
+      init_is_type();
+      init_normalize_loader();
+      init_option_utils();
+      init_parse();
+    }
+  });
+
   // ../core/src/index.ts
   var init_src3 = __esm({
     "../core/src/index.ts"() {
       init_fetch_file();
+      init_load();
     }
   });
 
@@ -3856,10 +5812,10 @@
   });
 
   // src/lib/utils/version.ts
-  var VERSION3;
+  var VERSION4;
   var init_version2 = __esm({
     "src/lib/utils/version.ts"() {
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -3873,7 +5829,8 @@
         BATCHED_3D_MODEL: "b3dm",
         INSTANCED_3D_MODEL: "i3dm",
         GEOMETRY: "geom",
-        VECTOR: "vect"
+        VECTOR: "vect",
+        GLTF: "glTF"
       };
       TILE3D_TYPES = Object.keys(TILE3D_TYPE);
       MAGIC_ARRAY = {
@@ -3893,7 +5850,7 @@
     const string = textDecoder.decode(typedArray);
     return string;
   }
-  function getMagicString2(arrayBuffer, byteOffset = 0) {
+  function getMagicString3(arrayBuffer, byteOffset = 0) {
     const dataView = new DataView(arrayBuffer);
     return `${String.fromCharCode(dataView.getUint8(byteOffset + 0))}${String.fromCharCode(dataView.getUint8(byteOffset + 1))}${String.fromCharCode(dataView.getUint8(byteOffset + 2))}${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;
   }
@@ -3904,10 +5861,10 @@
   });
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION4;
+  var VERSION5;
   var init_version3 = __esm({
     "../draco/src/lib/utils/version.ts"() {
-      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -3929,7 +5886,7 @@
         id: "draco",
         module: "draco",
         shapes: ["mesh"],
-        version: VERSION4,
+        version: VERSION5,
         worker: true,
         extensions: ["drc"],
         mimeTypes: ["application/octet-stream"],
@@ -3972,12 +5929,12 @@
   });
 
   // ../schema/src/lib/utils/assert.ts
-  function assert5(condition, message) {
+  function assert6(condition, message) {
     if (!condition) {
       throw new Error(message || "loader assertion failed.");
     }
   }
-  var init_assert4 = __esm({
+  var init_assert5 = __esm({
     "../schema/src/lib/utils/assert.ts"() {
     }
   });
@@ -3998,10 +5955,10 @@
   var Schema;
   var init_schema = __esm({
     "../schema/src/lib/schema/impl/schema.ts"() {
-      init_assert4();
+      init_assert5();
       Schema = class {
         constructor(fields, metadata) {
-          assert5(Array.isArray(fields));
+          assert6(Array.isArray(fields));
           checkNames(fields);
           this.fields = fields;
           this.metadata = metadata || new Map();
@@ -4137,7 +6094,7 @@
   });
 
   // ../schema/src/lib/schema/impl/type.ts
-  var DataType, Null, Bool, Int, Int8, Int16, Int32, Uint8, Uint16, Uint32, Precision, Float, Float32, Float64, Binary, Utf8, DateUnit, Date, TimeUnit, Time, Timestamp, IntervalUnit, Interval, FixedSizeList, Struct;
+  var DataType, Null, Bool, Int, Int8, Int16, Int32, Uint8, Uint16, Uint32, Precision, Float, Float32, Float64, Binary, Utf8, DateUnit, Date2, TimeUnit, Time, Timestamp, IntervalUnit, Interval, FixedSizeList, Struct;
   var init_type = __esm({
     "../schema/src/lib/schema/impl/type.ts"() {
       init_enum();
@@ -4330,7 +6287,7 @@
         DAY: 0,
         MILLISECOND: 1
       };
-      Date = class extends DataType {
+      Date2 = class extends DataType {
         constructor(unit) {
           super();
           this.unit = unit;
@@ -4960,7 +6917,7 @@
   });
 
   // ../draco/src/index.ts
-  async function parse(arrayBuffer, options) {
+  async function parse2(arrayBuffer, options) {
     const { draco } = await loadDracoDecoderModule(options);
     const dracoParser = new DracoParser(draco);
     try {
@@ -4977,7 +6934,7 @@
       init_draco_module_loader();
       DracoLoader2 = {
         ...DracoLoader,
-        parse
+        parse: parse2
       };
     }
   });
@@ -5089,12 +7046,12 @@
   });
 
   // ../math/src/geometry/utils/assert.ts
-  function assert6(condition, message) {
+  function assert7(condition, message) {
     if (!condition) {
       throw new Error(`math.gl assertion failed. ${message}`);
     }
   }
-  var init_assert5 = __esm({
+  var init_assert6 = __esm({
     "../math/src/geometry/utils/assert.ts"() {
     }
   });
@@ -5122,7 +7079,7 @@
     return value < 0 ? -1 : 1;
   }
   function octDecodeInRange(x, y, rangeMax, result) {
-    assert6(result);
+    assert7(result);
     if (x < 0 || x > rangeMax || y < 0 || y > rangeMax) {
       throw new Error(`x and y must be unsigned normalized integers between 0 and ${rangeMax}`);
     }
@@ -5143,7 +7100,7 @@
   var init_attribute_compression = __esm({
     "../math/src/geometry/compression/attribute-compression.ts"() {
       init_esm();
-      init_assert5();
+      init_assert6();
       RIGHT_SHIFT = 1 / 256;
       scratchVector23 = new Vector2();
       scratchVector32 = new Vector3();
@@ -6135,7 +8092,7 @@
     return await loadDraco(tile, dracoData, options, context);
   }
   async function loadDraco(tile, dracoData, options, context) {
-    const { parse: parse4 } = context;
+    const { parse: parse5 } = context;
     const dracoOptions = {
       ...options,
       draco: {
@@ -6144,7 +8101,7 @@
       }
     };
     delete dracoOptions["3d-tiles"];
-    const data = await parse4(dracoData.buffer, DracoLoader2, dracoOptions);
+    const data = await parse5(dracoData.buffer, DracoLoader2, dracoOptions);
     const decodedPositions = data.attributes.POSITION && data.attributes.POSITION.value;
     const decodedColors = data.attributes.COLOR_0 && data.attributes.COLOR_0.value;
     const decodedNormals = data.attributes.NORMAL && data.attributes.NORMAL.value;
@@ -6195,18 +8152,18 @@
   });
 
   // ../gltf/src/lib/utils/version.ts
-  var VERSION5;
+  var VERSION6;
   var init_version4 = __esm({
     "../gltf/src/lib/utils/version.ts"() {
-      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION6;
+  var VERSION7;
   var init_version5 = __esm({
     "../textures/src/lib/utils/version.ts"() {
-      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -6235,8 +8192,8 @@
       options.wasmBinary = wasmBinary;
     }
     return new Promise((resolve) => {
-      BasisModule(options).then((module) => {
-        const { BasisFile, initializeBasis } = module;
+      BasisModule(options).then((module2) => {
+        const { BasisFile, initializeBasis } = module2;
         initializeBasis();
         resolve({ BasisFile });
       });
@@ -6266,28 +8223,28 @@
       options.wasmBinary = wasmBinary;
     }
     return new Promise((resolve) => {
-      BasisEncoderModule(options).then((module) => {
-        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
+      BasisEncoderModule(options).then((module2) => {
+        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module2;
         initializeBasis();
         resolve({ BasisFile, KTX2File, BasisEncoder });
       });
     });
   }
-  var VERSION7, BASIS_CDN_ENCODER_WASM, BASIS_CDN_ENCODER_JS, loadBasisTranscoderPromise, loadBasisEncoderPromise;
+  var VERSION8, BASIS_CDN_ENCODER_WASM, BASIS_CDN_ENCODER_JS, loadBasisTranscoderPromise, loadBasisEncoderPromise;
   var init_basis_module_loader = __esm({
     "../textures/src/lib/parsers/basis-module-loader.ts"() {
       init_src();
-      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
-      BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION7}/dist/libs/basis_encoder.wasm`;
-      BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION7}/dist/libs/basis_encoder.js`;
+      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION8}/dist/libs/basis_encoder.wasm`;
+      BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION8}/dist/libs/basis_encoder.js`;
     }
   });
 
-  // ../textures/src/lib/gl-constants.ts
-  var GL3;
-  var init_gl_constants = __esm({
-    "../textures/src/lib/gl-constants.ts"() {
-      GL3 = {
+  // ../textures/src/lib/gl-extensions.ts
+  var GL_EXTENSIONS_CONSTANTS;
+  var init_gl_extensions = __esm({
+    "../textures/src/lib/gl-extensions.ts"() {
+      GL_EXTENSIONS_CONSTANTS = {
         COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
         COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
         COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
@@ -6444,7 +8401,7 @@
     }
   });
 
-  // ../textures/src/lib/parsers/parse-basis.js
+  // ../textures/src/lib/parsers/parse-basis.ts
   async function parseBasis(data, options) {
     if (options.basis.containerFormat === "auto") {
       if (isKTX(data)) {
@@ -6580,23 +8537,47 @@
   }
   var OutputFormat;
   var init_parse_basis = __esm({
-    "../textures/src/lib/parsers/parse-basis.js"() {
+    "../textures/src/lib/parsers/parse-basis.ts"() {
       init_basis_module_loader();
-      init_gl_constants();
+      init_gl_extensions();
       init_texture_formats();
       init_parse_ktx();
       OutputFormat = {
-        etc1: { basisFormat: 0, compressed: true, format: GL3.COMPRESSED_RGB_ETC1_WEBGL },
+        etc1: {
+          basisFormat: 0,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
+        },
         etc2: { basisFormat: 1, compressed: true },
-        bc1: { basisFormat: 2, compressed: true, format: GL3.COMPRESSED_RGB_S3TC_DXT1_EXT },
-        bc3: { basisFormat: 3, compressed: true, format: GL3.COMPRESSED_RGBA_S3TC_DXT5_EXT },
+        bc1: {
+          basisFormat: 2,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
+        },
+        bc3: {
+          basisFormat: 3,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
+        },
         bc4: { basisFormat: 4, compressed: true },
         bc5: { basisFormat: 5, compressed: true },
         "bc7-m6-opaque-only": { basisFormat: 6, compressed: true },
         "bc7-m5": { basisFormat: 7, compressed: true },
-        "pvrtc1-4-rgb": { basisFormat: 8, compressed: true, format: GL3.COMPRESSED_RGB_PVRTC_4BPPV1_IMG },
-        "pvrtc1-4-rgba": { basisFormat: 9, compressed: true, format: GL3.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG },
-        "astc-4x4": { basisFormat: 10, compressed: true, format: GL3.COMPRESSED_RGBA_ASTC_4X4_KHR },
+        "pvrtc1-4-rgb": {
+          basisFormat: 8,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+        },
+        "pvrtc1-4-rgba": {
+          basisFormat: 9,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+        },
+        "astc-4x4": {
+          basisFormat: 10,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
+        },
         "atc-rgb": { basisFormat: 11, compressed: true },
         "atc-rgba-interpolated-alpha": { basisFormat: 12, compressed: true },
         rgba32: { basisFormat: 13, compressed: false },
@@ -6617,7 +8598,7 @@
         name: "Basis",
         id: "basis",
         module: "textures",
-        version: VERSION6,
+        version: VERSION7,
         worker: true,
         extensions: ["basis", "ktx2"],
         mimeTypes: ["application/octet-stream", "image/ktx2"],
@@ -6640,10 +8621,10 @@
   });
 
   // ../images/src/lib/utils/version.ts
-  var VERSION8;
+  var VERSION9;
   var init_version6 = __esm({
     "../images/src/lib/utils/version.ts"() {
-      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -6767,13 +8748,13 @@
   // ../images/src/lib/parsers/parse-to-image.ts
   async function parseToImage(arrayBuffer, options, url) {
     const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
-    const URL = self.URL || self.webkitURL;
-    const objectUrl = typeof blobOrDataUrl !== "string" && URL.createObjectURL(blobOrDataUrl);
+    const URL2 = self.URL || self.webkitURL;
+    const objectUrl = typeof blobOrDataUrl !== "string" && URL2.createObjectURL(blobOrDataUrl);
     try {
       return await loadToImage(objectUrl || blobOrDataUrl, options);
     } finally {
       if (objectUrl) {
-        URL.revokeObjectURL(objectUrl);
+        URL2.revokeObjectURL(objectUrl);
       }
     }
   }
@@ -7038,7 +9019,7 @@
         id: "image",
         module: "images",
         name: "Images",
-        version: VERSION8,
+        version: VERSION9,
         mimeTypes: MIME_TYPES,
         extensions: EXTENSIONS,
         parse: parseImage,
@@ -7107,12 +9088,12 @@
   });
 
   // ../gltf/src/lib/utils/assert.ts
-  function assert7(condition, message) {
+  function assert8(condition, message) {
     if (!condition) {
       throw new Error(message || "assert failed: gltf");
     }
   }
-  var init_assert6 = __esm({
+  var init_assert7 = __esm({
     "../gltf/src/lib/utils/assert.ts"() {
     }
   });
@@ -7137,16 +9118,16 @@
   // ../gltf/src/lib/gltf-utils/get-typed-array.ts
   function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {
     const bufferView = json.bufferViews[bufferViewIndex];
-    assert7(bufferView);
+    assert8(bufferView);
     const bufferIndex = bufferView.buffer;
     const binChunk = buffers[bufferIndex];
-    assert7(binChunk);
+    assert8(binChunk);
     const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
     return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
   }
   var init_get_typed_array = __esm({
     "../gltf/src/lib/gltf-utils/get-typed-array.ts"() {
-      init_assert6();
+      init_assert7();
     }
   });
 
@@ -7168,13 +9149,13 @@
     const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
     const length4 = accessor.count * components;
     const byteLength = accessor.count * components * bytesPerComponent;
-    assert7(byteLength >= 0 && byteLength <= bufferView.byteLength);
+    assert8(byteLength >= 0 && byteLength <= bufferView.byteLength);
     return { ArrayType, length: length4, byteLength };
   }
   var TYPES, ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT, ARRAY_TO_COMPONENT_TYPE, ATTRIBUTE_TYPE_TO_COMPONENTS, ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE, ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY;
   var init_gltf_utils = __esm({
     "../gltf/src/lib/gltf-utils/gltf-utils.ts"() {
-      init_assert6();
+      init_assert7();
       TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
       ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
         [Int8Array, 5120],
@@ -7220,7 +9201,7 @@
     "../gltf/src/lib/api/gltf-scenegraph.ts"() {
       init_src8();
       init_src2();
-      init_assert6();
+      init_assert7();
       init_gltf_utils();
       DEFAULT_GLTF_JSON = {
         asset: {
@@ -7319,7 +9300,7 @@
           bufferView = this.getBufferView(bufferView);
           const bufferIndex = bufferView.buffer;
           const binChunk = this.gltf.buffers[bufferIndex];
-          assert7(binChunk);
+          assert8(binChunk);
           const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
           return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
         }
@@ -7366,14 +9347,14 @@
           return extension;
         }
         addExtension(extensionName, extensionData = {}) {
-          assert7(extensionData);
+          assert8(extensionData);
           this.json.extensions = this.json.extensions || {};
           this.json.extensions[extensionName] = extensionData;
           this.registerUsedExtension(extensionName);
           return extensionData;
         }
         addRequiredExtension(extensionName, extensionData = {}) {
-          assert7(extensionData);
+          assert8(extensionData);
           this.addExtension(extensionName, extensionData);
           this.registerRequiredExtension(extensionName);
           return extensionData;
@@ -7471,7 +9452,7 @@
         }
         addBufferView(buffer) {
           const byteLength = buffer.byteLength;
-          assert7(Number.isFinite(byteLength));
+          assert8(Number.isFinite(byteLength));
           this.sourceBuffers = this.sourceBuffers || [];
           this.sourceBuffers.push(buffer);
           const glTFBufferView = {
@@ -8021,10 +10002,10 @@
     }
     const buffer = scenegraph.getTypedArrayForBufferView(dracoExtension.bufferView);
     const bufferCopy = sliceArrayBuffer(buffer.buffer, buffer.byteOffset);
-    const { parse: parse4 } = context;
+    const { parse: parse5 } = context;
     const dracoOptions = { ...options };
     delete dracoOptions["3d-tiles"];
-    const decodedData = await parse4(bufferCopy, DracoLoader2, dracoOptions, context);
+    const decodedData = await parse5(bufferCopy, DracoLoader2, dracoOptions, context);
     const decodedAttributes = getGLTFAccessors(decodedData.attributes);
     for (const [attributeName, decodedAttribute] of Object.entries(decodedAttributes)) {
       if (attributeName in primitive.attributes) {
@@ -8118,7 +10099,7 @@
     const { json } = gltfScenegraph;
     if (json.lights) {
       const extension = gltfScenegraph.addExtension(KHR_LIGHTS_PUNCTUAL);
-      assert7(!extension.lights);
+      assert8(!extension.lights);
       extension.lights = json.lights;
       delete json.lights;
     }
@@ -8133,7 +10114,7 @@
   var KHR_LIGHTS_PUNCTUAL, name5;
   var init_KHR_lights_punctual = __esm({
     "../gltf/src/lib/extensions/deprecated/KHR_lights_punctual.ts"() {
-      init_assert6();
+      init_assert7();
       init_gltf_scenegraph();
       KHR_LIGHTS_PUNCTUAL = "KHR_lights_punctual";
       name5 = KHR_LIGHTS_PUNCTUAL;
@@ -8526,7 +10507,7 @@
   var COMPONENTS, BYTES, GL_SAMPLER, SAMPLER_PARAMETER_GLTF_TO_GL, DEFAULT_SAMPLER, GLTFPostProcessor;
   var init_post_process_gltf = __esm({
     "../gltf/src/lib/api/post-process-gltf.ts"() {
-      init_assert6();
+      init_assert7();
       init_gltf_utils();
       COMPONENTS = {
         SCALAR: 1,
@@ -8575,7 +10556,7 @@
         }
         postProcess(gltf, options = {}) {
           const { json, buffers = [], images = [], baseUri = "" } = gltf;
-          assert7(json);
+          assert8(json);
           this.baseUri = baseUri;
           this.json = json;
           this.buffers = buffers;
@@ -8761,11 +10742,22 @@
             const buffer = accessor.bufferView.buffer;
             const { ArrayType, byteLength } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
             const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
-            const cutBufffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
-            accessor.value = new ArrayType(cutBufffer);
+            let cutBuffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
+            if (accessor.bufferView.byteStride) {
+              cutBuffer = this._getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
+            }
+            accessor.value = new ArrayType(cutBuffer);
           }
           return accessor;
         }
+        _getValueFromInterleavedBuffer(buffer, byteOffset, byteStride, bytesPerElement, count) {
+          const result = new Uint8Array(count * bytesPerElement);
+          for (let i2 = 0; i2 < count; i2++) {
+            const elementOffset = byteOffset + i2 * byteStride;
+            result.set(new Uint8Array(buffer.arrayBuffer.slice(elementOffset, elementOffset + bytesPerElement)), i2 * bytesPerElement);
+          }
+          return result.buffer;
+        }
         _resolveTexture(texture, index) {
           texture.id = texture.id || `texture-${index}`;
           texture.sampler = "sampler" in texture ? this.getSampler(texture.sampler) : DEFAULT_SAMPLER;
@@ -8798,16 +10790,19 @@
           return image;
         }
         _resolveBufferView(bufferView, index) {
-          bufferView.id = bufferView.id || `bufferView-${index}`;
           const bufferIndex = bufferView.buffer;
-          bufferView.buffer = this.buffers[bufferIndex];
+          const result = {
+            id: `bufferView-${index}`,
+            ...bufferView,
+            buffer: this.buffers[bufferIndex]
+          };
           const arrayBuffer = this.buffers[bufferIndex].arrayBuffer;
           let byteOffset = this.buffers[bufferIndex].byteOffset || 0;
           if ("byteOffset" in bufferView) {
             byteOffset += bufferView.byteOffset;
           }
-          bufferView.data = new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
-          return bufferView;
+          result.data = new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
+          return result;
         }
         _resolveCamera(camera, index) {
           camera.id = camera.id || `camera-${index}`;
@@ -8822,7 +10817,7 @@
   });
 
   // ../gltf/src/lib/parsers/parse-glb.ts
-  function getMagicString3(dataView, byteOffset = 0) {
+  function getMagicString4(dataView, byteOffset = 0) {
     return `${String.fromCharCode(dataView.getUint8(byteOffset + 0))}${String.fromCharCode(dataView.getUint8(byteOffset + 1))}${String.fromCharCode(dataView.getUint8(byteOffset + 2))}${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;
   }
   function isGLB(arrayBuffer, byteOffset = 0, options = {}) {
@@ -8833,7 +10828,7 @@
   }
   function parseGLBSync(glb, arrayBuffer, byteOffset = 0, options = {}) {
     const dataView = new DataView(arrayBuffer);
-    const type = getMagicString3(dataView, byteOffset + 0);
+    const type = getMagicString4(dataView, byteOffset + 0);
     const version = dataView.getUint32(byteOffset + 4, LE);
     const byteLength = dataView.getUint32(byteOffset + 8, LE);
     Object.assign(glb, {
@@ -8965,11 +10960,11 @@
     } else if (data instanceof ArrayBuffer) {
       const glb = {};
       byteOffset = parseGLBSync(glb, data, byteOffset, options.glb);
-      assert7(glb.type === "glTF", `Invalid GLB magic string ${glb.type}`);
+      assert8(glb.type === "glTF", `Invalid GLB magic string ${glb.type}`);
       gltf._glb = glb;
       gltf.json = glb.json;
     } else {
-      assert7(false, "GLTF: must be ArrayBuffer or string");
+      assert8(false, "GLTF: must be ArrayBuffer or string");
     }
     const buffers = gltf.json.buffers || [];
     gltf.buffers = new Array(buffers.length).fill(null);
@@ -8990,7 +10985,7 @@
       const buffer = buffers[i2];
       if (buffer.uri) {
         const { fetch: fetch2 } = context;
-        assert7(fetch2);
+        assert8(fetch2);
         const uri = resolveUrl(buffer.uri, options);
         const response = await context?.fetch?.(uri);
         const arrayBuffer = await response?.arrayBuffer?.();
@@ -9023,7 +11018,7 @@
     return Array.from(imageIndices).sort();
   }
   async function loadImage(gltf, image, index, options, context) {
-    const { fetch: fetch2, parse: parse4 } = context;
+    const { fetch: fetch2, parse: parse5 } = context;
     let arrayBuffer;
     if (image.uri) {
       const uri = resolveUrl(image.uri, options);
@@ -9034,8 +11029,8 @@
       const array = getTypedArrayForBufferView(gltf.json, gltf.buffers, image.bufferView);
       arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);
     }
-    assert7(arrayBuffer, "glTF image has no data");
-    let parsedImage = await parse4(arrayBuffer, [ImageLoader, BasisLoader], { mimeType: image.mimeType, basis: { format: selectSupportedBasisFormat() } }, context);
+    assert8(arrayBuffer, "glTF image has no data");
+    let parsedImage = await parse5(arrayBuffer, [ImageLoader, BasisLoader], { mimeType: image.mimeType, basis: options.basis || { format: selectSupportedBasisFormat() } }, context);
     if (parsedImage && parsedImage[0]) {
       parsedImage = {
         compressed: true,
@@ -9053,7 +11048,7 @@
       init_src9();
       init_src8();
       init_src2();
-      init_assert6();
+      init_assert7();
       init_resolve_url();
       init_get_typed_array();
       init_gltf_extensions();
@@ -9064,7 +11059,7 @@
   });
 
   // ../gltf/src/gltf-loader.ts
-  async function parse2(arrayBuffer, options = {}, context) {
+  async function parse3(arrayBuffer, options = {}, context) {
     options = { ...GLTFLoader.options, ...options };
     options.gltf = { ...GLTFLoader.options.gltf, ...options.gltf };
     const { byteOffset = 0 } = options;
@@ -9080,13 +11075,13 @@
         name: "glTF",
         id: "gltf",
         module: "gltf",
-        version: VERSION5,
+        version: VERSION6,
         extensions: ["gltf", "glb"],
         mimeTypes: ["model/gltf+json", "model/gltf-binary"],
         text: true,
         binary: true,
         tests: ["glTF"],
-        parse: parse2,
+        parse: parse3,
         options: {
           gltf: {
             normalize: true,
@@ -9138,13 +11133,13 @@
     const tile3DOptions = options["3d-tiles"] || {};
     extractGLTFBufferOrURL(tile, gltfFormat, options);
     if (tile3DOptions.loadGLTF) {
-      const { parse: parse4, fetch: fetch2 } = context;
+      const { parse: parse5, fetch: fetch2 } = context;
       if (tile.gltfUrl) {
         tile.gltfArrayBuffer = await fetch2(tile.gltfUrl, options);
         tile.gltfByteOffset = 0;
       }
       if (tile.gltfArrayBuffer) {
-        tile.gltf = await parse4(tile.gltfArrayBuffer, GLTFLoader, options, context);
+        tile.gltf = await parse5(tile.gltfArrayBuffer, GLTFLoader, options, context);
         delete tile.gltfArrayBuffer;
         delete tile.gltfByteOffset;
         delete tile.gltfByteLength;
@@ -9381,15 +11376,30 @@
     }
   });
 
+  // src/lib/parsers/parse-3d-tile-gltf.js
+  async function parseGltf3DTile(tile, arrayBuffer, options, context) {
+    tile.rotateYtoZ = true;
+    tile.gltfUpAxis = options["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
+    const { parse: parse5 } = context;
+    tile.gltf = await parse5(arrayBuffer, GLTFLoader, options, context);
+  }
+  var init_parse_3d_tile_gltf = __esm({
+    "src/lib/parsers/parse-3d-tile-gltf.js"() {
+      init_src10();
+    }
+  });
+
   // src/lib/parsers/parse-3d-tile.ts
   async function parse3DTile(arrayBuffer, byteOffset = 0, options, context, tile = {}) {
     tile.byteOffset = byteOffset;
-    tile.type = getMagicString2(arrayBuffer, byteOffset);
+    tile.type = getMagicString3(arrayBuffer, byteOffset);
     switch (tile.type) {
       case TILE3D_TYPE.COMPOSITE:
         return await parseComposite3DTile(tile, arrayBuffer, byteOffset, options, context, parse3DTile);
       case TILE3D_TYPE.BATCHED_3D_MODEL:
         return await parseBatchedModel3DTile(tile, arrayBuffer, byteOffset, options, context);
+      case TILE3D_TYPE.GLTF:
+        return await parseGltf3DTile(tile, arrayBuffer, options, context);
       case TILE3D_TYPE.INSTANCED_3D_MODEL:
         return await parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context);
       case TILE3D_TYPE.POINT_CLOUD:
@@ -9406,6 +11416,219 @@
       init_parse_3d_tile_batched_model();
       init_parse_3d_tile_instanced_model();
       init_parse_3d_tile_composite();
+      init_parse_3d_tile_gltf();
+    }
+  });
+
+  // src/lib/parsers/helpers/parse-3d-tile-subtree.ts
+  async function parse3DTilesSubtree(data) {
+    const magic = new Uint32Array(data.slice(0, 4));
+    if (magic[0] !== SUBTREE_FILE_MAGIC) {
+      throw new Error("Wrong subtree file magic number");
+    }
+    const version = new Uint32Array(data.slice(4, 8));
+    if (version[0] !== SUBTREE_FILE_VERSION) {
+      throw new Error("Wrong subtree file verson, must be 1");
+    }
+    const jsonByteLength = parseUint64Value(data.slice(8, 16));
+    const stringAttribute = new Uint8Array(data, 24, jsonByteLength);
+    const textDecoder = new TextDecoder("utf8");
+    const string = textDecoder.decode(stringAttribute);
+    const subtree = JSON.parse(string);
+    const binaryByteLength = parseUint64Value(data.slice(16, 24));
+    let internalBinaryBuffer = new ArrayBuffer(0);
+    if (binaryByteLength) {
+      internalBinaryBuffer = data.slice(24 + jsonByteLength);
+    }
+    if ("bufferView" in subtree.tileAvailability) {
+      subtree.tileAvailability.explicitBitstream = await getExplicitBitstream(subtree, "tileAvailability", internalBinaryBuffer);
+    }
+    if ("bufferView" in subtree.contentAvailability) {
+      subtree.contentAvailability.explicitBitstream = await getExplicitBitstream(subtree, "contentAvailability", internalBinaryBuffer);
+    }
+    if ("bufferView" in subtree.childSubtreeAvailability) {
+      subtree.childSubtreeAvailability.explicitBitstream = await getExplicitBitstream(subtree, "childSubtreeAvailability", internalBinaryBuffer);
+    }
+    return subtree;
+  }
+  async function getExplicitBitstream(subtree, name8, internalBinaryBuffer) {
+    const bufferViewIndex = subtree[name8].bufferView;
+    const bufferView = subtree.bufferViews[bufferViewIndex];
+    const buffer = subtree.buffers[bufferView.buffer];
+    if (buffer.uri) {
+      const response = await fetchFile(buffer.uri);
+      const data = await response.arrayBuffer();
+      return new Uint8Array(data, bufferView.byteOffset, bufferView.byteLength);
+    }
+    return new Uint8Array(internalBinaryBuffer, bufferView.byteOffset, bufferView.byteLength);
+  }
+  function parseUint64Value(buffer) {
+    const dataView = new DataView(buffer);
+    const left = dataView.getUint32(0, true);
+    const right = dataView.getUint32(4, true);
+    return left + 2 ** 32 * right;
+  }
+  var SUBTREE_FILE_MAGIC, SUBTREE_FILE_VERSION;
+  var init_parse_3d_tile_subtree = __esm({
+    "src/lib/parsers/helpers/parse-3d-tile-subtree.ts"() {
+      init_src3();
+      SUBTREE_FILE_MAGIC = 1952609651;
+      SUBTREE_FILE_VERSION = 1;
+    }
+  });
+
+  // src/tile-3d-subtree-loader.ts
+  var Tile3DSubtreeLoader;
+  var init_tile_3d_subtree_loader = __esm({
+    "src/tile-3d-subtree-loader.ts"() {
+      init_parse_3d_tile_subtree();
+      init_version2();
+      Tile3DSubtreeLoader = {
+        id: "3d-tiles-subtree",
+        name: "3D Tiles Subtree",
+        module: "3d-tiles",
+        version: VERSION4,
+        extensions: ["subtree"],
+        mimeTypes: ["application/octet-stream"],
+        tests: ["subtree"],
+        parse: parse3DTilesSubtree,
+        options: {}
+      };
+    }
+  });
+
+  // src/lib/parsers/helpers/parse-3d-implicit-tiles.ts
+  async function parseImplicitTiles(subtree, options, parentData = {
+    mortonIndex: 0,
+    x: 0,
+    y: 0,
+    z: 0
+  }, childIndex = 0, level = 0, globalData = {
+    level: 0,
+    mortonIndex: 0,
+    x: 0,
+    y: 0,
+    z: 0
+  }) {
+    const {
+      subdivisionScheme,
+      subtreeLevels,
+      maximumLevel,
+      contentUrlTemplate,
+      subtreesUriTemplate,
+      basePath
+    } = options;
+    const tile = { children: [], lodMetricValue: 0, contentUrl: "" };
+    const childrenPerTile = SUBDIVISION_COUNT_MAP[subdivisionScheme];
+    const childX = childIndex & 1;
+    const childY = childIndex >> 1 & 1;
+    const childZ = childIndex >> 2 & 1;
+    const levelOffset = (childrenPerTile ** level - 1) / (childrenPerTile - 1);
+    let childTileMortonIndex = concatBits(parentData.mortonIndex, childIndex);
+    let tileAvailabilityIndex = levelOffset + childTileMortonIndex;
+    let childTileX = concatBits(parentData.x, childX);
+    let childTileY = concatBits(parentData.y, childY);
+    let childTileZ = concatBits(parentData.z, childZ);
+    let isChildSubtreeAvailable = false;
+    if (level + 1 > subtreeLevels) {
+      isChildSubtreeAvailable = getAvailabilityResult(subtree.childSubtreeAvailability, childTileMortonIndex);
+    }
+    const x = concatBits(globalData.x, childTileX);
+    const y = concatBits(globalData.y, childTileY);
+    const z = concatBits(globalData.z, childTileZ);
+    const lev = level + globalData.level;
+    if (isChildSubtreeAvailable) {
+      const subtreePath = `${basePath}/${subtreesUriTemplate}`;
+      const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, lev, x, y, z);
+      const childSubtree = await load(childSubtreeUrl, Tile3DSubtreeLoader);
+      subtree = childSubtree;
+      globalData.mortonIndex = childTileMortonIndex;
+      globalData.x = childTileX;
+      globalData.y = childTileY;
+      globalData.z = childTileZ;
+      globalData.level = level;
+      childTileMortonIndex = 0;
+      tileAvailabilityIndex = 0;
+      childTileX = 0;
+      childTileY = 0;
+      childTileZ = 0;
+      level = 0;
+    }
+    const isTileAvailable = getAvailabilityResult(subtree.tileAvailability, tileAvailabilityIndex);
+    if (!isTileAvailable || level > maximumLevel) {
+      return tile;
+    }
+    const isContentAvailable = getAvailabilityResult(subtree.contentAvailability, tileAvailabilityIndex);
+    if (isContentAvailable) {
+      tile.contentUrl = replaceContentUrlTemplate(contentUrlTemplate, lev, x, y, z);
+    }
+    const childTileLevel = level + 1;
+    const pData = { mortonIndex: childTileMortonIndex, x: childTileX, y: childTileY, z: childTileZ };
+    for (let index = 0; index < childrenPerTile; index++) {
+      const currentTile = await parseImplicitTiles(subtree, options, pData, index, childTileLevel, globalData);
+      if (currentTile.contentUrl || currentTile.children.length) {
+        const globalLevel = lev + 1;
+        const formattedTile = formatTileData(currentTile, globalLevel, options);
+        tile.children.push(formattedTile);
+      }
+    }
+    return tile;
+  }
+  function getAvailabilityResult(availabilityData, index) {
+    if ("constant" in availabilityData) {
+      return Boolean(availabilityData.constant);
+    }
+    if (availabilityData.explicitBitstream) {
+      return getBooleanValueFromBitstream(index, availabilityData.explicitBitstream);
+    }
+    return false;
+  }
+  function formatTileData(tile, level, options) {
+    const { basePath, refine, getRefine: getRefine2, lodMetricType, getTileType: getTileType2, rootLodMetricValue } = options;
+    const uri = tile.contentUrl && tile.contentUrl.replace(`${basePath}/`, "");
+    const lodMetricValue = rootLodMetricValue / 2 ** level;
+    return {
+      children: tile.children,
+      contentUrl: tile.contentUrl,
+      content: { uri },
+      id: tile.contentUrl,
+      refine: getRefine2(refine),
+      type: getTileType2(tile),
+      lodMetricType,
+      lodMetricValue
+    };
+  }
+  function concatBits(first, second) {
+    return parseInt(first.toString(2) + second.toString(2), 2);
+  }
+  function replaceContentUrlTemplate(templateUrl, level, x, y, z) {
+    const mapUrl = generateMapUrl({ level, x, y, z });
+    return templateUrl.replace(/{level}|{x}|{y}|{z}/gi, (matched) => mapUrl[matched]);
+  }
+  function generateMapUrl(items) {
+    const mapUrl = {};
+    for (const key in items) {
+      mapUrl[`{${key}}`] = items[key];
+    }
+    return mapUrl;
+  }
+  function getBooleanValueFromBitstream(availabilityIndex, availabilityBuffer) {
+    const byteIndex = Math.floor(availabilityIndex / 8);
+    const bitIndex = availabilityIndex % 8;
+    const bitValue = availabilityBuffer[byteIndex] >> bitIndex & 1;
+    return bitValue === 1;
+  }
+  var QUADTREE_DEVISION_COUNT, OCTREE_DEVISION_COUNT, SUBDIVISION_COUNT_MAP;
+  var init_parse_3d_implicit_tiles = __esm({
+    "src/lib/parsers/helpers/parse-3d-implicit-tiles.ts"() {
+      init_tile_3d_subtree_loader();
+      init_src3();
+      QUADTREE_DEVISION_COUNT = 4;
+      OCTREE_DEVISION_COUNT = 8;
+      SUBDIVISION_COUNT_MAP = {
+        QUADTREE: QUADTREE_DEVISION_COUNT,
+        OCTREE: OCTREE_DEVISION_COUNT
+      };
     }
   });
 
@@ -9421,6 +11644,8 @@
         return TILE_TYPE.POINTCLOUD;
       case "i3dm":
       case "b3dm":
+      case "glb":
+      case "gltf":
         return TILE_TYPE.SCENEGRAPH;
       default:
         return fileExtension;
@@ -9469,9 +11694,63 @@
     }
     return root;
   }
+  async function normalizeImplicitTileHeaders(tileset) {
+    if (!tileset.root) {
+      return null;
+    }
+    const basePath = tileset.basePath;
+    const implicitTilingExtension = tileset.root.extensions["3DTILES_implicit_tiling"];
+    const {
+      subdivisionScheme,
+      maximumLevel,
+      subtreeLevels,
+      subtrees: { uri: subtreesUriTemplate }
+    } = implicitTilingExtension;
+    const subtreeUrl = replaceContentUrlTemplate(subtreesUriTemplate, 0, 0, 0, 0);
+    const rootSubtreeUrl = `${basePath}/${subtreeUrl}`;
+    const rootSubtree = await load(rootSubtreeUrl, Tile3DSubtreeLoader);
+    const contentUrlTemplate = `${basePath}/${tileset.root.content.uri}`;
+    const refine = tileset.root.refine;
+    const rootLodMetricValue = tileset.root.geometricError;
+    const options = {
+      contentUrlTemplate,
+      subtreesUriTemplate,
+      subdivisionScheme,
+      subtreeLevels,
+      maximumLevel,
+      refine,
+      basePath,
+      lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+      rootLodMetricValue,
+      getTileType,
+      getRefine
+    };
+    return await normalizeImplicitTileData(tileset.root, rootSubtree, options);
+  }
+  async function normalizeImplicitTileData(tile, rootSubtree, options) {
+    if (!tile) {
+      return null;
+    }
+    tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
+    tile.lodMetricValue = tile.geometricError;
+    tile.transformMatrix = tile.transform;
+    const { children, contentUrl } = await parseImplicitTiles(rootSubtree, options);
+    if (contentUrl) {
+      tile.contentUrl = contentUrl;
+      tile.content = { uri: contentUrl.replace(`${options.basePath}/`, "") };
+    }
+    tile.refine = getRefine(tile.refine);
+    tile.type = getTileType(tile);
+    tile.children = children;
+    tile.id = tile.contentUrl;
+    return tile;
+  }
   var init_parse_3d_tile_header2 = __esm({
     "src/lib/parsers/parse-3d-tile-header.ts"() {
+      init_tile_3d_subtree_loader();
+      init_src3();
       init_src4();
+      init_parse_3d_implicit_tiles();
     }
   });
 
@@ -9494,13 +11773,13 @@
     tilesetJson.loader = options.loader || Tiles3DLoader;
     tilesetJson.url = context.url;
     tilesetJson.basePath = getBaseUri(tilesetJson);
-    tilesetJson.root = normalizeTileHeaders(tilesetJson);
+    tilesetJson.root = hasImplicitTilingExtension(tilesetJson) ? await normalizeImplicitTileHeaders(tilesetJson) : normalizeTileHeaders(tilesetJson);
     tilesetJson.type = TILESET_TYPE.TILES3D;
     tilesetJson.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
     tilesetJson.lodMetricValue = tilesetJson.root?.lodMetricValue || 0;
     return tilesetJson;
   }
-  async function parse3(data, options, context) {
+  async function parse4(data, options, context) {
     const loaderOptions = options["3d-tiles"] || {};
     let isTileset;
     if (loaderOptions.isTileset === "auto") {
@@ -9515,7 +11794,10 @@
     }
     return data;
   }
-  var Tiles3DLoader;
+  function hasImplicitTilingExtension(tilesetJson) {
+    return tilesetJson?.extensionsRequired?.includes(IMPLICIT_TILING_EXTENSION_NAME) && tilesetJson?.extensionsUsed?.includes(IMPLICIT_TILING_EXTENSION_NAME);
+  }
+  var IMPLICIT_TILING_EXTENSION_NAME, Tiles3DLoader;
   var init_tiles_3d_loader = __esm({
     "src/tiles-3d-loader.ts"() {
       init_src2();
@@ -9523,15 +11805,16 @@
       init_version2();
       init_parse_3d_tile();
       init_parse_3d_tile_header2();
+      IMPLICIT_TILING_EXTENSION_NAME = "3DTILES_implicit_tiling";
       Tiles3DLoader = {
         id: "3d-tiles",
         name: "3D Tiles",
         module: "3d-tiles",
-        version: VERSION3,
+        version: VERSION4,
         extensions: ["cmpt", "pnts", "b3dm", "i3dm"],
         mimeTypes: ["application/octet-stream"],
         tests: ["cmpt", "pnts", "b3dm", "i3dm"],
-        parse: parse3,
+        parse: parse4,
         options: {
           "3d-tiles": {
             loadGLTF: true,
@@ -9544,7 +11827,7 @@
     }
   });
 
-  // src/lib/ion/ion.js
+  // src/lib/ion/ion.ts
   async function getIonTilesetMetadata(accessToken, assetId) {
     if (!assetId) {
       const assets = await getIonAssets(accessToken);
@@ -9594,7 +11877,7 @@
   }
   var CESIUM_ION_URL;
   var init_ion = __esm({
-    "src/lib/ion/ion.js"() {
+    "src/lib/ion/ion.ts"() {
       init_src3();
       init_src2();
       CESIUM_ION_URL = "https://api.cesium.com/v1/assets";
@@ -9638,83 +11921,6 @@
     }
   });
 
-  // src/lib/parsers/helpers/parse-3d-tile-subtree.ts
-  async function parse3DTilesSubtree(data) {
-    const magic = new Uint32Array(data.slice(0, 4));
-    if (magic[0] !== SUBTREE_FILE_MAGIC) {
-      throw new Error("Wrong subtree file magic number");
-    }
-    const version = new Uint32Array(data.slice(4, 8));
-    if (version[0] !== SUBTREE_FILE_VERSION) {
-      throw new Error("Wrong subtree file verson, must be 1");
-    }
-    const jsonByteLength = parseUint64Value(data.slice(8, 16));
-    const stringAttribute = new Uint8Array(data, 24, jsonByteLength);
-    const textDecoder = new TextDecoder("utf8");
-    const string = textDecoder.decode(stringAttribute);
-    const subtree = JSON.parse(string);
-    const binaryByteLength = parseUint64Value(data.slice(16, 24));
-    let internalBinaryBuffer = new ArrayBuffer(0);
-    if (binaryByteLength) {
-      internalBinaryBuffer = data.slice(24 + jsonByteLength);
-    }
-    if ("bufferView" in subtree.tileAvailability) {
-      subtree.tileAvailability.explicitBitstream = await getExplicitBitstream(subtree, "tileAvailability", internalBinaryBuffer);
-    }
-    if ("bufferView" in subtree.contentAvailability) {
-      subtree.contentAvailability.explicitBitstream = await getExplicitBitstream(subtree, "contentAvailability", internalBinaryBuffer);
-    }
-    if ("bufferView" in subtree.childSubtreeAvailability) {
-      subtree.childSubtreeAvailability.explicitBitstream = await getExplicitBitstream(subtree, "childSubtreeAvailability", internalBinaryBuffer);
-    }
-    return subtree;
-  }
-  async function getExplicitBitstream(subtree, name8, internalBinaryBuffer) {
-    const bufferViewIndex = subtree[name8].bufferView;
-    const bufferView = subtree.bufferViews[bufferViewIndex];
-    const buffer = subtree.buffers[bufferView.buffer];
-    if (buffer.uri) {
-      const response = await fetchFile(buffer.uri);
-      const data = await response.arrayBuffer();
-      return new Uint8Array(data, bufferView.byteOffset, bufferView.byteLength);
-    }
-    return new Uint8Array(internalBinaryBuffer, bufferView.byteOffset, bufferView.byteLength);
-  }
-  function parseUint64Value(buffer) {
-    const dataView = new DataView(buffer);
-    const left = dataView.getUint32(0, true);
-    const right = dataView.getUint32(4, true);
-    return left + 2 ** 32 * right;
-  }
-  var SUBTREE_FILE_MAGIC, SUBTREE_FILE_VERSION;
-  var init_parse_3d_tile_subtree = __esm({
-    "src/lib/parsers/helpers/parse-3d-tile-subtree.ts"() {
-      init_src3();
-      SUBTREE_FILE_MAGIC = 1952609651;
-      SUBTREE_FILE_VERSION = 1;
-    }
-  });
-
-  // src/tile-3d-subtree-loader.ts
-  var Tile3DSubtreeLoader;
-  var init_tile_3d_subtree_loader = __esm({
-    "src/tile-3d-subtree-loader.ts"() {
-      init_parse_3d_tile_subtree();
-      init_version2();
-      Tile3DSubtreeLoader = {
-        id: "3d-tiles-subtree",
-        name: "3D Tiles Subtree",
-        module: "3d-tiles",
-        version: VERSION3,
-        extensions: ["subtree"],
-        mimeTypes: ["application/octet-stream"],
-        tests: ["subtree"],
-        parse: parse3DTilesSubtree,
-        options: {}
-      };
-    }
-  });
-
   // src/lib/encoders/helpers/encode-3d-tile-header.ts
   function encode3DTileHeader(tile, dataView, byteOffset) {
     const HEADER_SIZE = 12;
@@ -9924,7 +12130,7 @@
         name: "3D Tile",
         id: "3d-tiles",
         module: "3d-tiles",
-        version: VERSION3,
+        version: VERSION4,
         extensions: ["cmpt", "pnts", "b3dm", "i3dm"],
         mimeTypes: ["application/octet-stream"],
         encodeSync,
@@ -9963,10 +12169,10 @@
 
   // src/bundle.ts
   var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module) {
+    "src/bundle.ts"(exports, module2) {
       var moduleExports = (init_src11(), src_exports);
       globalThis.loaders = globalThis.loaders || {};
-      module.exports = Object.assign(globalThis.loaders, moduleExports);
+      module2.exports = Object.assign(globalThis.loaders, moduleExports);
     }
   });
   require_bundle();