@loaders.gl/i3s 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/i3s-content-worker.js

@@ -1,3 +1,4 @@
+"use strict";
 (() => {
   var __create = Object.create;
   var __defProp = Object.defineProperty;
@@ -5,36 +6,39 @@
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
   var __export = (target, all) => {
-    __markAsModule(target);
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
-  var __reExport = (target, module, desc) => {
-    if (module && typeof module === "object" || typeof module === "function") {
-      for (let key of __getOwnPropNames(module))
-        if (!__hasOwnProp.call(target, key) && key !== "default")
-          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
     }
-    return target;
+    return to;
   };
-  var __toModule = (module) => {
-    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
   };
 
   // (disabled):../worker-utils/src/lib/node/require-utils.node
   var require_require_utils = __commonJS({
     "(disabled):../worker-utils/src/lib/node/require-utils.node"() {
-    }
-  });
-
-  // (disabled):../core/src/lib/fetch/fetch-file.node
-  var require_fetch_file = __commonJS({
-    "(disabled):../core/src/lib/fetch/fetch-file.node"() {
+      "use strict";
     }
   });
 
@@ -61,7 +65,10 @@
   var window_ = globals.window || globals.self || globals.global || {};
   var global_ = globals.global || globals.self || globals.window || {};
   var document_ = globals.document || {};
-  var isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
+  var isBrowser = (
+    // @ts-ignore process does not exist on browser
+    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+  );
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
@@ -73,7 +80,10 @@
     const options = { ...baseOptions };
     for (const [key, newValue] of Object.entries(newOptions)) {
       if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
-        options[key] = mergeOptionsRecursively(options[key] || {}, newOptions[key]);
+        options[key] = mergeOptionsRecursively(
+          options[key] || {},
+          newOptions[key]
+        );
       } else {
         options[key] = newOptions[key];
       }
@@ -87,10 +97,12 @@
     if (!globalThis._loadersgl_?.version) {
       globalThis._loadersgl_ = globalThis._loadersgl_ || {};
       if (false) {
-        console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+        console.error(
+          "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
+        );
         globalThis._loadersgl_.version = NPM_TAG;
       } else {
-        globalThis._loadersgl_.version = "4.0.0-beta.2";
+        globalThis._loadersgl_.version = "4.0.0-beta.4";
       }
     }
     return globalThis._loadersgl_.version;
@@ -115,7 +127,10 @@
   var window_2 = globals2.window || globals2.self || globals2.global || {};
   var global_2 = globals2.global || globals2.self || globals2.window || {};
   var document_2 = globals2.document || {};
-  var isBrowser2 = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
+  var isBrowser2 = (
+    // @ts-ignore process.browser
+    typeof process !== "object" || String(process) !== "[object process]" || process.browser
+  );
   var isWorker = typeof importScripts === "function";
   var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
   var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
@@ -123,12 +138,16 @@
 
   // ../worker-utils/src/lib/worker-farm/worker-job.ts
   var WorkerJob = class {
+    name;
+    workerThread;
+    isRunning = true;
+    /** Promise that resolves when Job is done */
+    result;
+    _resolve = () => {
+    };
+    _reject = () => {
+    };
     constructor(jobName, workerThread) {
-      this.isRunning = true;
-      this._resolve = () => {
-      };
-      this._reject = () => {
-      };
       this.name = jobName;
       this.workerThread = workerThread;
       this.result = new Promise((resolve2, reject) => {
@@ -136,18 +155,29 @@
         this._reject = reject;
       });
     }
+    /**
+     * Send a message to the job's worker thread
+     * @param data any data structure, ideally consisting mostly of transferrable objects
+     */
     postMessage(type, payload) {
       this.workerThread.postMessage({
         source: "loaders.gl",
+        // Lets worker ignore unrelated messages
         type,
         payload
       });
     }
+    /**
+     * Call to resolve the `result` Promise with the supplied value
+     */
     done(value) {
       assert2(this.isRunning);
       this.isRunning = false;
       this._resolve(value);
     }
+    /**
+     * Call to reject the `result` Promise with the supplied error
+     */
     error(error) {
       assert2(this.isRunning);
       this.isRunning = false;
@@ -162,7 +192,7 @@
   };
 
   // ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
-  var workerURLCache = new Map();
+  var workerURLCache = /* @__PURE__ */ new Map();
   function getLoadableWorkerURL(props) {
     assert2(props.source && !props.url || !props.source && props.url);
     let workerURL = workerURLCache.get(props.source || props.url);
@@ -201,7 +231,7 @@
 
   // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
   function getTransferList(object, recursive = true, transfers) {
-    const transfersSet = transfers || new Set();
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
     if (!object) {
     } else if (isTransferable(object)) {
       transfersSet.add(object);
@@ -238,9 +268,19 @@
   var NOOP = () => {
   };
   var WorkerThread = class {
+    name;
+    source;
+    url;
+    terminated = false;
+    worker;
+    onMessage;
+    onError;
+    _loadableURL = "";
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return typeof Worker !== "undefined" && isBrowser2 || typeof Worker2 !== "undefined" && !isBrowser2;
+    }
     constructor(props) {
-      this.terminated = false;
-      this._loadableURL = "";
       const { name, source, url } = props;
       assert2(source || url);
       this.name = name;
@@ -250,9 +290,10 @@
       this.onError = (error) => console.log(error);
       this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker();
     }
-    static isSupported() {
-      return typeof Worker !== "undefined" && isBrowser2 || typeof Worker2 !== "undefined" && !isBrowser2;
-    }
+    /**
+     * Terminate this worker thread
+     * @note Can free up significant memory
+     */
     destroy() {
       this.onMessage = NOOP;
       this.onError = NOOP;
@@ -262,10 +303,20 @@
     get isRunning() {
       return Boolean(this.onMessage);
     }
+    /**
+     * Send a message to this worker thread
+     * @param data any data structure, ideally consisting mostly of transferrable objects
+     * @param transferList If not supplied, calculated automatically by traversing data
+     */
     postMessage(data, transferList) {
       transferList = transferList || getTransferList(data);
       this.worker.postMessage(data, transferList);
     }
+    // PRIVATE
+    /**
+     * Generate a standard Error from an ErrorEvent
+     * @param event
+     */
     _getErrorFromErrorEvent(event) {
       let message = "Failed to load ";
       message += `worker ${this.name} from ${this.url}. `;
@@ -277,6 +328,9 @@
       }
       return new Error(message);
     }
+    /**
+     * Creates a worker thread on the browser
+     */
     _createBrowserWorker() {
       this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url });
       const worker = new Worker(this._loadableURL, { name: this.name });
@@ -294,6 +348,10 @@
       worker.onmessageerror = (event) => console.error(event);
       return worker;
     }
+    /**
+     * Creates a worker thread in node.js
+     * @todo https://nodejs.org/api/async_hooks.html#async-resource-worker-pool
+     */
     _createNodeWorker() {
       let worker;
       if (this.url) {
@@ -319,25 +377,37 @@
 
   // ../worker-utils/src/lib/worker-farm/worker-pool.ts
   var WorkerPool = class {
+    name = "unnamed";
+    source;
+    // | Function;
+    url;
+    maxConcurrency = 1;
+    maxMobileConcurrency = 1;
+    onDebug = () => {
+    };
+    reuseWorkers = true;
+    props = {};
+    jobQueue = [];
+    idleQueue = [];
+    count = 0;
+    isDestroyed = false;
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return WorkerThread.isSupported();
+    }
+    /**
+     * @param processor - worker function
+     * @param maxConcurrency - max count of workers
+     */
     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);
     }
-    static isSupported() {
-      return WorkerThread.isSupported();
-    }
+    /**
+     * Terminates all workers in the pool
+     * @note Can free up significant memory
+     */
     destroy() {
       this.idleQueue.forEach((worker) => worker.destroy());
       this.isDestroyed = true;
@@ -368,6 +438,11 @@
       this._startQueuedJob();
       return await startPromise;
     }
+    // PRIVATE
+    /**
+     * Starts first queued job if worker is available or can be created
+     * Called when job is started and whenever a worker returns to the idleQueue
+     */
     async _startQueuedJob() {
       if (!this.jobQueue.length) {
         return;
@@ -390,13 +465,30 @@
         queuedJob.onStart(job);
         try {
           await job.result;
+        } catch (error) {
+          console.error(`Worker exception: ${error}`);
         } finally {
           this.returnWorkerToQueue(workerThread);
         }
       }
     }
+    /**
+     * Returns a worker to the idle queue
+     * Destroys the worker if
+     *  - pool is destroyed
+     *  - if this pool doesn't reuse workers
+     *  - if maxConcurrency has been lowered
+     * @param worker
+     */
     returnWorkerToQueue(worker) {
-      const shouldDestroyWorker = !isBrowser2 || this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
+      const shouldDestroyWorker = (
+        // Workers on Node.js prevent the process from exiting.
+        // Until we figure out how to close them before exit, we always destroy them
+        !isBrowser2 || // If the pool is destroyed, there is no reason to keep the worker around
+        this.isDestroyed || // If the app has disabled worker reuse, any completed workers should be destroyed
+        !this.reuseWorkers || // If concurrency has been lowered, this worker might be surplus to requirements
+        this.count > this._getMaxConcurrency()
+      );
       if (shouldDestroyWorker) {
         worker.destroy();
         this.count--;
@@ -407,6 +499,9 @@
         this._startQueuedJob();
       }
     }
+    /**
+     * Returns idle worker or creates new worker if maxConcurrency has not been reached
+     */
     _getAvailableWorker() {
       if (this.idleQueue.length > 0) {
         return this.idleQueue.shift() || null;
@@ -431,33 +526,54 @@
     onDebug: () => {
     }
   };
-  var WorkerFarm = class {
-    constructor(props) {
-      this.workerPools = new Map();
-      this.props = { ...DEFAULT_PROPS };
-      this.setProps(props);
-      this.workerPools = new Map();
-    }
+  var _WorkerFarm = class {
+    props;
+    workerPools = /* @__PURE__ */ new Map();
+    /** Checks if workers are supported on this platform */
     static isSupported() {
       return WorkerThread.isSupported();
     }
+    /** Get the singleton instance of the global worker farm */
     static getWorkerFarm(props = {}) {
-      WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});
-      WorkerFarm._workerFarm.setProps(props);
-      return WorkerFarm._workerFarm;
+      _WorkerFarm._workerFarm = _WorkerFarm._workerFarm || new _WorkerFarm({});
+      _WorkerFarm._workerFarm.setProps(props);
+      return _WorkerFarm._workerFarm;
+    }
+    /** get global instance with WorkerFarm.getWorkerFarm() */
+    constructor(props) {
+      this.props = { ...DEFAULT_PROPS };
+      this.setProps(props);
+      this.workerPools = /* @__PURE__ */ new Map();
     }
+    /**
+     * Terminate all workers in the farm
+     * @note Can free up significant memory
+     */
     destroy() {
       for (const workerPool of this.workerPools.values()) {
         workerPool.destroy();
       }
-      this.workerPools = new Map();
+      this.workerPools = /* @__PURE__ */ new Map();
     }
+    /**
+     * Set props used when initializing worker pools
+     * @param props
+     */
     setProps(props) {
       this.props = { ...this.props, ...props };
       for (const workerPool of this.workerPools.values()) {
         workerPool.setProps(this._getWorkerPoolProps());
       }
     }
+    /**
+     * Returns a worker pool for the specified worker
+     * @param options - only used first time for a specific worker name
+     * @param options.name - the name of the worker - used to identify worker pool
+     * @param options.url -
+     * @param options.source -
+     * @example
+     *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);
+     */
     getWorkerPool(options) {
       const { name, source, url } = options;
       let workerPool = this.workerPools.get(name);
@@ -481,6 +597,9 @@
       };
     }
   };
+  var WorkerFarm = _WorkerFarm;
+  // singleton
+  __publicField(WorkerFarm, "_workerFarm");
 
   // ../worker-utils/src/lib/worker-farm/worker-body.ts
   function getParentPort() {
@@ -492,11 +611,15 @@
     }
     return parentPort;
   }
-  var onMessageWrapperMap = new Map();
+  var onMessageWrapperMap = /* @__PURE__ */ new Map();
   var WorkerBody = class {
+    /** Check that we are actually in a worker thread */
     static inWorkerThread() {
       return typeof self !== "undefined" || Boolean(getParentPort());
     }
+    /*
+     * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
+     */
     static set onmessage(onMessage2) {
       function handleMessage(message) {
         const parentPort3 = getParentPort();
@@ -540,6 +663,11 @@
         globalThis.removeEventListener("message", onMessageWrapper);
       }
     }
+    /**
+     * Send a message from a worker to creating thread (main thread)
+     * @param type
+     * @param payload
+     */
     static postMessage(type, payload) {
       const data = { source: "loaders.gl", type, payload };
       const transferList = getTransferList(payload);
@@ -590,13 +718,14 @@
   }
 
   // ../worker-utils/src/lib/library-utils/library-utils.ts
-  var node = __toModule(require_require_utils());
+  var node = __toESM(require_require_utils(), 1);
   var loadLibraryPromises = {};
   async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
     if (moduleName) {
       libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
     }
-    loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
+    loadLibraryPromises[libraryUrl] = // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
     return await loadLibraryPromises[libraryUrl];
   }
   function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
@@ -626,8 +755,9 @@
     }
     if (!isBrowser2) {
       try {
-        return node && node.requireFromFile && await node.requireFromFile(libraryUrl);
-      } catch {
+        return node && void 0 && await (void 0)(libraryUrl);
+      } catch (error) {
+        console.error(error);
         return null;
       }
     }
@@ -639,10 +769,10 @@
   }
   function loadLibraryFromString(scriptSource, id) {
     if (!isBrowser2) {
-      return node.requireFromString && node.requireFromString(scriptSource, id);
+      return void 0 && (void 0)(scriptSource, id);
     }
     if (isWorker) {
-      eval.call(global_2, scriptSource);
+      eval.call(globalThis, scriptSource);
       return null;
     }
     const script = document.createElement("script");
@@ -656,18 +786,18 @@
     return null;
   }
   async function loadAsArrayBuffer(url) {
-    if (!node.readFileAsArrayBuffer || url.startsWith("http")) {
+    if (!void 0 || url.startsWith("http")) {
       const response = await fetch(url);
       return await response.arrayBuffer();
     }
-    return await node.readFileAsArrayBuffer(url);
+    return await (void 0)(url);
   }
   async function loadAsText(url) {
-    if (!node.readFileAsText || url.startsWith("http")) {
+    if (!void 0 || url.startsWith("http")) {
       const response = await fetch(url);
       return await response.text();
     }
-    return await node.readFileAsText(url);
+    return await (void 0)(url);
   }
 
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
@@ -685,6 +815,7 @@
               loader,
               arrayBuffer: input,
               options,
+              // @ts-expect-error fetch missing
               context: {
                 ...context,
                 _parse: parseOnMainThread
@@ -767,8 +898,14 @@
     const workerPool = workerFarm.getWorkerPool({ name, url });
     options = JSON.parse(JSON.stringify(options));
     context = JSON.parse(JSON.stringify(context || {}));
-    const job = await workerPool.startJob("process-on-worker", onMessage.bind(null, parseOnMainThread2));
+    const job = await workerPool.startJob(
+      "process-on-worker",
+      // @ts-expect-error
+      onMessage.bind(null, parseOnMainThread2)
+      // eslint-disable-line @typescript-eslint/no-misused-promises
+    );
     job.postMessage("process", {
+      // @ts-ignore
       input: data,
       options,
       context
@@ -815,7 +952,9 @@
     return true;
   }
   function concatenateArrayBuffers(...sources) {
-    const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+    const sourceArrays = sources.map(
+      (source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2
+    );
     const byteLength = sourceArrays.reduce((length2, typedArray) => length2 + typedArray.byteLength, 0);
     const result = new Uint8Array(byteLength);
     let offset = 0;
@@ -838,10 +977,10 @@
   // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
   function _typeof(obj) {
     "@babel/helpers - typeof";
-    return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(obj2) {
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
       return typeof obj2;
     } : function(obj2) {
-      return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
     }, _typeof(obj);
   }
 
@@ -1243,7 +1382,6 @@
   }
 
   // ../core/src/lib/fetch/fetch-file.ts
-  var node3 = __toModule(require_fetch_file());
   function isNodePath(url) {
     return !isRequestURL(url) && !isDataURL(url);
   }
@@ -1256,8 +1394,10 @@
   async function fetchFile(urlOrData, fetchOptions) {
     if (typeof urlOrData === "string") {
       const url = resolvePath(urlOrData);
-      if (isNodePath(url) && node3?.fetchFileNode) {
-        return node3.fetchFileNode(url, fetchOptions);
+      if (isNodePath(url)) {
+        if (globalThis.loaders?.fetchNode) {
+          return globalThis.loaders?.fetchNode(url, fetchOptions);
+        }
       }
       return await fetch(url, fetchOptions);
     }
@@ -1295,7 +1435,7 @@
   var navigator_ = globalThis.navigator || {};
 
   // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
-  var VERSION2 = true ? "4.0.0-beta.2" : "untranspiled source";
+  var VERSION2 = true ? "4.0.0-beta.4" : "untranspiled source";
   var isBrowser4 = isBrowser3();
 
   // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
@@ -1361,14 +1501,14 @@
     const padLength = Math.max(length2 - string.length, 0);
     return "".concat(" ".repeat(padLength)).concat(string);
   }
-  function formatImage(image, message, scale2) {
+  function formatImage(image, message, scale3) {
     let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600;
     const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29");
     if (image.width > maxWidth) {
-      scale2 = Math.min(scale2, maxWidth / image.width);
+      scale3 = Math.min(scale3, maxWidth / image.width);
     }
-    const width = image.width * scale2;
-    const height = image.height * scale2;
+    const width = image.width * scale3;
+    const height = image.height * scale3;
     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];
   }
@@ -1405,11 +1545,11 @@
     if (!isBrowser3 && typeof string === "string") {
       if (color) {
         const colorCode = getColor(color);
-        string = "[".concat(colorCode, "m").concat(string, "");
+        string = "\x1B[".concat(colorCode, "m").concat(string, "\x1B[39m");
       }
       if (background) {
         const colorCode = getColor(background);
-        string = "[".concat(colorCode + BACKGROUND_INCREMENT, "m").concat(string, "");
+        string = "\x1B[".concat(colorCode + BACKGROUND_INCREMENT, "m").concat(string, "\x1B[49m");
       }
     }
     return string;
@@ -1592,7 +1732,7 @@
         priority,
         image,
         message = "",
-        scale: scale2 = 1
+        scale: scale3 = 1
       } = _ref;
       if (!this._shouldLog(logLevel || priority)) {
         return noop;
@@ -1600,11 +1740,11 @@
       return isBrowser3() ? logImageInBrowser({
         image,
         message,
-        scale: scale2
+        scale: scale3
       }) : logImageInNode({
         image,
         message,
-        scale: scale2
+        scale: scale3
       });
     }
     time(logLevel, message) {
@@ -1745,7 +1885,7 @@
     let {
       image,
       message = "",
-      scale: scale2 = 1
+      scale: scale3 = 1
     } = _ref2;
     console.warn("removed");
     return noop;
@@ -1754,12 +1894,12 @@
     let {
       image,
       message = "",
-      scale: scale2 = 1
+      scale: scale3 = 1
     } = _ref3;
     if (typeof image === "string") {
       const img = new Image();
       img.onload = () => {
-        const args = formatImage(img, message, scale2);
+        const args = formatImage(img, message, scale3);
         console.log(...args);
       };
       img.src = image;
@@ -1767,12 +1907,12 @@
     }
     const element = image.nodeName || "";
     if (element.toLowerCase() === "img") {
-      console.log(...formatImage(image, message, scale2));
+      console.log(...formatImage(image, message, scale3));
       return noop;
     }
     if (element.toLowerCase() === "canvas") {
       const img = new Image();
-      img.onload = () => console.log(...formatImage(img, message, scale2));
+      img.onload = () => console.log(...formatImage(img, message, scale3));
       img.src = image.toDataURL();
       return noop;
     }
@@ -1813,6 +1953,7 @@
     }
   };
   var ConsoleLog = class {
+    console;
     constructor() {
       this.console = console;
     }
@@ -1832,29 +1973,39 @@
 
   // ../core/src/lib/loader-utils/option-defaults.ts
   var DEFAULT_LOADER_OPTIONS = {
+    // baseUri
     fetch: null,
     mimeType: void 0,
     nothrow: false,
     log: new ConsoleLog(),
+    // A probe.gl compatible (`log.log()()` syntax) that just logs to console
     useLocalLibraries: false,
     CDN: "https://unpkg.com/@loaders.gl",
     worker: true,
+    // By default, use worker if provided by loader.
     maxConcurrency: 3,
+    // How many worker instances should be created for each loader.
     maxMobileConcurrency: 1,
+    // How many worker instances should be created for each loader on mobile devices.
     reuseWorkers: isBrowser,
+    // By default reuse workers in browser (Node.js refuses to terminate if browsers are running)
     _nodeWorkers: false,
+    // By default do not support node workers
     _workerType: "",
+    // 'test' to use locally generated workers
     limit: 0,
     _limitMB: 0,
     batchSize: "auto",
     batchDebounceMs: 0,
     metadata: false,
+    // TODO - currently only implemented for parseInBatches, adds initial metadata batch,
     transforms: []
   };
   var REMOVED_LOADER_OPTIONS = {
     throws: "nothrow",
     dataType: "(no longer used)",
     uri: "baseUri",
+    // Warn if fetch options are used on top-level
     method: "fetch.method",
     headers: "fetch.headers",
     body: "fetch.body",
@@ -1905,10 +2056,14 @@
       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]}'`)();
+          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}`)();
+          probeLog.warn(
+            `${loaderName} loader option '${prefix}${key}' not recognized. ${suggestion}`
+          )();
         }
       }
     }
@@ -2408,7 +2563,12 @@
       return null;
     }
     options = normalizeOptions(options, loader, candidateLoaders, url);
-    context = getLoaderContext({ url, _parse: parse, loaders: candidateLoaders }, options, context || null);
+    context = getLoaderContext(
+      // @ts-expect-error
+      { url, _parse: parse, loaders: candidateLoaders },
+      options,
+      context || null
+    );
     return await parseWithLoader(loader, data, options, context);
   }
   async function parseWithLoader(loader, data, options, context) {
@@ -2461,24 +2621,24 @@
     return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions);
   }
 
-  // ../../node_modules/@math.gl/core/dist/esm/lib/assert.js
-  function assert4(condition, message) {
-    if (!condition) {
-      throw new Error("math.gl assertion ".concat(message));
-    }
-  }
-
-  // ../../node_modules/@math.gl/core/dist/esm/lib/common.js
+  // ../../node_modules/@math.gl/core/dist/lib/common.js
   var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
   var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
-  var config = {
+  var DEFAULT_CONFIG = {
     EPSILON: 1e-12,
     debug: false,
     precision: 4,
     printTypes: false,
     printDegrees: false,
-    printRowMajor: true
+    printRowMajor: true,
+    _cartographicRadians: false
   };
+  globalThis.mathgl = globalThis.mathgl || {
+    config: {
+      ...DEFAULT_CONFIG
+    }
+  };
+  var config = globalThis.mathgl.config;
   function formatValue(value, {
     precision = config.precision
   } = {}) {
@@ -2545,14 +2705,15 @@
       const array = value;
       result = result || duplicateArray(array);
       for (let i2 = 0; i2 < result.length && i2 < array.length; ++i2) {
-        result[i2] = func(value[i2], i2, result);
+        const val = typeof value === "number" ? value : value[i2];
+        result[i2] = func(val, i2, result);
       }
       return result;
     }
     return func(value);
   }
 
-  // ../../node_modules/@math.gl/core/dist/esm/classes/base/math-array.js
+  // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
   function _extendableBuiltin(cls) {
     function ExtendableBuiltin() {
       var instance = Reflect.construct(cls, Array.from(arguments));
@@ -2590,6 +2751,9 @@
       }
       return targetArray;
     }
+    toObject(targetObject) {
+      return targetObject;
+    }
     from(arrayOrObject) {
       return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
     }
@@ -2649,7 +2813,8 @@
       }
       for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
         const ai = a2[i2];
-        this[i2] = ai + t2 * (b[i2] - ai);
+        const endValue = typeof b === "number" ? b : b[i2];
+        this[i2] = ai + t2 * (endValue - ai);
       }
       return this.check();
     }
@@ -2687,14 +2852,14 @@
       }
       return this.check();
     }
-    scale(scale2) {
-      if (typeof scale2 === "number") {
+    scale(scale3) {
+      if (typeof scale3 === "number") {
         for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-          this[i2] *= scale2;
+          this[i2] *= scale3;
         }
       } else {
-        for (let i2 = 0; i2 < this.ELEMENTS && i2 < scale2.length; ++i2) {
-          this[i2] *= scale2[i2];
+        for (let i2 = 0; i2 < this.ELEMENTS && i2 < scale3.length; ++i2) {
+          this[i2] *= scale3[i2];
         }
       }
       return this.check();
@@ -2745,9 +2910,9 @@
     divideScalar(a2) {
       return this.multiplyByScalar(1 / a2);
     }
-    clampScalar(min, max) {
+    clampScalar(min2, max2) {
       for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] = Math.min(Math.max(this[i2], min), max);
+        this[i2] = Math.min(Math.max(this[i2], min2), max2);
       }
       return this.check();
     }
@@ -2756,7 +2921,7 @@
     }
   };
 
-  // ../../node_modules/@math.gl/core/dist/esm/lib/validators.js
+  // ../../node_modules/@math.gl/core/dist/lib/validators.js
   function validateVector(v, length2) {
     if (v.length !== length2) {
       return false;
@@ -2770,7 +2935,7 @@
   }
   function checkNumber(value) {
     if (!Number.isFinite(value)) {
-      throw new Error("Invalid number ".concat(value));
+      throw new Error("Invalid number ".concat(JSON.stringify(value)));
     }
     return value;
   }
@@ -2781,7 +2946,14 @@
     return v;
   }
 
-  // ../../node_modules/@math.gl/core/dist/esm/classes/base/vector.js
+  // ../../node_modules/@math.gl/core/dist/lib/assert.js
+  function assert4(condition, message) {
+    if (!condition) {
+      throw new Error("math.gl assertion ".concat(message));
+    }
+  }
+
+  // ../../node_modules/@math.gl/core/dist/classes/base/vector.js
   var Vector = class extends MathArray {
     get x() {
       return this[0];
@@ -2817,8 +2989,8 @@
     distanceSquared(mathArray) {
       let length2 = 0;
       for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        const dist = this[i2] - mathArray[i2];
-        length2 += dist * dist;
+        const dist2 = this[i2] - mathArray[i2];
+        length2 += dist2 * dist2;
       }
       return checkNumber(length2);
     }
@@ -2886,22 +3058,20 @@
     }
   };
 
-  // ../../node_modules/gl-matrix/esm/common.js
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/common.js
   var EPSILON = 1e-6;
   var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+  var RANDOM = Math.random;
+  function round2(a2) {
+    if (a2 >= 0)
+      return Math.round(a2);
+    return a2 % 0.5 === 0 ? Math.floor(a2) : Math.round(a2);
+  }
   var degree = Math.PI / 180;
-  if (!Math.hypot)
-    Math.hypot = function() {
-      var y = 0, i2 = arguments.length;
-      while (i2--) {
-        y += arguments[i2] * arguments[i2];
-      }
-      return Math.sqrt(y);
-    };
 
-  // ../../node_modules/gl-matrix/esm/vec2.js
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec2.js
   function create() {
-    var out = new ARRAY_TYPE(2);
+    const out = new ARRAY_TYPE(2);
     if (ARRAY_TYPE != Float32Array) {
       out[0] = 0;
       out[1] = 0;
@@ -2909,16 +3079,17 @@
     return out;
   }
   function transformMat4(out, a2, m) {
-    var x = a2[0];
-    var y = a2[1];
+    const x = a2[0];
+    const y = a2[1];
     out[0] = m[0] * x + m[4] * y + m[12];
     out[1] = m[1] * x + m[5] * y + m[13];
     return out;
   }
   var forEach2 = function() {
-    var vec = create();
+    const vec = create();
     return function(a2, stride, offset, count, fn, arg) {
-      var i2, l2;
+      let i2;
+      let l2;
       if (!stride) {
         stride = 2;
       }
@@ -2941,7 +3112,7 @@
     };
   }();
 
-  // ../../node_modules/@math.gl/core/dist/esm/lib/gl-matrix-extras.js
+  // ../../node_modules/@math.gl/core/dist/lib/gl-matrix-extras.js
   function vec2_transformMat4AsVector(out, a2, m) {
     const x = a2[0];
     const y = a2[1];
@@ -2969,9 +3140,61 @@
     return out;
   }
 
-  // ../../node_modules/gl-matrix/esm/vec3.js
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec3.js
+  var vec3_exports = {};
+  __export(vec3_exports, {
+    add: () => add,
+    angle: () => angle,
+    bezier: () => bezier,
+    ceil: () => ceil,
+    clone: () => clone,
+    copy: () => copy,
+    create: () => create2,
+    cross: () => cross,
+    dist: () => dist,
+    distance: () => distance,
+    div: () => div,
+    divide: () => divide,
+    dot: () => dot,
+    equals: () => equals2,
+    exactEquals: () => exactEquals,
+    floor: () => floor,
+    forEach: () => forEach3,
+    fromValues: () => fromValues,
+    hermite: () => hermite,
+    inverse: () => inverse,
+    len: () => len,
+    length: () => length,
+    lerp: () => lerp,
+    max: () => max,
+    min: () => min,
+    mul: () => mul,
+    multiply: () => multiply,
+    negate: () => negate,
+    normalize: () => normalize,
+    random: () => random,
+    rotateX: () => rotateX,
+    rotateY: () => rotateY,
+    rotateZ: () => rotateZ,
+    round: () => round3,
+    scale: () => scale,
+    scaleAndAdd: () => scaleAndAdd,
+    set: () => set,
+    slerp: () => slerp,
+    sqrDist: () => sqrDist,
+    sqrLen: () => sqrLen,
+    squaredDistance: () => squaredDistance,
+    squaredLength: () => squaredLength,
+    str: () => str,
+    sub: () => sub,
+    subtract: () => subtract,
+    transformMat3: () => transformMat3,
+    transformMat4: () => transformMat42,
+    transformQuat: () => transformQuat,
+    zero: () => zero
+  });
   function create2() {
-    var out = new ARRAY_TYPE(3);
+    const out = new ARRAY_TYPE(3);
     if (ARRAY_TYPE != Float32Array) {
       out[0] = 0;
       out[1] = 0;
@@ -2979,26 +3202,220 @@
     }
     return out;
   }
+  function clone(a2) {
+    const out = new ARRAY_TYPE(3);
+    out[0] = a2[0];
+    out[1] = a2[1];
+    out[2] = a2[2];
+    return out;
+  }
   function length(a2) {
-    var x = a2[0];
-    var y = a2[1];
-    var z = a2[2];
-    return Math.hypot(x, y, z);
+    const x = a2[0];
+    const y = a2[1];
+    const z = a2[2];
+    return Math.sqrt(x * x + y * y + z * z);
+  }
+  function fromValues(x, y, z) {
+    const out = new ARRAY_TYPE(3);
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    return out;
+  }
+  function copy(out, a2) {
+    out[0] = a2[0];
+    out[1] = a2[1];
+    out[2] = a2[2];
+    return out;
+  }
+  function set(out, x, y, z) {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    return out;
+  }
+  function add(out, a2, b) {
+    out[0] = a2[0] + b[0];
+    out[1] = a2[1] + b[1];
+    out[2] = a2[2] + b[2];
+    return out;
+  }
+  function subtract(out, a2, b) {
+    out[0] = a2[0] - b[0];
+    out[1] = a2[1] - b[1];
+    out[2] = a2[2] - b[2];
+    return out;
+  }
+  function multiply(out, a2, b) {
+    out[0] = a2[0] * b[0];
+    out[1] = a2[1] * b[1];
+    out[2] = a2[2] * b[2];
+    return out;
+  }
+  function divide(out, a2, b) {
+    out[0] = a2[0] / b[0];
+    out[1] = a2[1] / b[1];
+    out[2] = a2[2] / b[2];
+    return out;
+  }
+  function ceil(out, a2) {
+    out[0] = Math.ceil(a2[0]);
+    out[1] = Math.ceil(a2[1]);
+    out[2] = Math.ceil(a2[2]);
+    return out;
+  }
+  function floor(out, a2) {
+    out[0] = Math.floor(a2[0]);
+    out[1] = Math.floor(a2[1]);
+    out[2] = Math.floor(a2[2]);
+    return out;
+  }
+  function min(out, a2, b) {
+    out[0] = Math.min(a2[0], b[0]);
+    out[1] = Math.min(a2[1], b[1]);
+    out[2] = Math.min(a2[2], b[2]);
+    return out;
+  }
+  function max(out, a2, b) {
+    out[0] = Math.max(a2[0], b[0]);
+    out[1] = Math.max(a2[1], b[1]);
+    out[2] = Math.max(a2[2], b[2]);
+    return out;
+  }
+  function round3(out, a2) {
+    out[0] = round2(a2[0]);
+    out[1] = round2(a2[1]);
+    out[2] = round2(a2[2]);
+    return out;
+  }
+  function scale(out, a2, b) {
+    out[0] = a2[0] * b;
+    out[1] = a2[1] * b;
+    out[2] = a2[2] * b;
+    return out;
+  }
+  function scaleAndAdd(out, a2, b, scale3) {
+    out[0] = a2[0] + b[0] * scale3;
+    out[1] = a2[1] + b[1] * scale3;
+    out[2] = a2[2] + b[2] * scale3;
+    return out;
+  }
+  function distance(a2, b) {
+    const x = b[0] - a2[0];
+    const y = b[1] - a2[1];
+    const z = b[2] - a2[2];
+    return Math.sqrt(x * x + y * y + z * z);
+  }
+  function squaredDistance(a2, b) {
+    const x = b[0] - a2[0];
+    const y = b[1] - a2[1];
+    const z = b[2] - a2[2];
+    return x * x + y * y + z * z;
+  }
+  function squaredLength(a2) {
+    const x = a2[0];
+    const y = a2[1];
+    const z = a2[2];
+    return x * x + y * y + z * z;
+  }
+  function negate(out, a2) {
+    out[0] = -a2[0];
+    out[1] = -a2[1];
+    out[2] = -a2[2];
+    return out;
+  }
+  function inverse(out, a2) {
+    out[0] = 1 / a2[0];
+    out[1] = 1 / a2[1];
+    out[2] = 1 / a2[2];
+    return out;
+  }
+  function normalize(out, a2) {
+    const x = a2[0];
+    const y = a2[1];
+    const z = a2[2];
+    let len2 = x * x + y * y + z * z;
+    if (len2 > 0) {
+      len2 = 1 / Math.sqrt(len2);
+    }
+    out[0] = a2[0] * len2;
+    out[1] = a2[1] * len2;
+    out[2] = a2[2] * len2;
+    return out;
   }
   function dot(a2, b) {
     return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
   }
   function cross(out, a2, b) {
-    var ax = a2[0], ay = a2[1], az = a2[2];
-    var bx = b[0], by = b[1], bz = b[2];
+    const ax = a2[0];
+    const ay = a2[1];
+    const az = a2[2];
+    const bx = b[0];
+    const by = b[1];
+    const bz = b[2];
     out[0] = ay * bz - az * by;
     out[1] = az * bx - ax * bz;
     out[2] = ax * by - ay * bx;
     return out;
   }
+  function lerp(out, a2, b, t2) {
+    const ax = a2[0];
+    const ay = a2[1];
+    const az = a2[2];
+    out[0] = ax + t2 * (b[0] - ax);
+    out[1] = ay + t2 * (b[1] - ay);
+    out[2] = az + t2 * (b[2] - az);
+    return out;
+  }
+  function slerp(out, a2, b, t2) {
+    const angle2 = Math.acos(Math.min(Math.max(dot(a2, b), -1), 1));
+    const sinTotal = Math.sin(angle2);
+    const ratioA = Math.sin((1 - t2) * angle2) / sinTotal;
+    const ratioB = Math.sin(t2 * angle2) / sinTotal;
+    out[0] = ratioA * a2[0] + ratioB * b[0];
+    out[1] = ratioA * a2[1] + ratioB * b[1];
+    out[2] = ratioA * a2[2] + ratioB * b[2];
+    return out;
+  }
+  function hermite(out, a2, b, c2, d, t2) {
+    const factorTimes2 = t2 * t2;
+    const factor1 = factorTimes2 * (2 * t2 - 3) + 1;
+    const factor2 = factorTimes2 * (t2 - 2) + t2;
+    const factor3 = factorTimes2 * (t2 - 1);
+    const factor4 = factorTimes2 * (3 - 2 * t2);
+    out[0] = a2[0] * factor1 + b[0] * factor2 + c2[0] * factor3 + d[0] * factor4;
+    out[1] = a2[1] * factor1 + b[1] * factor2 + c2[1] * factor3 + d[1] * factor4;
+    out[2] = a2[2] * factor1 + b[2] * factor2 + c2[2] * factor3 + d[2] * factor4;
+    return out;
+  }
+  function bezier(out, a2, b, c2, d, t2) {
+    const inverseFactor = 1 - t2;
+    const inverseFactorTimesTwo = inverseFactor * inverseFactor;
+    const factorTimes2 = t2 * t2;
+    const factor1 = inverseFactorTimesTwo * inverseFactor;
+    const factor2 = 3 * t2 * inverseFactorTimesTwo;
+    const factor3 = 3 * factorTimes2 * inverseFactor;
+    const factor4 = factorTimes2 * t2;
+    out[0] = a2[0] * factor1 + b[0] * factor2 + c2[0] * factor3 + d[0] * factor4;
+    out[1] = a2[1] * factor1 + b[1] * factor2 + c2[1] * factor3 + d[1] * factor4;
+    out[2] = a2[2] * factor1 + b[2] * factor2 + c2[2] * factor3 + d[2] * factor4;
+    return out;
+  }
+  function random(out, scale3) {
+    scale3 = scale3 === void 0 ? 1 : scale3;
+    const r2 = RANDOM() * 2 * Math.PI;
+    const z = RANDOM() * 2 - 1;
+    const zScale = Math.sqrt(1 - z * z) * scale3;
+    out[0] = Math.cos(r2) * zScale;
+    out[1] = Math.sin(r2) * zScale;
+    out[2] = z * scale3;
+    return out;
+  }
   function transformMat42(out, a2, m) {
-    var x = a2[0], y = a2[1], z = a2[2];
-    var w = m[3] * x + m[7] * y + m[11] * z + m[15];
+    const x = a2[0];
+    const y = a2[1];
+    const z = a2[2];
+    let w = m[3] * x + m[7] * y + m[11] * z + m[15];
     w = w || 1;
     out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
     out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
@@ -3006,18 +3423,29 @@
     return out;
   }
   function transformMat3(out, a2, m) {
-    var x = a2[0], y = a2[1], z = a2[2];
+    const x = a2[0];
+    const y = a2[1];
+    const z = a2[2];
     out[0] = x * m[0] + y * m[3] + z * m[6];
     out[1] = x * m[1] + y * m[4] + z * m[7];
     out[2] = x * m[2] + y * m[5] + z * m[8];
     return out;
   }
   function transformQuat(out, a2, q) {
-    var qx = q[0], qy = q[1], qz = q[2], qw = q[3];
-    var x = a2[0], y = a2[1], z = a2[2];
-    var uvx = qy * z - qz * y, uvy = qz * x - qx * z, uvz = qx * y - qy * x;
-    var uuvx = qy * uvz - qz * uvy, uuvy = qz * uvx - qx * uvz, uuvz = qx * uvy - qy * uvx;
-    var w2 = qw * 2;
+    const qx = q[0];
+    const qy = q[1];
+    const qz = q[2];
+    const qw = q[3];
+    const x = a2[0];
+    const y = a2[1];
+    const z = a2[2];
+    let uvx = qy * z - qz * y;
+    let uvy = qz * x - qx * z;
+    let uvz = qx * y - qy * x;
+    let uuvx = qy * uvz - qz * uvy;
+    let uuvy = qz * uvx - qx * uvz;
+    let uuvz = qx * uvy - qy * uvx;
+    const w2 = qw * 2;
     uvx *= w2;
     uvy *= w2;
     uvz *= w2;
@@ -3030,7 +3458,8 @@
     return out;
   }
   function rotateX(out, a2, b, rad) {
-    var p2 = [], r2 = [];
+    const p2 = [];
+    const r2 = [];
     p2[0] = a2[0] - b[0];
     p2[1] = a2[1] - b[1];
     p2[2] = a2[2] - b[2];
@@ -3043,7 +3472,8 @@
     return out;
   }
   function rotateY(out, a2, b, rad) {
-    var p2 = [], r2 = [];
+    const p2 = [];
+    const r2 = [];
     p2[0] = a2[0] - b[0];
     p2[1] = a2[1] - b[1];
     p2[2] = a2[2] - b[2];
@@ -3056,7 +3486,8 @@
     return out;
   }
   function rotateZ(out, a2, b, rad) {
-    var p2 = [], r2 = [];
+    const p2 = [];
+    const r2 = [];
     p2[0] = a2[0] - b[0];
     p2[1] = a2[1] - b[1];
     p2[2] = a2[2] - b[2];
@@ -3069,13 +3500,49 @@
     return out;
   }
   function angle(a2, b) {
-    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;
+    const ax = a2[0];
+    const ay = a2[1];
+    const az = a2[2];
+    const bx = b[0];
+    const by = b[1];
+    const bz = b[2];
+    const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz));
+    const cosine = mag && dot(a2, b) / mag;
     return Math.acos(Math.min(Math.max(cosine, -1), 1));
   }
+  function zero(out) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    return out;
+  }
+  function str(a2) {
+    return "vec3(".concat(a2[0], ", ").concat(a2[1], ", ").concat(a2[2], ")");
+  }
+  function exactEquals(a2, b) {
+    return a2[0] === b[0] && a2[1] === b[1] && a2[2] === b[2];
+  }
+  function equals2(a2, b) {
+    const a0 = a2[0];
+    const a1 = a2[1];
+    const a22 = a2[2];
+    const b0 = b[0];
+    const b1 = b[1];
+    const b2 = b[2];
+    return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a22 - b2) <= EPSILON * Math.max(1, Math.abs(a22), Math.abs(b2));
+  }
+  var sub = subtract;
+  var mul = multiply;
+  var div = divide;
+  var dist = distance;
+  var sqrDist = squaredDistance;
+  var len = length;
+  var sqrLen = squaredLength;
   var forEach3 = function() {
-    var vec = create2();
+    const vec = create2();
     return function(a2, stride, offset, count, fn, arg) {
-      var i2, l2;
+      let i2;
+      let l2;
       if (!stride) {
         stride = 3;
       }
@@ -3100,7 +3567,7 @@
     };
   }();
 
-  // ../../node_modules/@math.gl/core/dist/esm/classes/vector3.js
+  // ../../node_modules/@math.gl/core/dist/classes/vector3.js
   var ORIGIN = [0, 0, 0];
   var ZERO;
   var Vector3 = class extends Vector {
@@ -3217,7 +3684,7 @@
     }
   };
 
-  // ../../node_modules/@math.gl/core/dist/esm/classes/base/matrix.js
+  // ../../node_modules/@math.gl/core/dist/classes/base/matrix.js
   var Matrix = class extends MathArray {
     toString() {
       let string = "[";
@@ -3263,7 +3730,7 @@
     }
   };
 
-  // ../../node_modules/gl-matrix/esm/mat4.js
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/mat4.js
   function identity(out) {
     out[0] = 1;
     out[1] = 0;
@@ -3285,9 +3752,12 @@
   }
   function transpose(out, a2) {
     if (out === a2) {
-      var a01 = a2[1], a02 = a2[2], a03 = a2[3];
-      var a12 = a2[6], a13 = a2[7];
-      var a23 = a2[11];
+      const a01 = a2[1];
+      const a02 = a2[2];
+      const a03 = a2[3];
+      const a12 = a2[6];
+      const a13 = a2[7];
+      const a23 = a2[11];
       out[1] = a2[4];
       out[2] = a2[8];
       out[3] = a2[12];
@@ -3321,23 +3791,35 @@
     return out;
   }
   function invert(out, a2) {
-    var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3];
-    var a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7];
-    var a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11];
-    var a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15];
-    var b00 = a00 * a11 - a01 * a10;
-    var b01 = a00 * a12 - a02 * a10;
-    var b02 = a00 * a13 - a03 * a10;
-    var b03 = a01 * a12 - a02 * a11;
-    var b04 = a01 * a13 - a03 * a11;
-    var b05 = a02 * a13 - a03 * a12;
-    var b06 = a20 * a31 - a21 * a30;
-    var b07 = a20 * a32 - a22 * a30;
-    var b08 = a20 * a33 - a23 * a30;
-    var b09 = a21 * a32 - a22 * a31;
-    var b10 = a21 * a33 - a23 * a31;
-    var b11 = a22 * a33 - a23 * a32;
-    var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    const a00 = a2[0];
+    const a01 = a2[1];
+    const a02 = a2[2];
+    const a03 = a2[3];
+    const a10 = a2[4];
+    const a11 = a2[5];
+    const a12 = a2[6];
+    const a13 = a2[7];
+    const a20 = a2[8];
+    const a21 = a2[9];
+    const a22 = a2[10];
+    const a23 = a2[11];
+    const a30 = a2[12];
+    const a31 = a2[13];
+    const a32 = a2[14];
+    const a33 = a2[15];
+    const b00 = a00 * a11 - a01 * a10;
+    const b01 = a00 * a12 - a02 * a10;
+    const b02 = a00 * a13 - a03 * a10;
+    const b03 = a01 * a12 - a02 * a11;
+    const b04 = a01 * a13 - a03 * a11;
+    const b05 = a02 * a13 - a03 * a12;
+    const b06 = a20 * a31 - a21 * a30;
+    const b07 = a20 * a32 - a22 * a30;
+    const b08 = a20 * a33 - a23 * a30;
+    const b09 = a21 * a32 - a22 * a31;
+    const b10 = a21 * a33 - a23 * a31;
+    const b11 = a22 * a33 - a23 * a32;
+    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
     if (!det) {
       return null;
     }
@@ -3361,30 +3843,55 @@
     return out;
   }
   function determinant(a2) {
-    var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3];
-    var a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7];
-    var a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11];
-    var a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15];
-    var b00 = a00 * a11 - a01 * a10;
-    var b01 = a00 * a12 - a02 * a10;
-    var b02 = a00 * a13 - a03 * a10;
-    var b03 = a01 * a12 - a02 * a11;
-    var b04 = a01 * a13 - a03 * a11;
-    var b05 = a02 * a13 - a03 * a12;
-    var b06 = a20 * a31 - a21 * a30;
-    var b07 = a20 * a32 - a22 * a30;
-    var b08 = a20 * a33 - a23 * a30;
-    var b09 = a21 * a32 - a22 * a31;
-    var b10 = a21 * a33 - a23 * a31;
-    var b11 = a22 * a33 - a23 * a32;
-    return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-  }
-  function multiply(out, a2, b) {
-    var a00 = a2[0], a01 = a2[1], a02 = a2[2], a03 = a2[3];
-    var a10 = a2[4], a11 = a2[5], a12 = a2[6], a13 = a2[7];
-    var a20 = a2[8], a21 = a2[9], a22 = a2[10], a23 = a2[11];
-    var a30 = a2[12], a31 = a2[13], a32 = a2[14], a33 = a2[15];
-    var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+    const a00 = a2[0];
+    const a01 = a2[1];
+    const a02 = a2[2];
+    const a03 = a2[3];
+    const a10 = a2[4];
+    const a11 = a2[5];
+    const a12 = a2[6];
+    const a13 = a2[7];
+    const a20 = a2[8];
+    const a21 = a2[9];
+    const a22 = a2[10];
+    const a23 = a2[11];
+    const a30 = a2[12];
+    const a31 = a2[13];
+    const a32 = a2[14];
+    const a33 = a2[15];
+    const b0 = a00 * a11 - a01 * a10;
+    const b1 = a00 * a12 - a02 * a10;
+    const b2 = a01 * a12 - a02 * a11;
+    const b3 = a20 * a31 - a21 * a30;
+    const b4 = a20 * a32 - a22 * a30;
+    const b5 = a21 * a32 - a22 * a31;
+    const b6 = a00 * b5 - a01 * b4 + a02 * b3;
+    const b7 = a10 * b5 - a11 * b4 + a12 * b3;
+    const b8 = a20 * b2 - a21 * b1 + a22 * b0;
+    const b9 = a30 * b2 - a31 * b1 + a32 * b0;
+    return a13 * b6 - a03 * b7 + a33 * b8 - a23 * b9;
+  }
+  function multiply2(out, a2, b) {
+    const a00 = a2[0];
+    const a01 = a2[1];
+    const a02 = a2[2];
+    const a03 = a2[3];
+    const a10 = a2[4];
+    const a11 = a2[5];
+    const a12 = a2[6];
+    const a13 = a2[7];
+    const a20 = a2[8];
+    const a21 = a2[9];
+    const a22 = a2[10];
+    const a23 = a2[11];
+    const a30 = a2[12];
+    const a31 = a2[13];
+    const a32 = a2[14];
+    const a33 = a2[15];
+    let b0 = b[0];
+    let b1 = b[1];
+    let b2 = b[2];
+    let b3 = b[3];
     out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
     out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
     out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
@@ -3416,10 +3923,21 @@
     return out;
   }
   function translate(out, a2, v) {
-    var x = v[0], y = v[1], z = v[2];
-    var a00, a01, a02, a03;
-    var a10, a11, a12, a13;
-    var a20, a21, a22, a23;
+    const x = v[0];
+    const y = v[1];
+    const z = v[2];
+    let a00;
+    let a01;
+    let a02;
+    let a03;
+    let a10;
+    let a11;
+    let a12;
+    let a13;
+    let a20;
+    let a21;
+    let a22;
+    let a23;
     if (a2 === out) {
       out[12] = a2[0] * x + a2[4] * y + a2[8] * z + a2[12];
       out[13] = a2[1] * x + a2[5] * y + a2[9] * z + a2[13];
@@ -3457,8 +3975,10 @@
     }
     return out;
   }
-  function scale(out, a2, v) {
-    var x = v[0], y = v[1], z = v[2];
+  function scale2(out, a2, v) {
+    const x = v[0];
+    const y = v[1];
+    const z = v[2];
     out[0] = a2[0] * x;
     out[1] = a2[1] * x;
     out[2] = a2[2] * x;
@@ -3478,22 +3998,41 @@
     return out;
   }
   function rotate(out, a2, rad, axis) {
-    var x = axis[0], y = axis[1], z = axis[2];
-    var len = Math.hypot(x, y, z);
-    var s2, c2, t2;
-    var a00, a01, a02, a03;
-    var a10, a11, a12, a13;
-    var a20, a21, a22, a23;
-    var b00, b01, b02;
-    var b10, b11, b12;
-    var b20, b21, b22;
-    if (len < EPSILON) {
+    let x = axis[0];
+    let y = axis[1];
+    let z = axis[2];
+    let len2 = Math.sqrt(x * x + y * y + z * z);
+    let c2;
+    let s2;
+    let t2;
+    let a00;
+    let a01;
+    let a02;
+    let a03;
+    let a10;
+    let a11;
+    let a12;
+    let a13;
+    let a20;
+    let a21;
+    let a22;
+    let a23;
+    let b00;
+    let b01;
+    let b02;
+    let b10;
+    let b11;
+    let b12;
+    let b20;
+    let b21;
+    let b22;
+    if (len2 < EPSILON) {
       return null;
     }
-    len = 1 / len;
-    x *= len;
-    y *= len;
-    z *= len;
+    len2 = 1 / len2;
+    x *= len2;
+    y *= len2;
+    z *= len2;
     s2 = Math.sin(rad);
     c2 = Math.cos(rad);
     t2 = 1 - c2;
@@ -3539,16 +4078,16 @@
     return out;
   }
   function rotateX2(out, a2, rad) {
-    var s2 = Math.sin(rad);
-    var c2 = Math.cos(rad);
-    var a10 = a2[4];
-    var a11 = a2[5];
-    var a12 = a2[6];
-    var a13 = a2[7];
-    var a20 = a2[8];
-    var a21 = a2[9];
-    var a22 = a2[10];
-    var a23 = a2[11];
+    const s2 = Math.sin(rad);
+    const c2 = Math.cos(rad);
+    const a10 = a2[4];
+    const a11 = a2[5];
+    const a12 = a2[6];
+    const a13 = a2[7];
+    const a20 = a2[8];
+    const a21 = a2[9];
+    const a22 = a2[10];
+    const a23 = a2[11];
     if (a2 !== out) {
       out[0] = a2[0];
       out[1] = a2[1];
@@ -3570,16 +4109,16 @@
     return out;
   }
   function rotateY2(out, a2, rad) {
-    var s2 = Math.sin(rad);
-    var c2 = Math.cos(rad);
-    var a00 = a2[0];
-    var a01 = a2[1];
-    var a02 = a2[2];
-    var a03 = a2[3];
-    var a20 = a2[8];
-    var a21 = a2[9];
-    var a22 = a2[10];
-    var a23 = a2[11];
+    const s2 = Math.sin(rad);
+    const c2 = Math.cos(rad);
+    const a00 = a2[0];
+    const a01 = a2[1];
+    const a02 = a2[2];
+    const a03 = a2[3];
+    const a20 = a2[8];
+    const a21 = a2[9];
+    const a22 = a2[10];
+    const a23 = a2[11];
     if (a2 !== out) {
       out[4] = a2[4];
       out[5] = a2[5];
@@ -3601,16 +4140,16 @@
     return out;
   }
   function rotateZ2(out, a2, rad) {
-    var s2 = Math.sin(rad);
-    var c2 = Math.cos(rad);
-    var a00 = a2[0];
-    var a01 = a2[1];
-    var a02 = a2[2];
-    var a03 = a2[3];
-    var a10 = a2[4];
-    var a11 = a2[5];
-    var a12 = a2[6];
-    var a13 = a2[7];
+    const s2 = Math.sin(rad);
+    const c2 = Math.cos(rad);
+    const a00 = a2[0];
+    const a01 = a2[1];
+    const a02 = a2[2];
+    const a03 = a2[3];
+    const a10 = a2[4];
+    const a11 = a2[5];
+    const a12 = a2[6];
+    const a13 = a2[7];
     if (a2 !== out) {
       out[8] = a2[8];
       out[9] = a2[9];
@@ -3632,19 +4171,22 @@
     return out;
   }
   function fromQuat(out, q) {
-    var x = q[0], y = q[1], z = q[2], w = q[3];
-    var x2 = x + x;
-    var y2 = y + y;
-    var z2 = z + z;
-    var xx = x * x2;
-    var yx = y * x2;
-    var yy = y * y2;
-    var zx = z * x2;
-    var zy = z * y2;
-    var zz = z * z2;
-    var wx = w * x2;
-    var wy = w * y2;
-    var wz = w * z2;
+    const x = q[0];
+    const y = q[1];
+    const z = q[2];
+    const w = q[3];
+    const x2 = x + x;
+    const y2 = y + y;
+    const z2 = z + z;
+    const xx = x * x2;
+    const yx = y * x2;
+    const yy = y * y2;
+    const zx = z * x2;
+    const zy = z * y2;
+    const zz = z * z2;
+    const wx = w * x2;
+    const wy = w * y2;
+    const wz = w * z2;
     out[0] = 1 - yy - zz;
     out[1] = yx + wz;
     out[2] = zx - wy;
@@ -3664,9 +4206,9 @@
     return out;
   }
   function frustum(out, left, right, bottom, top, near, far) {
-    var rl = 1 / (right - left);
-    var tb = 1 / (top - bottom);
-    var nf = 1 / (near - far);
+    const rl = 1 / (right - left);
+    const tb = 1 / (top - bottom);
+    const nf = 1 / (near - far);
     out[0] = near * 2 * rl;
     out[1] = 0;
     out[2] = 0;
@@ -3686,7 +4228,7 @@
     return out;
   }
   function perspectiveNO(out, fovy, aspect, near, far) {
-    var f2 = 1 / Math.tan(fovy / 2), nf;
+    const f2 = 1 / Math.tan(fovy / 2);
     out[0] = f2 / aspect;
     out[1] = 0;
     out[2] = 0;
@@ -3702,7 +4244,7 @@
     out[13] = 0;
     out[15] = 0;
     if (far != null && far !== Infinity) {
-      nf = 1 / (near - far);
+      const nf = 1 / (near - far);
       out[10] = (far + near) * nf;
       out[14] = 2 * far * near * nf;
     } else {
@@ -3713,9 +4255,9 @@
   }
   var perspective = perspectiveNO;
   function orthoNO(out, left, right, bottom, top, near, far) {
-    var lr = 1 / (left - right);
-    var bt = 1 / (bottom - top);
-    var nf = 1 / (near - far);
+    const lr = 1 / (left - right);
+    const bt = 1 / (bottom - top);
+    const nf = 1 / (near - far);
     out[0] = -2 * lr;
     out[1] = 0;
     out[2] = 0;
@@ -3736,53 +4278,62 @@
   }
   var ortho = orthoNO;
   function lookAt(out, eye, center, up) {
-    var x0, x1, x2, y0, y1, y2, z0, z1, z2, len;
-    var eyex = eye[0];
-    var eyey = eye[1];
-    var eyez = eye[2];
-    var upx = up[0];
-    var upy = up[1];
-    var upz = up[2];
-    var centerx = center[0];
-    var centery = center[1];
-    var centerz = center[2];
+    let len2;
+    let x0;
+    let x1;
+    let x2;
+    let y0;
+    let y1;
+    let y2;
+    let z0;
+    let z1;
+    let z2;
+    const eyex = eye[0];
+    const eyey = eye[1];
+    const eyez = eye[2];
+    const upx = up[0];
+    const upy = up[1];
+    const upz = up[2];
+    const centerx = center[0];
+    const centery = center[1];
+    const centerz = center[2];
     if (Math.abs(eyex - centerx) < EPSILON && Math.abs(eyey - centery) < EPSILON && Math.abs(eyez - centerz) < EPSILON) {
       return identity(out);
     }
     z0 = eyex - centerx;
     z1 = eyey - centery;
     z2 = eyez - centerz;
-    len = 1 / Math.hypot(z0, z1, z2);
-    z0 *= len;
-    z1 *= len;
-    z2 *= len;
+    len2 = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
+    z0 *= len2;
+    z1 *= len2;
+    z2 *= len2;
     x0 = upy * z2 - upz * z1;
     x1 = upz * z0 - upx * z2;
     x2 = upx * z1 - upy * z0;
-    len = Math.hypot(x0, x1, x2);
-    if (!len) {
+    len2 = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
+    if (!len2) {
       x0 = 0;
       x1 = 0;
       x2 = 0;
     } else {
-      len = 1 / len;
-      x0 *= len;
-      x1 *= len;
-      x2 *= len;
+      len2 = 1 / len2;
+      x0 *= len2;
+      x1 *= len2;
+      x2 *= len2;
     }
     y0 = z1 * x2 - z2 * x1;
     y1 = z2 * x0 - z0 * x2;
     y2 = z0 * x1 - z1 * x0;
-    len = Math.hypot(y0, y1, y2);
-    if (!len) {
+    len2 = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+    if (!len2) {
       y0 = 0;
       y1 = 0;
       y2 = 0;
     } else {
-      len = 1 / len;
-      y0 *= len;
-      y1 *= len;
-      y2 *= len;
+      len2 = 1 / len2;
+      y0 *= len2;
+      y1 *= len2;
+      y2 *= len2;
     }
     out[0] = x0;
     out[1] = y0;
@@ -3803,9 +4354,9 @@
     return out;
   }
 
-  // ../../node_modules/gl-matrix/esm/vec4.js
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec4.js
   function create3() {
-    var out = new ARRAY_TYPE(4);
+    const out = new ARRAY_TYPE(4);
     if (ARRAY_TYPE != Float32Array) {
       out[0] = 0;
       out[1] = 0;
@@ -3815,7 +4366,10 @@
     return out;
   }
   function transformMat43(out, a2, m) {
-    var x = a2[0], y = a2[1], z = a2[2], w = a2[3];
+    const x = a2[0];
+    const y = a2[1];
+    const z = a2[2];
+    const w = a2[3];
     out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;
     out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;
     out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;
@@ -3823,9 +4377,10 @@
     return out;
   }
   var forEach4 = function() {
-    var vec = create3();
+    const vec = create3();
     return function(a2, stride, offset, count, fn, arg) {
-      var i2, l2;
+      let i2;
+      let l2;
       if (!stride) {
         stride = 4;
       }
@@ -3852,7 +4407,7 @@
     };
   }();
 
-  // ../../node_modules/@math.gl/core/dist/esm/classes/matrix4.js
+  // ../../node_modules/@math.gl/core/dist/classes/matrix4.js
   var INDICES;
   (function(INDICES2) {
     INDICES2[INDICES2["COL0ROW0"] = 0] = "COL0ROW0";
@@ -4074,10 +4629,10 @@
     getRotation(result, scaleResult) {
       result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
       scaleResult = scaleResult || [-0, -0, -0];
-      const scale2 = this.getScale(scaleResult);
-      const inverseScale0 = 1 / scale2[0];
-      const inverseScale1 = 1 / scale2[1];
-      const inverseScale2 = 1 / scale2[2];
+      const scale3 = this.getScale(scaleResult);
+      const inverseScale0 = 1 / scale3[0];
+      const inverseScale1 = 1 / scale3[1];
+      const inverseScale2 = 1 / scale3[2];
       result[0] = this[0] * inverseScale0;
       result[1] = this[1] * inverseScale1;
       result[2] = this[2] * inverseScale2;
@@ -4099,10 +4654,10 @@
     getRotationMatrix3(result, scaleResult) {
       result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
       scaleResult = scaleResult || [-0, -0, -0];
-      const scale2 = this.getScale(scaleResult);
-      const inverseScale0 = 1 / scale2[0];
-      const inverseScale1 = 1 / scale2[1];
-      const inverseScale2 = 1 / scale2[2];
+      const scale3 = this.getScale(scaleResult);
+      const inverseScale0 = 1 / scale3[0];
+      const inverseScale1 = 1 / scale3[1];
+      const inverseScale2 = 1 / scale3[2];
       result[0] = this[0] * inverseScale0;
       result[1] = this[1] * inverseScale1;
       result[2] = this[2] * inverseScale2;
@@ -4123,11 +4678,11 @@
       return this.check();
     }
     multiplyLeft(a2) {
-      multiply(this, a2, this);
+      multiply2(this, a2, this);
       return this.check();
     }
     multiplyRight(a2) {
-      multiply(this, this, a2);
+      multiply2(this, this, a2);
       return this.check();
     }
     rotateX(radians2) {
@@ -4150,7 +4705,7 @@
       return this.check();
     }
     scale(factor) {
-      scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
+      scale2(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
       return this.check();
     }
     translate(vector) {
@@ -4262,35 +4817,60 @@
     return result;
   }
 
-  // ../../node_modules/@math.gl/core/dist/esm/lib/math-utils.js
-  var math_utils_default = {
-    EPSILON1: 0.1,
-    EPSILON2: 0.01,
-    EPSILON3: 1e-3,
-    EPSILON4: 1e-4,
-    EPSILON5: 1e-5,
-    EPSILON6: 1e-6,
-    EPSILON7: 1e-7,
-    EPSILON8: 1e-8,
-    EPSILON9: 1e-9,
-    EPSILON10: 1e-10,
-    EPSILON11: 1e-11,
-    EPSILON12: 1e-12,
-    EPSILON13: 1e-13,
-    EPSILON14: 1e-14,
-    EPSILON15: 1e-15,
-    EPSILON16: 1e-16,
-    EPSILON17: 1e-17,
-    EPSILON18: 1e-18,
-    EPSILON19: 1e-19,
-    EPSILON20: 1e-20,
-    PI_OVER_TWO: Math.PI / 2,
-    PI_OVER_FOUR: Math.PI / 4,
-    PI_OVER_SIX: Math.PI / 6,
-    TWO_PI: Math.PI * 2
-  };
-
-  // ../../node_modules/@math.gl/geospatial/dist/esm/constants.js
+  // ../../node_modules/@math.gl/core/dist/lib/math-utils.js
+  var math_utils_exports = {};
+  __export(math_utils_exports, {
+    EPSILON1: () => EPSILON1,
+    EPSILON10: () => EPSILON10,
+    EPSILON11: () => EPSILON11,
+    EPSILON12: () => EPSILON12,
+    EPSILON13: () => EPSILON13,
+    EPSILON14: () => EPSILON14,
+    EPSILON15: () => EPSILON15,
+    EPSILON16: () => EPSILON16,
+    EPSILON17: () => EPSILON17,
+    EPSILON18: () => EPSILON18,
+    EPSILON19: () => EPSILON19,
+    EPSILON2: () => EPSILON2,
+    EPSILON20: () => EPSILON20,
+    EPSILON3: () => EPSILON3,
+    EPSILON4: () => EPSILON4,
+    EPSILON5: () => EPSILON5,
+    EPSILON6: () => EPSILON6,
+    EPSILON7: () => EPSILON7,
+    EPSILON8: () => EPSILON8,
+    EPSILON9: () => EPSILON9,
+    PI_OVER_FOUR: () => PI_OVER_FOUR,
+    PI_OVER_SIX: () => PI_OVER_SIX,
+    PI_OVER_TWO: () => PI_OVER_TWO,
+    TWO_PI: () => TWO_PI
+  });
+  var EPSILON1 = 0.1;
+  var EPSILON2 = 0.01;
+  var EPSILON3 = 1e-3;
+  var EPSILON4 = 1e-4;
+  var EPSILON5 = 1e-5;
+  var EPSILON6 = 1e-6;
+  var EPSILON7 = 1e-7;
+  var EPSILON8 = 1e-8;
+  var EPSILON9 = 1e-9;
+  var EPSILON10 = 1e-10;
+  var EPSILON11 = 1e-11;
+  var EPSILON12 = 1e-12;
+  var EPSILON13 = 1e-13;
+  var EPSILON14 = 1e-14;
+  var EPSILON15 = 1e-15;
+  var EPSILON16 = 1e-16;
+  var EPSILON17 = 1e-17;
+  var EPSILON18 = 1e-18;
+  var EPSILON19 = 1e-19;
+  var EPSILON20 = 1e-20;
+  var PI_OVER_TWO = Math.PI / 2;
+  var PI_OVER_FOUR = Math.PI / 4;
+  var PI_OVER_SIX = Math.PI / 6;
+  var TWO_PI = Math.PI * 2;
+
+  // ../../node_modules/@math.gl/geospatial/dist/constants.js
   var WGS84_RADIUS_X = 6378137;
   var WGS84_RADIUS_Y = 6378137;
   var WGS84_RADIUS_Z = 6356752314245179e-9;
@@ -4303,7 +4883,7 @@
     centerToleranceSquared: 0.1
   };
 
-  // ../../node_modules/@math.gl/geospatial/dist/esm/type-utils.js
+  // ../../node_modules/@math.gl/geospatial/dist/type-utils.js
   function identity2(x) {
     return x;
   }
@@ -4347,68 +4927,8 @@
     return toCartographic(vector, cartographic, config._cartographicRadians ? identity2 : toDegrees);
   }
 
-  // ../../node_modules/@math.gl/geospatial/dist/esm/ellipsoid/helpers/scale-to-geodetic-surface.js
-  var scratchVector2 = new Vector3();
-  var scaleToGeodeticSurfaceIntersection = new Vector3();
-  var scaleToGeodeticSurfaceGradient = new Vector3();
-  function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
-    const {
-      oneOverRadii,
-      oneOverRadiiSquared,
-      centerToleranceSquared
-    } = ellipsoid;
-    scratchVector2.from(cartesian);
-    const positionX = scratchVector2.x;
-    const positionY = scratchVector2.y;
-    const positionZ = scratchVector2.z;
-    const oneOverRadiiX = oneOverRadii.x;
-    const oneOverRadiiY = oneOverRadii.y;
-    const oneOverRadiiZ = oneOverRadii.z;
-    const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;
-    const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;
-    const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
-    const squaredNorm = x2 + y2 + z2;
-    const ratio = Math.sqrt(1 / squaredNorm);
-    if (!Number.isFinite(ratio)) {
-      return void 0;
-    }
-    const intersection = scaleToGeodeticSurfaceIntersection;
-    intersection.copy(cartesian).scale(ratio);
-    if (squaredNorm < centerToleranceSquared) {
-      return intersection.to(result);
-    }
-    const oneOverRadiiSquaredX = oneOverRadiiSquared.x;
-    const oneOverRadiiSquaredY = oneOverRadiiSquared.y;
-    const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
-    const gradient = scaleToGeodeticSurfaceGradient;
-    gradient.set(intersection.x * oneOverRadiiSquaredX * 2, intersection.y * oneOverRadiiSquaredY * 2, intersection.z * oneOverRadiiSquaredZ * 2);
-    let lambda = (1 - ratio) * scratchVector2.len() / (0.5 * gradient.len());
-    let correction = 0;
-    let xMultiplier;
-    let yMultiplier;
-    let zMultiplier;
-    let func;
-    do {
-      lambda -= correction;
-      xMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredX);
-      yMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredY);
-      zMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredZ);
-      const xMultiplier2 = xMultiplier * xMultiplier;
-      const yMultiplier2 = yMultiplier * yMultiplier;
-      const zMultiplier2 = zMultiplier * zMultiplier;
-      const xMultiplier3 = xMultiplier2 * xMultiplier;
-      const yMultiplier3 = yMultiplier2 * yMultiplier;
-      const zMultiplier3 = zMultiplier2 * zMultiplier;
-      func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1;
-      const denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;
-      const derivative = -2 * denominator;
-      correction = func / derivative;
-    } while (Math.abs(func) > math_utils_default.EPSILON12);
-    return scratchVector2.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);
-  }
-
-  // ../../node_modules/@math.gl/geospatial/dist/esm/ellipsoid/helpers/ellipsoid-transform.js
-  var EPSILON14 = 1e-14;
+  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid/helpers/ellipsoid-transform.js
+  var EPSILON142 = 1e-14;
   var scratchOrigin = new Vector3();
   var VECTOR_PRODUCT_LOCAL_FRAME = {
     up: {
@@ -4465,7 +4985,7 @@
     down: new Vector3()
   };
   var scratchVector1 = new Vector3();
-  var scratchVector22 = new Vector3();
+  var scratchVector2 = new Vector3();
   var scratchVector3 = new Vector3();
   function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {
     const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
@@ -4474,14 +4994,14 @@
     let secondAxisVector;
     let thirdAxisVector;
     const origin = scratchOrigin.copy(cartesianOrigin);
-    const atPole = equals(origin.x, 0, EPSILON14) && equals(origin.y, 0, EPSILON14);
+    const atPole = equals(origin.x, 0, EPSILON142) && equals(origin.y, 0, EPSILON142);
     if (atPole) {
       const sign = Math.sign(origin.z);
       firstAxisVector = scratchVector1.fromArray(degeneratePositionLocalFrame[firstAxis]);
       if (firstAxis !== "east" && firstAxis !== "west") {
         firstAxisVector.scale(sign);
       }
-      secondAxisVector = scratchVector22.fromArray(degeneratePositionLocalFrame[secondAxis]);
+      secondAxisVector = scratchVector2.fromArray(degeneratePositionLocalFrame[secondAxis]);
       if (secondAxis !== "east" && secondAxis !== "west") {
         secondAxisVector.scale(sign);
       }
@@ -4529,8 +5049,68 @@
     return result;
   }
 
-  // ../../node_modules/@math.gl/geospatial/dist/esm/ellipsoid/ellipsoid.js
+  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid/helpers/scale-to-geodetic-surface.js
   var scratchVector4 = new Vector3();
+  var scaleToGeodeticSurfaceIntersection = new Vector3();
+  var scaleToGeodeticSurfaceGradient = new Vector3();
+  function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
+    const {
+      oneOverRadii,
+      oneOverRadiiSquared,
+      centerToleranceSquared
+    } = ellipsoid;
+    scratchVector4.from(cartesian);
+    const positionX = scratchVector4.x;
+    const positionY = scratchVector4.y;
+    const positionZ = scratchVector4.z;
+    const oneOverRadiiX = oneOverRadii.x;
+    const oneOverRadiiY = oneOverRadii.y;
+    const oneOverRadiiZ = oneOverRadii.z;
+    const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;
+    const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;
+    const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
+    const squaredNorm = x2 + y2 + z2;
+    const ratio = Math.sqrt(1 / squaredNorm);
+    if (!Number.isFinite(ratio)) {
+      return void 0;
+    }
+    const intersection = scaleToGeodeticSurfaceIntersection;
+    intersection.copy(cartesian).scale(ratio);
+    if (squaredNorm < centerToleranceSquared) {
+      return intersection.to(result);
+    }
+    const oneOverRadiiSquaredX = oneOverRadiiSquared.x;
+    const oneOverRadiiSquaredY = oneOverRadiiSquared.y;
+    const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
+    const gradient = scaleToGeodeticSurfaceGradient;
+    gradient.set(intersection.x * oneOverRadiiSquaredX * 2, intersection.y * oneOverRadiiSquaredY * 2, intersection.z * oneOverRadiiSquaredZ * 2);
+    let lambda = (1 - ratio) * scratchVector4.len() / (0.5 * gradient.len());
+    let correction = 0;
+    let xMultiplier;
+    let yMultiplier;
+    let zMultiplier;
+    let func;
+    do {
+      lambda -= correction;
+      xMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredX);
+      yMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredY);
+      zMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredZ);
+      const xMultiplier2 = xMultiplier * xMultiplier;
+      const yMultiplier2 = yMultiplier * yMultiplier;
+      const zMultiplier2 = zMultiplier * zMultiplier;
+      const xMultiplier3 = xMultiplier2 * xMultiplier;
+      const yMultiplier3 = yMultiplier2 * yMultiplier;
+      const zMultiplier3 = zMultiplier2 * zMultiplier;
+      func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1;
+      const denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;
+      const derivative = -2 * denominator;
+      correction = func / derivative;
+    } while (Math.abs(func) > math_utils_exports.EPSILON12);
+    return scratchVector4.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);
+  }
+
+  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid/ellipsoid.js
+  var scratchVector5 = new Vector3();
   var scratchNormal = new Vector3();
   var scratchK = new Vector3();
   var scratchPosition = new Vector3();
@@ -4545,7 +5125,7 @@
       _defineProperty(this, "oneOverRadiiSquared", void 0);
       _defineProperty(this, "minimumRadius", void 0);
       _defineProperty(this, "maximumRadius", void 0);
-      _defineProperty(this, "centerToleranceSquared", math_utils_default.EPSILON1);
+      _defineProperty(this, "centerToleranceSquared", math_utils_exports.EPSILON1);
       _defineProperty(this, "squaredXOverSquaredZ", void 0);
       assert4(x >= 0);
       assert4(y >= 0);
@@ -4591,7 +5171,7 @@
       h.copy(scratchCartesian).subtract(point);
       const longitude = Math.atan2(normal.y, normal.x);
       const latitude = Math.asin(normal.z);
-      const height = Math.sign(dot(h, scratchCartesian)) * length(h);
+      const height = Math.sign(vec3_exports.dot(h, scratchCartesian)) * vec3_exports.length(h);
       return toCartographicFromRadians([longitude, latitude, height], result);
     }
     eastNorthUpToFixedFrame(origin, result = new Matrix4()) {
@@ -4601,18 +5181,18 @@
       return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);
     }
     geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {
-      return scratchVector4.from(cartesian).normalize().to(result);
+      return scratchVector5.from(cartesian).normalize().to(result);
     }
     geodeticSurfaceNormalCartographic(cartographic, result = [0, 0, 0]) {
       const cartographicVectorRadians = fromCartographicToRadians(cartographic);
       const longitude = cartographicVectorRadians[0];
       const latitude = cartographicVectorRadians[1];
       const cosLatitude = Math.cos(latitude);
-      scratchVector4.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude)).normalize();
-      return scratchVector4.to(result);
+      scratchVector5.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude)).normalize();
+      return scratchVector5.to(result);
     }
     geodeticSurfaceNormal(cartesian, result = [0, 0, 0]) {
-      return scratchVector4.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);
+      return scratchVector5.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);
     }
     scaleToGeodeticSurface(cartesian, result) {
       return scaleToGeodeticSurface(cartesian, this, result);
@@ -4633,7 +5213,7 @@
       return scratchPosition.from(position).scale(this.radii).to(result);
     }
     getSurfaceNormalIntersectionWithZAxis(position, buffer = 0, result = [0, 0, 0]) {
-      assert4(equals(this.radii.x, this.radii.y, math_utils_default.EPSILON15));
+      assert4(equals(this.radii.x, this.radii.y, math_utils_exports.EPSILON15));
       assert4(this.radii.z > 0);
       scratchPosition.from(position);
       const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);
@@ -4646,13 +5226,13 @@
   _defineProperty(Ellipsoid, "WGS84", new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z));
 
   // ../images/src/lib/utils/version.ts
-  var VERSION3 = true ? "4.0.0-beta.2" : "latest";
+  var VERSION3 = true ? "4.0.0-beta.4" : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
-  var { _parseImageNode } = globalThis;
+  var parseImageNode = globalThis.loaders?.parseImageNode;
   var IMAGE_SUPPORTED = typeof Image !== "undefined";
   var IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
-  var NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
+  var NODE_IMAGE_SUPPORTED = Boolean(parseImageNode);
   var DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;
   function isImageTypeSupported(type) {
     switch (type) {
@@ -4866,6 +5446,7 @@
     }
     return {
       mimeType: mediaType.mimeType,
+      // TODO - decode width and height
       width: 0,
       height: 0
     };
@@ -4920,7 +5501,9 @@
         return {
           mimeType: "image/jpeg",
           height: dataView.getUint16(i2 + 5, BIG_ENDIAN),
+          // Number of lines
           width: dataView.getUint16(i2 + 7, BIG_ENDIAN)
+          // Number of pixels per line
         };
       }
       if (!tableMarkers.has(marker)) {
@@ -4932,11 +5515,11 @@
     return null;
   }
   function getJpegMarkers() {
-    const tableMarkers = new Set([65499, 65476, 65484, 65501, 65534]);
+    const tableMarkers = /* @__PURE__ */ new Set([65499, 65476, 65484, 65501, 65534]);
     for (let i2 = 65504; i2 < 65520; ++i2) {
       tableMarkers.add(i2);
     }
-    const sofMarkers = new Set([
+    const sofMarkers = /* @__PURE__ */ new Set([
       65472,
       65473,
       65474,
@@ -4970,9 +5553,9 @@
   // ../images/src/lib/parsers/parse-to-node-image.ts
   async function parseToNodeImage(arrayBuffer, options) {
     const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
-    const _parseImageNode2 = globalThis._parseImageNode;
-    assert(_parseImageNode2);
-    return await _parseImageNode2(arrayBuffer, mimeType);
+    const parseImageNode2 = globalThis.loaders?.parseImageNode;
+    assert(parseImageNode2);
+    return await parseImageNode2(arrayBuffer, mimeType);
   }
 
   // ../images/src/lib/parsers/parse-image.ts
@@ -5028,7 +5611,9 @@
     image: {
       type: "auto",
       decode: true
+      // if format is HTML
     }
+    // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor
   };
   var ImageLoader = {
     id: "image",
@@ -5038,17 +5623,19 @@
     mimeTypes: MIME_TYPES,
     extensions: EXTENSIONS,
     parse: parseImage,
+    // TODO: byteOffset, byteLength;
     tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
     options: DEFAULT_IMAGE_LOADER_OPTIONS
   };
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION4 = true ? "4.0.0-beta.2" : "latest";
+  var VERSION4 = true ? "4.0.0-beta.4" : "latest";
 
   // ../draco/src/draco-loader.ts
   var DEFAULT_DRACO_OPTIONS = {
     draco: {
       decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
+      // 'js' for IE11
       libraryPath: "libs/",
       extraAttributes: {},
       attributeNameEntry: void 0
@@ -5058,6 +5645,7 @@
     name: "Draco",
     id: "draco",
     module: "draco",
+    // shapes: ['mesh'],
     version: VERSION4,
     worker: true,
     extensions: ["drc"],
@@ -5101,8 +5689,8 @@
     let maxY = -Infinity;
     let maxZ = -Infinity;
     const positions = attributes.POSITION ? attributes.POSITION.value : [];
-    const len = positions && positions.length;
-    for (let i2 = 0; i2 < len; i2 += 3) {
+    const len2 = positions && positions.length;
+    for (let i2 = 0; i2 < len2; i2 += 3) {
       const x = positions[i2];
       const y = positions[i2 + 1];
       const z = positions[i2 + 2];
@@ -5151,7 +5739,11 @@
     const namedLoaderDataAttributes = transformAttributesLoaderData(loaderData.attributes);
     for (const attributeName in attributes) {
       const attribute = attributes[attributeName];
-      const field = getArrowFieldFromAttribute(attributeName, attribute, namedLoaderDataAttributes[attributeName]);
+      const field = getArrowFieldFromAttribute(
+        attributeName,
+        attribute,
+        namedLoaderDataAttributes[attributeName]
+      );
       fields.push(field);
     }
     if (indices) {
@@ -5200,15 +5792,27 @@
   };
   var INDEX_ITEM_SIZE = 4;
   var DracoParser = class {
+    draco;
+    decoder;
+    metadataQuerier;
+    // draco - the draco decoder, either import `draco3d` or load dynamically
     constructor(draco) {
       this.draco = draco;
       this.decoder = new this.draco.Decoder();
       this.metadataQuerier = new this.draco.MetadataQuerier();
     }
+    /**
+     * Destroy draco resources
+     */
     destroy() {
       this.draco.destroy(this.decoder);
       this.draco.destroy(this.metadataQuerier);
     }
+    /**
+     * NOTE: caller must call `destroyGeometry` on the return value after using it
+     * @param arrayBuffer
+     * @param options
+     */
     parseSync(arrayBuffer, options = {}) {
       const buffer = new this.draco.DecoderBuffer();
       buffer.Init(new Int8Array(arrayBuffer), arrayBuffer.byteLength);
@@ -5253,6 +5857,14 @@
         }
       }
     }
+    // Draco specific "loader data"
+    /**
+     * Extract
+     * @param dracoGeometry
+     * @param geometry_type
+     * @param options
+     * @returns
+     */
     _getDracoLoaderData(dracoGeometry, geometry_type, options) {
       const metadata = this._getTopLevelMetadata(dracoGeometry);
       const attributes = this._getDracoAttributes(dracoGeometry, options);
@@ -5265,6 +5877,12 @@
         attributes
       };
     }
+    /**
+     * Extract all draco provided information and metadata for each attribute
+     * @param dracoGeometry
+     * @param options
+     * @returns
+     */
     _getDracoAttributes(dracoGeometry, options) {
       const dracoAttributes = {};
       for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {
@@ -5292,6 +5910,12 @@
       }
       return dracoAttributes;
     }
+    /**
+     * Get standard loaders.gl mesh category data
+     * Extracts the geometry from draco
+     * @param dracoGeometry
+     * @param options
+     */
     _getMeshData(dracoGeometry, loaderData, options) {
       const attributes = this._getMeshAttributes(loaderData, dracoGeometry, options);
       const positionAttribute = attributes.POSITION;
@@ -5304,6 +5928,7 @@
             return {
               topology: "triangle-strip",
               mode: 4,
+              // GL.TRIANGLES
               attributes,
               indices: {
                 value: this._getTriangleStripIndices(dracoGeometry),
@@ -5315,6 +5940,7 @@
             return {
               topology: "triangle-list",
               mode: 5,
+              // GL.TRIANGLE_STRIP
               attributes,
               indices: {
                 value: this._getTriangleListIndices(dracoGeometry),
@@ -5326,6 +5952,7 @@
       return {
         topology: "point-list",
         mode: 0,
+        // GL.POINTS
         attributes
       };
     }
@@ -5345,6 +5972,11 @@
       }
       return attributes;
     }
+    // MESH INDICES EXTRACTION
+    /**
+     * For meshes, we need indices to define the faces.
+     * @param dracoGeometry
+     */
     _getTriangleListIndices(dracoGeometry) {
       const numFaces = dracoGeometry.num_faces();
       const numIndices = numFaces * 3;
@@ -5357,6 +5989,10 @@
         this.draco._free(ptr);
       }
     }
+    /**
+     * For meshes, we need indices to define the faces.
+     * @param dracoGeometry
+     */
     _getTriangleStripIndices(dracoGeometry) {
       const dracoArray = new this.draco.DracoInt32Array();
       try {
@@ -5366,6 +6002,12 @@
         this.draco.destroy(dracoArray);
       }
     }
+    /**
+     *
+     * @param dracoGeometry
+     * @param dracoAttribute
+     * @param attributeName
+     */
     _getAttributeValues(dracoGeometry, attribute) {
       const TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];
       const numComponents = attribute.num_components;
@@ -5377,16 +6019,48 @@
       const ptr = this.draco._malloc(byteLength);
       try {
         const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attribute.attribute_index);
-        this.decoder.GetAttributeDataArrayForAllPoints(dracoGeometry, dracoAttribute, dataType, byteLength, ptr);
+        this.decoder.GetAttributeDataArrayForAllPoints(
+          dracoGeometry,
+          dracoAttribute,
+          dataType,
+          byteLength,
+          ptr
+        );
         value = new TypedArrayCtor(this.draco.HEAPF32.buffer, ptr, numValues).slice();
       } finally {
         this.draco._free(ptr);
       }
       return { value, size: numComponents };
     }
+    // Attribute names
+    /** 
+     * DRACO does not store attribute names - We need to deduce an attribute name
+     * for each attribute
+    _getAttributeNames(
+      dracoGeometry: Mesh | PointCloud,
+      options: DracoParseOptions
+    ): {[unique_id: number]: string} {
+      const attributeNames: {[unique_id: number]: string} = {};
+      for (let attributeId = 0; attributeId < dracoGeometry.num_attributes(); attributeId++) {
+        const dracoAttribute = this.decoder.GetAttribute(dracoGeometry, attributeId);
+        const attributeName = this._deduceAttributeName(dracoAttribute, options);
+        attributeNames[attributeName] = attributeName;
+      }
+      return attributeNames;
+    }
+     */
+    /**
+     * Deduce an attribute name.
+     * @note DRACO does not save attribute names, just general type (POSITION, COLOR)
+     * to help optimize compression. We generate GLTF compatible names for the Draco-recognized
+     * types
+     * @param attributeData
+     */
     _deduceAttributeName(attribute, options) {
       const uniqueId = attribute.unique_id;
-      for (const [attributeName, attributeUniqueId] of Object.entries(options.extraAttributes || {})) {
+      for (const [attributeName, attributeUniqueId] of Object.entries(
+        options.extraAttributes || {}
+      )) {
         if (attributeUniqueId === uniqueId) {
           return attributeName;
         }
@@ -5404,14 +6078,22 @@
       }
       return `CUSTOM_ATTRIBUTE_${uniqueId}`;
     }
+    // METADATA EXTRACTION
+    /** Get top level metadata */
     _getTopLevelMetadata(dracoGeometry) {
       const dracoMetadata = this.decoder.GetMetadata(dracoGeometry);
       return this._getDracoMetadata(dracoMetadata);
     }
+    /** Get per attribute metadata */
     _getAttributeMetadata(dracoGeometry, attributeId) {
       const dracoMetadata = this.decoder.GetAttributeMetadata(dracoGeometry, attributeId);
       return this._getDracoMetadata(dracoMetadata);
     }
+    /**
+     * Extract metadata field values
+     * @param dracoMetadata
+     * @returns
+     */
     _getDracoMetadata(dracoMetadata) {
       if (!dracoMetadata || !dracoMetadata.ptr) {
         return {};
@@ -5424,6 +6106,11 @@
       }
       return result;
     }
+    /**
+     * Extracts possible values for one metadata entry by name
+     * @param dracoMetadata
+     * @param entryName
+     */
     _getDracoMetadataField(dracoMetadata, entryName) {
       const dracoArray = new this.draco.DracoInt32Array();
       try {
@@ -5439,6 +6126,8 @@
         this.draco.destroy(dracoArray);
       }
     }
+    // QUANTIZED ATTRIBUTE SUPPORT (NO DECOMPRESSION)
+    /** Skip transforms for specific attribute types */
     _disableAttributeTransforms(options) {
       const { quantizedAttributes = [], octahedronAttributes = [] } = options;
       const skipAttributes = [...quantizedAttributes, ...octahedronAttributes];
@@ -5446,6 +6135,10 @@
         this.decoder.SkipAttributeTransform(this.draco[dracoAttributeName]);
       }
     }
+    /**
+     * Extract (and apply?) Position Transform
+     * @todo not used
+     */
     _getQuantizationTransform(dracoAttribute, options) {
       const { quantizedAttributes = [] } = options;
       const attribute_type = dracoAttribute.attribute_type();
@@ -5484,6 +6177,7 @@
       }
       return null;
     }
+    // HELPERS
   };
   function getDracoDataType(draco, attributeType) {
     switch (attributeType) {
@@ -5527,9 +6221,13 @@
   var DRACO_ENCODER_VERSION = "1.4.1";
   var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
   var DRACO_EXTERNAL_LIBRARIES = {
+    /** The primary Draco3D encoder, javascript wrapper part */
     DECODER: "draco_wasm_wrapper.js",
+    /** The primary draco decoder, compiled web assembly part */
     DECODER_WASM: "draco_decoder.wasm",
+    /** Fallback decoder for non-webassebly environments. Very big bundle, lower performance */
     FALLBACK_DECODER: "draco_decoder.js",
+    /** Draco encoder */
     ENCODER: "draco_encoder.js"
   };
   var DRACO_EXTERNAL_LIBRARY_URLS = {
@@ -5555,13 +6253,28 @@
     let wasmBinary;
     switch (options.draco && options.draco.decoderType) {
       case "js":
-        DracoDecoderModule = await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER], "draco", options, DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER);
+        DracoDecoderModule = await loadLibrary(
+          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER],
+          "draco",
+          options,
+          DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER
+        );
         break;
       case "wasm":
       default:
         [DracoDecoderModule, wasmBinary] = await Promise.all([
-          await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER], "draco", options, DRACO_EXTERNAL_LIBRARIES.DECODER),
-          await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM], "draco", options, DRACO_EXTERNAL_LIBRARIES.DECODER_WASM)
+          await loadLibrary(
+            DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
+            "draco",
+            options,
+            DRACO_EXTERNAL_LIBRARIES.DECODER
+          ),
+          await loadLibrary(
+            DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
+            "draco",
+            options,
+            DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
+          )
         ]);
     }
     DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
@@ -5576,6 +6289,7 @@
       DracoDecoderModule({
         ...options,
         onModuleLoaded: (draco) => resolve2({ draco })
+        // Module is Promise-like. Wrap in object to avoid loop.
       });
     });
   }
@@ -5596,13 +6310,17 @@
   }
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION5 = true ? "4.0.0-beta.2" : "beta";
+  var VERSION5 = true ? "4.0.0-beta.4" : "beta";
 
   // ../textures/src/lib/parsers/basis-module-loader.ts
   var BASIS_EXTERNAL_LIBRARIES = {
+    /** Basis transcoder, javascript wrapper part */
     TRANSCODER: "basis_transcoder.js",
+    /** Basis transcoder, compiled web assembly part */
     TRANSCODER_WASM: "basis_transcoder.wasm",
+    /** Basis encoder, javascript wrapper part */
     ENCODER: "basis_encoder.js",
+    /** Basis encoder, compiled web assembly part */
     ENCODER_WASM: "basis_encoder.wasm"
   };
   var loadBasisTranscoderPromise;
@@ -5672,10 +6390,12 @@
 
   // ../textures/src/lib/gl-extensions.ts
   var GL_EXTENSIONS_CONSTANTS = {
+    // WEBGL_compressed_texture_s3tc
     COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
     COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
     COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
     COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
+    // WEBGL_compressed_texture_es3
     COMPRESSED_R11_EAC: 37488,
     COMPRESSED_SIGNED_R11_EAC: 37489,
     COMPRESSED_RG11_EAC: 37490,
@@ -5686,14 +6406,18 @@
     COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37495,
     COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37496,
     COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37497,
+    // WEBGL_compressed_texture_pvrtc
     COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
     COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
     COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
     COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
+    // WEBGL_compressed_texture_etc1
     COMPRESSED_RGB_ETC1_WEBGL: 36196,
+    // WEBGL_compressed_texture_atc
     COMPRESSED_RGB_ATC_WEBGL: 35986,
     COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35987,
     COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798,
+    // WEBGL_compressed_texture_astc
     COMPRESSED_RGBA_ASTC_4X4_KHR: 37808,
     COMPRESSED_RGBA_ASTC_5X4_KHR: 37809,
     COMPRESSED_RGBA_ASTC_5X5_KHR: 37810,
@@ -5722,10 +6446,12 @@
     COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR: 37851,
     COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR: 37852,
     COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR: 37853,
+    // EXT_texture_compression_rgtc
     COMPRESSED_RED_RGTC1_EXT: 36283,
     COMPRESSED_SIGNED_RED_RGTC1_EXT: 36284,
     COMPRESSED_RED_GREEN_RGTC2_EXT: 36285,
     COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 36286,
+    // WEBGL_compressed_texture_s3tc_srgb
     COMPRESSED_SRGB_S3TC_DXT1_EXT: 35916,
     COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 35917,
     COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 35918,
@@ -5735,6 +6461,7 @@
   // ../textures/src/lib/utils/texture-formats.ts
   var BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
   var WEBGL_EXTENSIONS = {
+    /* eslint-disable camelcase */
     WEBGL_compressed_texture_s3tc: "dxt",
     WEBGL_compressed_texture_s3tc_srgb: "dxt-srgb",
     WEBGL_compressed_texture_etc1: "etc1",
@@ -5743,12 +6470,13 @@
     WEBGL_compressed_texture_atc: "atc",
     WEBGL_compressed_texture_astc: "astc",
     EXT_texture_compression_rgtc: "rgtc"
+    /* eslint-enable camelcase */
   };
   var formats = null;
   function getSupportedGPUTextureFormats(gl) {
     if (!formats) {
       gl = gl || getWebGLContext() || void 0;
-      formats = new Set();
+      formats = /* @__PURE__ */ new Set();
       for (const prefix of BROWSER_PREFIXES) {
         for (const extension in WEBGL_EXTENSIONS) {
           if (gl && gl.getExtension(`${prefix}${extension}`)) {
@@ -5834,7 +6562,7 @@
     }
   };
   function _(t2) {
-    return typeof TextDecoder != "undefined" ? new TextDecoder().decode(t2) : Buffer.from(t2).toString("utf8");
+    return "undefined" != typeof TextDecoder ? new TextDecoder().decode(t2) : Buffer.from(t2).toString("utf8");
   }
   function p(t2) {
     const n2 = new Uint8Array(t2.buffer, t2.byteOffset, e.length);
@@ -5925,49 +6653,91 @@
     154: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_R11_EAC,
     155: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RG11_EAC,
     156: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RG11_EAC,
+    // @ts-ignore
     157: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4x4_KHR,
+    // @ts-ignore
     158: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
+    // @ts-ignore
     159: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x4_KHR,
+    // @ts-ignore
     160: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR,
+    // @ts-ignore
     161: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x5_KHR,
+    // @ts-ignore
     162: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
+    // @ts-ignore
     163: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x5_KHR,
+    // @ts-ignore
     164: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
+    // @ts-ignore
     165: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x6_KHR,
+    // @ts-ignore
     166: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
+    // @ts-ignore
     167: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x5_KHR,
+    // @ts-ignore
     168: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
+    // @ts-ignore
     169: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x6_KHR,
+    // @ts-ignore
     170: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
+    // @ts-ignore
     171: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x8_KHR,
+    // @ts-ignore
     172: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
+    // @ts-ignore
     173: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x5_KHR,
+    // @ts-ignore
     174: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
+    // @ts-ignore
     175: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x6_KHR,
+    // @ts-ignore
     176: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
+    // @ts-ignore
     177: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x8_KHR,
+    // @ts-ignore
     178: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
+    // @ts-ignore
     179: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x10_KHR,
+    // @ts-ignore
     180: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
+    // @ts-ignore
     181: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x10_KHR,
+    // @ts-ignore
     182: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
+    // @ts-ignore
     183: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x12_KHR,
+    // @ts-ignore
     184: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
     1000054e3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,
     1000054001: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
+    // @ts-ignore
     1000066e3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4x4_KHR,
+    // @ts-ignore
     1000066001: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x4_KHR,
+    // @ts-ignore
     1000066002: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x5_KHR,
+    // @ts-ignore
     1000066003: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x5_KHR,
+    // @ts-ignore
     1000066004: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x6_KHR,
+    // @ts-ignore
     1000066005: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x5_KHR,
+    // @ts-ignore
     1000066006: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x6_KHR,
+    // @ts-ignore
     1000066007: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x8_KHR,
+    // @ts-ignore
     1000066008: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x5_KHR,
+    // @ts-ignore
     1000066009: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x6_KHR,
+    // @ts-ignore
     1000066010: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x8_KHR,
+    // @ts-ignore
     1000066011: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x10_KHR,
+    // @ts-ignore
     1000066012: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x10_KHR,
+    // @ts-ignore
     1000066013: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x12_KHR
   };
   function mapVkFormatToWebGL(vkFormat) {
@@ -5976,6 +6746,7 @@
 
   // ../textures/src/lib/parsers/parse-ktx.ts
   var KTX2_ID = [
+    // '´', 'K', 'T', 'X', '2', '0', 'ª', '\r', '\n', '\x1A', '\n'
     171,
     75,
     84,
@@ -5991,7 +6762,18 @@
   ];
   function isKTX(data) {
     const id = new Uint8Array(data);
-    const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || id[1] !== KTX2_ID[1] || id[2] !== KTX2_ID[2] || id[3] !== KTX2_ID[3] || id[4] !== KTX2_ID[4] || id[5] !== KTX2_ID[5] || id[6] !== KTX2_ID[6] || id[7] !== KTX2_ID[7] || id[8] !== KTX2_ID[8] || id[9] !== KTX2_ID[9] || id[10] !== KTX2_ID[10] || id[11] !== KTX2_ID[11];
+    const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || // '´'
+    id[1] !== KTX2_ID[1] || // 'K'
+    id[2] !== KTX2_ID[2] || // 'T'
+    id[3] !== KTX2_ID[3] || // 'X'
+    id[4] !== KTX2_ID[4] || // ' '
+    id[5] !== KTX2_ID[5] || // '2'
+    id[6] !== KTX2_ID[6] || // '0'
+    id[7] !== KTX2_ID[7] || // 'ª'
+    id[8] !== KTX2_ID[8] || // '\r'
+    id[9] !== KTX2_ID[9] || // '\n'
+    id[10] !== KTX2_ID[10] || // '\x1A'
+    id[11] !== KTX2_ID[11];
     return !notKTX;
   }
   function parseKTX(arrayBuffer) {
@@ -6104,7 +6886,9 @@
   function transcodeImage(basisFile, imageIndex, levelIndex, options) {
     const width = basisFile.getImageWidth(imageIndex, levelIndex);
     const height = basisFile.getImageHeight(imageIndex, levelIndex);
-    const hasAlpha = basisFile.getHasAlpha();
+    const hasAlpha = basisFile.getHasAlpha(
+      /* imageIndex, levelIndex */
+    );
     const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
     const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
     const decodedData = new Uint8Array(decodedSize);
@@ -6112,11 +6896,14 @@
       throw new Error("failed to start Basis transcoding");
     }
     return {
+      // standard loaders.gl image category payload
       width,
       height,
       data: decodedData,
       compressed,
       format,
+      // Additional fields
+      // Add levelSize field.
       hasAlpha
     };
   }
@@ -6141,16 +6928,33 @@
   function transcodeKTX2Image(ktx2File, levelIndex, options) {
     const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
     const { compressed, format, basisFormat } = getBasisOptions(options, alphaFlag);
-    const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0, 0, basisFormat);
+    const decodedSize = ktx2File.getImageTranscodedSizeInBytes(
+      levelIndex,
+      0,
+      0,
+      basisFormat
+    );
     const decodedData = new Uint8Array(decodedSize);
-    if (!ktx2File.transcodeImage(decodedData, levelIndex, 0, 0, basisFormat, 0, -1, -1)) {
+    if (!ktx2File.transcodeImage(
+      decodedData,
+      levelIndex,
+      0,
+      0,
+      basisFormat,
+      0,
+      -1,
+      -1
+      /* channel1 */
+    )) {
       throw new Error("Failed to transcode KTX2 image");
     }
     return {
+      // standard loaders.gl image category payload
       width,
       height,
       data: decodedData,
       compressed,
+      // Additional fields
       levelSize: decodedSize,
       hasAlpha: alphaFlag,
       format
@@ -6203,9 +7007,12 @@
     options: {
       basis: {
         format: "auto",
+        // gl context doesn't exist on a worker thread
         libraryPath: "libs/",
         containerFormat: "auto",
+        // 'basis' || 'ktx2' || 'auto'
         module: "transcoder"
+        // 'transcoder' || 'encoder'
       }
     }
   };
@@ -6256,7 +7063,10 @@
   function parseDDS(data) {
     const header = new Int32Array(data, 0, DDS_CONSTANTS.HEADER_LENGTH);
     const pixelFormatNumber = header[DDS_CONSTANTS.HEADER_PF_FOURCC_INDEX];
-    assert(Boolean(header[DDS_CONSTANTS.HEADER_PF_FLAGS_INDEX] & DDS_CONSTANTS.DDPF_FOURCC), "DDS: Unsupported format, must contain a FourCC code");
+    assert(
+      Boolean(header[DDS_CONSTANTS.HEADER_PF_FLAGS_INDEX] & DDS_CONSTANTS.DDPF_FOURCC),
+      "DDS: Unsupported format, must contain a FourCC code"
+    );
     const fourCC = int32ToFourCC(pixelFormatNumber);
     const internalFormat = DDS_PIXEL_FORMATS[fourCC];
     const sizeFunction = DDS_SIZE_FUNCTIONS[fourCC];
@@ -6284,7 +7094,12 @@
     return (width + 3 >> 2) * (height + 3 >> 2) * 16;
   }
   function int32ToFourCC(value) {
-    return String.fromCharCode(value & 255, value >> 8 & 255, value >> 16 & 255, value >> 24 & 255);
+    return String.fromCharCode(
+      value & 255,
+      value >> 8 & 255,
+      value >> 16 & 255,
+      value >> 24 & 255
+    );
   }
 
   // ../textures/src/lib/parsers/parse-pvr.ts
@@ -6507,7 +7322,9 @@
       "ktx",
       "ktx2",
       "dds",
+      // WEBGL_compressed_texture_s3tc, WEBGL_compressed_texture_atc
       "pvr"
+      // WEBGL_compressed_texture_pvrtc
     ],
     mimeTypes: [
       "image/ktx2",
@@ -6533,6 +7350,7 @@
             alpha: "BC3",
             noAlpha: "BC1"
           },
+          // @ts-expect-error TODO not allowed to modify inputs
           ...options.basis,
           containerFormat: "ktx2",
           module: "encoder"
@@ -6544,13 +7362,6 @@
     }
   };
 
-  // src/types.ts
-  var HeaderAttributeProperty;
-  (function(HeaderAttributeProperty2) {
-    HeaderAttributeProperty2["vertexCount"] = "vertexCount";
-    HeaderAttributeProperty2["featureCount"] = "featureCount";
-  })(HeaderAttributeProperty || (HeaderAttributeProperty = {}));
-
   // src/lib/utils/url-utils.ts
   function getUrlWithToken(url, token = null) {
     return token ? `${url}?token=${token}` : url;
@@ -7221,14 +8032,6 @@
   var OBJECT_ID_ATTRIBUTE_TYPE = "Oid32";
   var FLOAT_64_TYPE = "Float64";
   var INT_16_ATTRIBUTE_TYPE = "Int16";
-  var COORDINATE_SYSTEM;
-  (function(COORDINATE_SYSTEM2) {
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["DEFAULT"] = -1] = "DEFAULT";
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["LNGLAT"] = 1] = "LNGLAT";
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["METER_OFFSETS"] = 2] = "METER_OFFSETS";
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["LNGLAT_OFFSETS"] = 3] = "LNGLAT_OFFSETS";
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["CARTESIAN"] = 0] = "CARTESIAN";
-  })(COORDINATE_SYSTEM || (COORDINATE_SYSTEM = {}));
 
   // src/lib/parsers/parse-i3s-attribute.ts
   function parseI3STileAttribute(arrayBuffer, options) {
@@ -7272,7 +8075,11 @@
     const bytesPerStringSize = 4;
     const stringsArray = [];
     try {
-      const stringsCount = new DataView(arrayBuffer, stringsCountOffset, bytesPerStringSize).getUint32(stringsCountOffset, true);
+      const stringsCount = new DataView(
+        arrayBuffer,
+        stringsCountOffset,
+        bytesPerStringSize
+      ).getUint32(stringsCountOffset, true);
       const stringSizes = new Uint32Array(arrayBuffer, dataOffset, stringsCount);
       let stringOffset = dataOffset + stringsCount * bytesPerStringSize;
       for (const stringByteSize of stringSizes) {
@@ -7288,7 +8095,7 @@
   }
 
   // src/i3s-attribute-loader.ts
-  var VERSION6 = true ? "4.0.0-beta.2" : "latest";
+  var VERSION6 = true ? "4.0.0-beta.4" : "latest";
   var I3SAttributeLoader = {
     name: "I3S Attribute",
     id: "i3s-attribute",
@@ -7314,11 +8121,20 @@
     if (!options?.i3s?.colorsByAttribute) {
       return colors;
     }
-    const colorizeAttributeField = tilesetOptions.fields.find(({ name }) => name === options?.i3s?.colorsByAttribute?.attributeName);
-    if (!colorizeAttributeField || !["esriFieldTypeDouble", "esriFieldTypeInteger", "esriFieldTypeSmallInteger"].includes(colorizeAttributeField.type)) {
+    const colorizeAttributeField = tilesetOptions.fields.find(
+      ({ name }) => name === options?.i3s?.colorsByAttribute?.attributeName
+    );
+    if (!colorizeAttributeField || !["esriFieldTypeDouble", "esriFieldTypeInteger", "esriFieldTypeSmallInteger"].includes(
+      colorizeAttributeField.type
+    )) {
       return colors;
     }
-    const colorizeAttributeData = await loadFeatureAttributeData(colorizeAttributeField.name, tileOptions, tilesetOptions, options);
+    const colorizeAttributeData = await loadFeatureAttributeData(
+      colorizeAttributeField.name,
+      tileOptions,
+      tilesetOptions,
+      options
+    );
     if (!colorizeAttributeData) {
       return colors;
     }
@@ -7326,13 +8142,22 @@
     if (!objectIdField) {
       return colors;
     }
-    const objectIdAttributeData = await loadFeatureAttributeData(objectIdField.name, tileOptions, tilesetOptions, options);
+    const objectIdAttributeData = await loadFeatureAttributeData(
+      objectIdField.name,
+      tileOptions,
+      tilesetOptions,
+      options
+    );
     if (!objectIdAttributeData) {
       return colors;
     }
     const attributeValuesMap = {};
     for (let i2 = 0; i2 < objectIdAttributeData[objectIdField.name].length; i2++) {
-      attributeValuesMap[objectIdAttributeData[objectIdField.name][i2]] = calculateColorForAttribute(colorizeAttributeData[colorizeAttributeField.name][i2], options);
+      attributeValuesMap[objectIdAttributeData[objectIdField.name][i2]] = calculateColorForAttribute(
+        // @ts-expect-error
+        colorizeAttributeData[colorizeAttributeField.name][i2],
+        options
+      );
     }
     for (let i2 = 0; i2 < featureIds.value.length; i2++) {
       const color = attributeValuesMap[featureIds.value[i2]];
@@ -7376,7 +8201,7 @@
   }
 
   // src/lib/parsers/parse-i3s-tile-content.ts
-  var scratchVector5 = new Vector3([0, 0, 0]);
+  var scratchVector6 = new Vector3([0, 0, 0]);
   function getLoaderForTextureFormat(textureFormat) {
     switch (textureFormat) {
       case "ktx-etc2":
@@ -7405,7 +8230,8 @@
     if (tileOptions.textureUrl) {
       const url = getUrlWithToken(tileOptions.textureUrl, options?.i3s?.token);
       const loader = getLoaderForTextureFormat(tileOptions.textureFormat);
-      const response = await fetch(url, options?.fetch);
+      const fetch2 = context?.fetch;
+      const response = await fetch2(url);
       const arrayBuffer2 = await response.arrayBuffer();
       if (options?.i3s.decodeTextures) {
         if (loader === ImageLoader) {
@@ -7487,26 +8313,46 @@
       byteOffset = headers.byteOffset;
       vertexCount = headers.vertexCount;
       featureCount = headers.featureCount;
-      const { attributes: normalizedVertexAttributes, byteOffset: offset } = normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, vertexCount, attributesOrder);
-      const { attributes: normalizedFeatureAttributes } = normalizeAttributes(arrayBuffer, offset, featureAttributes, featureCount, featureAttributeOrder);
+      const { attributes: normalizedVertexAttributes, byteOffset: offset } = normalizeAttributes(
+        arrayBuffer,
+        byteOffset,
+        vertexAttributes,
+        vertexCount,
+        attributesOrder
+      );
+      const { attributes: normalizedFeatureAttributes } = normalizeAttributes(
+        arrayBuffer,
+        offset,
+        featureAttributes,
+        featureCount,
+        featureAttributeOrder
+      );
       flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes);
       attributes = concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes);
     }
-    if (!options?.i3s?.coordinateSystem || options.i3s.coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) {
+    if (!options?.i3s?.coordinateSystem || options.i3s.coordinateSystem === 2 /* METER_OFFSETS */) {
       const enuMatrix = parsePositions(attributes.position, tileOptions);
       content.modelMatrix = enuMatrix.invert();
-      content.coordinateSystem = COORDINATE_SYSTEM.METER_OFFSETS;
+      content.coordinateSystem = 2 /* METER_OFFSETS */;
     } else {
       content.modelMatrix = getModelMatrix(attributes.position);
-      content.coordinateSystem = COORDINATE_SYSTEM.LNGLAT_OFFSETS;
-    }
-    attributes.color = await customizeColors(attributes.color, attributes.id, tileOptions, tilesetOptions, options);
+      content.coordinateSystem = 3 /* LNGLAT_OFFSETS */;
+    }
+    attributes.color = await customizeColors(
+      attributes.color,
+      attributes.id,
+      tileOptions,
+      tilesetOptions,
+      options
+    );
     content.attributes = {
       positions: attributes.position,
       normals: attributes.normal,
       colors: normalizeAttribute(attributes.color),
+      // Normalize from UInt8
       texCoords: attributes.uv0,
       uvRegions: normalizeAttribute(attributes.uvRegion || attributes.region)
+      // Normalize from UInt16
     };
     content.indices = indices || null;
     if (attributes.id && attributes.id.value) {
@@ -7553,11 +8399,11 @@
     for (const { property, type } of options.store.defaultGeometrySchema.header) {
       const TypedArrayTypeHeader = getConstructorForDataFormat(type);
       switch (property) {
-        case HeaderAttributeProperty.vertexCount:
+        case "vertexCount" /* vertexCount */:
           vertexCount = new TypedArrayTypeHeader(arrayBuffer, 0, 4)[0];
           byteOffset += sizeOf(type);
           break;
-        case HeaderAttributeProperty.featureCount:
+        case "featureCount" /* featureCount */:
           featureCount = new TypedArrayTypeHeader(arrayBuffer, 4, 4)[0];
           byteOffset += sizeOf(type);
           break;
@@ -7642,10 +8488,10 @@
       positions[i2 + 2] = vertices[i2 + 2] + cartographicOrigin.z;
     }
     for (let i2 = 0; i2 < positions.length; i2 += 3) {
-      Ellipsoid.WGS84.cartographicToCartesian(positions.subarray(i2, i2 + 3), scratchVector5);
-      positions[i2] = scratchVector5.x;
-      positions[i2 + 1] = scratchVector5.y;
-      positions[i2 + 2] = scratchVector5.z;
+      Ellipsoid.WGS84.cartographicToCartesian(positions.subarray(i2, i2 + 3), scratchVector6);
+      positions[i2] = scratchVector6.x;
+      positions[i2 + 1] = scratchVector6.y;
+      positions[i2 + 2] = scratchVector6.z;
     }
     return positions;
   }
@@ -7683,7 +8529,9 @@
       pbrMaterial.emissiveFactor = convertColorFormat(pbrMaterial.emissiveFactor);
     }
     if (pbrMaterial.pbrMetallicRoughness && pbrMaterial.pbrMetallicRoughness.baseColorFactor) {
-      pbrMaterial.pbrMetallicRoughness.baseColorFactor = convertColorFormat(pbrMaterial.pbrMetallicRoughness.baseColorFactor);
+      pbrMaterial.pbrMetallicRoughness.baseColorFactor = convertColorFormat(
+        pbrMaterial.pbrMetallicRoughness.baseColorFactor
+      );
     }
     if (texture) {
       setMaterialTexture(pbrMaterial, texture);
@@ -7753,7 +8601,7 @@
   }
 
   // src/i3s-content-loader.ts
-  var VERSION7 = true ? "4.0.0-beta.2" : "beta";
+  var VERSION7 = true ? "4.0.0-beta.4" : "beta";
   var I3SContentLoader = {
     name: "I3S Content (Indexed Scene Layers)",
     id: "i3s-content",
@@ -7774,7 +8622,13 @@
     if (!tileOptions || !tilesetOptions) {
       return null;
     }
-    return await parseI3STileContent(data, tileOptions, tilesetOptions, options, context);
+    return await parseI3STileContent(
+      data,
+      tileOptions,
+      tilesetOptions,
+      options,
+      context
+    );
   }
 
   // src/workers/i3s-content-worker.ts