@loaders.gl/i3s 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/i3s-content-worker.js

@@ -1,11 +1,36 @@
 (() => {
+  var __create = Object.create;
   var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[Object.keys(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 });
+    }
+    return target;
+  };
+  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);
+  };
+
+  // (disabled):../worker-utils/src/lib/node/require-utils.node
+  var require_require_utils = __commonJS({
+    "(disabled):../worker-utils/src/lib/node/require-utils.node"() {
+    }
+  });
 
   // ../loader-utils/src/lib/env-utils/assert.ts
   function assert(condition, message) {
@@ -30,9 +55,8 @@
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
   // ../worker-utils/src/lib/env-utils/version.ts
-  var DEFAULT_VERSION = "beta";
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : DEFAULT_VERSION;
-  if (typeof __VERSION__ === "undefined") {
+  var VERSION = true ? "4.0.0-alpha.11" : DEFAULT_VERSION;
+  if (false) {
     console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
   }
 
@@ -63,15 +87,15 @@
   // ../worker-utils/src/lib/worker-farm/worker-job.ts
   var WorkerJob = class {
     constructor(jobName, workerThread) {
-      this.name = jobName;
-      this.workerThread = workerThread;
       this.isRunning = true;
       this._resolve = () => {
       };
       this._reject = () => {
       };
-      this.result = new Promise((resolve, reject) => {
-        this._resolve = resolve;
+      this.name = jobName;
+      this.workerThread = workerThread;
+      this.result = new Promise((resolve2, reject) => {
+        this._resolve = resolve2;
         this._reject = reject;
       });
     }
@@ -94,6 +118,12 @@
     }
   };
 
+  // ../worker-utils/src/lib/node/worker_threads-browser.ts
+  var Worker2 = class {
+    terminate() {
+    }
+  };
+
   // ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
   var workerURLCache = new Map();
   function getLoadableWorkerURL(props) {
@@ -181,10 +211,10 @@
       this.url = url;
       this.onMessage = NOOP;
       this.onError = (error) => console.log(error);
-      this.worker = this._createBrowserWorker();
+      this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker();
     }
     static isSupported() {
-      return typeof Worker !== "undefined";
+      return typeof Worker !== "undefined" && isBrowser2 || typeof Worker2 !== "undefined" && !isBrowser2;
     }
     destroy() {
       this.onMessage = NOOP;
@@ -227,6 +257,27 @@
       worker.onmessageerror = (event) => console.error(event);
       return worker;
     }
+    _createNodeWorker() {
+      let worker;
+      if (this.url) {
+        const absolute = this.url.includes(":/") || this.url.startsWith("/");
+        const url = absolute ? this.url : `./${this.url}`;
+        worker = new Worker2(url, { eval: false });
+      } else if (this.source) {
+        worker = new Worker2(this.source, { eval: true });
+      } else {
+        throw new Error("no worker");
+      }
+      worker.on("message", (data) => {
+        this.onMessage(data);
+      });
+      worker.on("error", (error) => {
+        this.onError(error);
+      });
+      worker.on("exit", (code) => {
+      });
+      return worker;
+    }
   };
 
   // ../worker-utils/src/lib/worker-farm/worker-pool.ts
@@ -247,6 +298,9 @@
       this.url = props.url;
       this.setProps(props);
     }
+    static isSupported() {
+      return WorkerThread.isSupported();
+    }
     destroy() {
       this.idleQueue.forEach((worker) => worker.destroy());
       this.isDestroyed = true;
@@ -305,7 +359,7 @@
       }
     }
     returnWorkerToQueue(worker) {
-      const shouldDestroyWorker = this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
+      const shouldDestroyWorker = !isBrowser2 || this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
       if (shouldDestroyWorker) {
         worker.destroy();
         this.count--;
@@ -336,9 +390,9 @@
   var DEFAULT_PROPS = {
     maxConcurrency: 3,
     maxMobileConcurrency: 1,
+    reuseWorkers: true,
     onDebug: () => {
-    },
-    reuseWorkers: true
+    }
   };
   var WorkerFarm = class {
     constructor(props) {
@@ -359,6 +413,7 @@
       for (const workerPool of this.workerPools.values()) {
         workerPool.destroy();
       }
+      this.workerPools = new Map();
     }
     setProps(props) {
       this.props = { ...this.props, ...props };
@@ -391,16 +446,33 @@
   };
 
   // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+    }
+    return parentPort;
+  }
   var onMessageWrapperMap = new Map();
   var WorkerBody = class {
+    static inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(getParentPort());
+    }
     static set onmessage(onMessage2) {
-      self.onmessage = (message) => {
-        if (!isKnownMessage(message)) {
-          return;
-        }
-        const { type, payload } = message.data;
+      function handleMessage(message) {
+        const parentPort3 = getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
         onMessage2(type, payload);
-      };
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.on("message", handleMessage);
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
     }
     static addEventListener(onMessage2) {
       let onMessageWrapper = onMessageWrapperMap.get(onMessage2);
@@ -409,22 +481,36 @@
           if (!isKnownMessage(message)) {
             return;
           }
-          const { type, payload } = message.data;
+          const parentPort3 = getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
           onMessage2(type, payload);
         };
       }
-      self.addEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
     }
     static removeEventListener(onMessage2) {
       const onMessageWrapper = onMessageWrapperMap.get(onMessage2);
       onMessageWrapperMap.delete(onMessage2);
-      self.removeEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
     }
     static postMessage(type, payload) {
-      if (self) {
-        const data = { source: "loaders.gl", type, payload };
-        const transferList = getTransferList(payload);
-        self.postMessage(data, transferList);
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
       }
     }
   };
@@ -437,8 +523,11 @@
   var NPM_TAG = "beta";
   function getWorkerURL(worker, options = {}) {
     const workerOptions = options[worker.id] || {};
-    const workerFile = `${worker.id}-worker.js`;
+    const workerFile = isBrowser2 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
     let url = workerOptions.workerUrl;
+    if (!url && worker.id === "compression") {
+      url = options.workerUrl;
+    }
     if (options._workerType === "test") {
       url = `modules/${worker.module}/dist/${workerFile}`;
     }
@@ -465,6 +554,7 @@
   }
 
   // ../worker-utils/src/lib/library-utils/library-utils.ts
+  var node = __toModule(require_require_utils());
   var LATEST = "beta";
   var VERSION2 = typeof VERSION !== "undefined" ? VERSION : LATEST;
   var loadLibraryPromises = {};
@@ -501,7 +591,11 @@
       return await response2.arrayBuffer();
     }
     if (!isBrowser2) {
-      return node.requireFromFile && await node.requireFromFile(libraryUrl);
+      try {
+        return node && node.requireFromFile && await node.requireFromFile(libraryUrl);
+      } catch {
+        return null;
+      }
     }
     if (isWorker) {
       return importScripts(libraryUrl);
@@ -532,19 +626,20 @@
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
   var requestId = 0;
   function createLoaderWorker(loader) {
-    if (typeof self === "undefined") {
+    if (!WorkerBody.inWorkerThread()) {
       return;
     }
     WorkerBody.onmessage = async (type, payload) => {
       switch (type) {
         case "process":
           try {
-            const { input, options = {} } = payload;
+            const { input, options = {}, context = {} } = payload;
             const result = await parseData({
               loader,
               arrayBuffer: input,
               options,
               context: {
+                ...context,
                 parse: parseOnMainThread
               }
             });
@@ -559,7 +654,7 @@
     };
   }
   function parseOnMainThread(arrayBuffer, options) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const id = requestId++;
       const onMessage2 = (type, payload2) => {
         if (payload2.id !== id) {
@@ -568,7 +663,7 @@
         switch (type) {
           case "done":
             WorkerBody.removeEventListener(onMessage2);
-            resolve(payload2.result);
+            resolve2(payload2.result);
             break;
           case "error":
             WorkerBody.removeEventListener(onMessage2);
@@ -608,6 +703,9 @@
     if (!WorkerFarm.isSupported()) {
       return false;
     }
+    if (!isBrowser2 && !options?._nodeWorkers) {
+      return false;
+    }
     return loader.worker && options?.worker;
   }
   async function parseWithWorker(loader, data, options, context, parseOnMainThread2) {
@@ -616,10 +714,12 @@
     const workerFarm = WorkerFarm.getWorkerFarm(options);
     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));
     job.postMessage("process", {
       input: data,
-      options
+      options,
+      context
     });
     const result = await job.result;
     return await result.result;
@@ -647,42 +747,7 @@
     }
   }
 
-  // ../loader-utils/src/lib/binary-utils/buffer-utils.ts
-  function isBuffer(value) {
-    return value && typeof value === "object" && value.isBuffer;
-  }
-  function bufferToArrayBuffer(buffer) {
-    if (isBuffer(buffer)) {
-      const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
-      return typedArray.slice().buffer;
-    }
-    return buffer;
-  }
-
   // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
-  function toArrayBuffer(data) {
-    if (isBuffer(data)) {
-      return bufferToArrayBuffer(data);
-    }
-    if (data instanceof ArrayBuffer) {
-      return data;
-    }
-    if (ArrayBuffer.isView(data)) {
-      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-        return data.buffer;
-      }
-      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-    }
-    if (typeof data === "string") {
-      const text = data;
-      const uint8Array = new TextEncoder().encode(text);
-      return uint8Array.buffer;
-    }
-    if (data && typeof data === "object" && data._toArrayBuffer) {
-      return data._toArrayBuffer();
-    }
-    throw new Error("toArrayBuffer");
-  }
   function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
     byteLength = byteLength || arrayBuffer1.byteLength;
     if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
@@ -699,7 +764,7 @@
   }
   function concatenateArrayBuffers(...sources) {
     const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
-    const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
+    const byteLength = sourceArrays.reduce((length2, typedArray) => length2 + typedArray.byteLength, 0);
     const result = new Uint8Array(byteLength);
     let offset = 0;
     for (const sourceArray of sourceArrays) {
@@ -718,6 +783,52 @@
     return concatenateArrayBuffers(...arrayBuffers);
   }
 
+  // ../../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 obj2;
+    } : function(obj2) {
+      return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+
   // ../loader-utils/src/lib/path-utils/file-aliases.ts
   var pathPrefix = "";
   var fileAliases = {};
@@ -734,19 +845,64 @@
     return filename2;
   }
 
+  // ../loader-utils/src/lib/node/buffer.browser.ts
+  function toArrayBuffer(buffer) {
+    return buffer;
+  }
+
+  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+  function isBuffer(value) {
+    return value && typeof value === "object" && value.isBuffer;
+  }
+  function toArrayBuffer2(data) {
+    if (isBuffer(data)) {
+      return toArrayBuffer(data);
+    }
+    if (data instanceof ArrayBuffer) {
+      return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+        return data.buffer;
+      }
+      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    }
+    if (typeof data === "string") {
+      const text = data;
+      const uint8Array = new TextEncoder().encode(text);
+      return uint8Array.buffer;
+    }
+    if (data && typeof data === "object" && data._toArrayBuffer) {
+      return data._toArrayBuffer();
+    }
+    throw new Error("toArrayBuffer");
+  }
+
   // ../loader-utils/src/lib/path-utils/path.ts
   var path_exports = {};
   __export(path_exports, {
     dirname: () => dirname,
     filename: () => filename,
-    join: () => join
+    join: () => join,
+    resolve: () => resolve
   });
+
+  // ../loader-utils/src/lib/path-utils/get-cwd.ts
+  function getCWD() {
+    if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
+      return process.cwd();
+    }
+    const pathname = window.location?.pathname;
+    return pathname?.slice(0, pathname.lastIndexOf("/") + 1) || "";
+  }
+
+  // ../loader-utils/src/lib/path-utils/path.ts
   function filename(url) {
-    const slashIndex = url && url.lastIndexOf("/");
+    const slashIndex = url ? url.lastIndexOf("/") : -1;
     return slashIndex >= 0 ? url.substr(slashIndex + 1) : "";
   }
   function dirname(url) {
-    const slashIndex = url && url.lastIndexOf("/");
+    const slashIndex = url ? url.lastIndexOf("/") : -1;
     return slashIndex >= 0 ? url.substr(0, slashIndex) : "";
   }
   function join(...parts) {
@@ -762,6 +918,108 @@
     });
     return parts.join(separator);
   }
+  function resolve(...components) {
+    const paths = [];
+    for (let _i = 0; _i < components.length; _i++) {
+      paths[_i] = components[_i];
+    }
+    let resolvedPath = "";
+    let resolvedAbsolute = false;
+    let cwd;
+    for (let i2 = paths.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) {
+      let path;
+      if (i2 >= 0) {
+        path = paths[i2];
+      } else {
+        if (cwd === void 0) {
+          cwd = getCWD();
+        }
+        path = cwd;
+      }
+      if (path.length === 0) {
+        continue;
+      }
+      resolvedPath = `${path}/${resolvedPath}`;
+      resolvedAbsolute = path.charCodeAt(0) === SLASH;
+    }
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute) {
+      return `/${resolvedPath}`;
+    } else if (resolvedPath.length > 0) {
+      return resolvedPath;
+    }
+    return ".";
+  }
+  var SLASH = 47;
+  var DOT = 46;
+  function normalizeStringPosix(path, allowAboveRoot) {
+    let res = "";
+    let lastSlash = -1;
+    let dots = 0;
+    let code;
+    let isAboveRoot = false;
+    for (let i2 = 0; i2 <= path.length; ++i2) {
+      if (i2 < path.length) {
+        code = path.charCodeAt(i2);
+      } else if (code === SLASH) {
+        break;
+      } else {
+        code = SLASH;
+      }
+      if (code === SLASH) {
+        if (lastSlash === i2 - 1 || dots === 1) {
+        } else if (lastSlash !== i2 - 1 && dots === 2) {
+          if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
+            if (res.length > 2) {
+              const start = res.length - 1;
+              let j = start;
+              for (; j >= 0; --j) {
+                if (res.charCodeAt(j) === SLASH) {
+                  break;
+                }
+              }
+              if (j !== start) {
+                res = j === -1 ? "" : res.slice(0, j);
+                lastSlash = i2;
+                dots = 0;
+                isAboveRoot = false;
+                continue;
+              }
+            } else if (res.length === 2 || res.length === 1) {
+              res = "";
+              lastSlash = i2;
+              dots = 0;
+              isAboveRoot = false;
+              continue;
+            }
+          }
+          if (allowAboveRoot) {
+            if (res.length > 0) {
+              res += "/..";
+            } else {
+              res = "..";
+            }
+            isAboveRoot = true;
+          }
+        } else {
+          const slice = path.slice(lastSlash + 1, i2);
+          if (res.length > 0) {
+            res += `/${slice}`;
+          } else {
+            res = slice;
+          }
+          isAboveRoot = false;
+        }
+        lastSlash = i2;
+        dots = 0;
+      } else if (code === DOT && dots !== -1) {
+        ++dots;
+      } else {
+        dots = -1;
+      }
+    }
+    return res;
+  }
 
   // ../core/src/javascript-utils/is-type.ts
   var isBoolean = (x) => typeof x === "boolean";
@@ -795,40 +1053,55 @@
     return "";
   }
 
-  // ../core/src/lib/utils/resource-utils.ts
+  // ../core/src/lib/utils/url-utils.ts
   var QUERY_STRING_PATTERN = /\?.*/;
-  function getResourceUrlAndType(resource) {
+  function extractQueryString(url) {
+    const matches3 = url.match(QUERY_STRING_PATTERN);
+    return matches3 && matches3[0];
+  }
+  function stripQueryString(url) {
+    return url.replace(QUERY_STRING_PATTERN, "");
+  }
+
+  // ../core/src/lib/utils/resource-utils.ts
+  function getResourceUrl(resource) {
     if (isResponse(resource)) {
-      const url = stripQueryString(resource.url || "");
-      const contentTypeHeader = resource.headers.get("content-type") || "";
-      return {
-        url,
-        type: parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(url)
-      };
+      const response = resource;
+      return response.url;
     }
     if (isBlob(resource)) {
-      return {
-        url: stripQueryString(resource.name || ""),
-        type: resource.type || ""
-      };
+      const blob = resource;
+      return blob.name || "";
     }
     if (typeof resource === "string") {
-      return {
-        url: stripQueryString(resource),
-        type: parseMIMETypeFromURL(resource)
-      };
+      return resource;
     }
-    return {
-      url: "",
-      type: ""
-    };
+    return "";
+  }
+  function getResourceMIMEType(resource) {
+    if (isResponse(resource)) {
+      const response = resource;
+      const contentTypeHeader = response.headers.get("content-type") || "";
+      const noQueryUrl = stripQueryString(response.url);
+      return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
+    }
+    if (isBlob(resource)) {
+      const blob = resource;
+      return blob.type || "";
+    }
+    if (typeof resource === "string") {
+      return parseMIMETypeFromURL(resource);
+    }
+    return "";
   }
   function getResourceContentLength(resource) {
     if (isResponse(resource)) {
-      return resource.headers["content-length"] || -1;
+      const response = resource;
+      return response.headers["content-length"] || -1;
     }
     if (isBlob(resource)) {
-      return resource.size;
+      const blob = resource;
+      return blob.size;
     }
     if (typeof resource === "string") {
       return resource.length;
@@ -841,9 +1114,6 @@
     }
     return -1;
   }
-  function stripQueryString(url) {
-    return url.replace(QUERY_STRING_PATTERN, "");
-  }
 
   // ../core/src/lib/utils/response-utils.ts
   async function makeResponse(resource) {
@@ -855,7 +1125,8 @@
     if (contentLength >= 0) {
       headers["content-length"] = String(contentLength);
     }
-    const { url, type } = getResourceUrlAndType(resource);
+    const url = getResourceUrl(resource);
+    const type = getResourceMIMEType(resource);
     if (type) {
       headers["content-type"] = type;
     }
@@ -885,7 +1156,7 @@
         text += ` ${await response.text()}`;
       }
       message += text;
-      message = message.length > 60 ? `${message.slice(60)}...` : message;
+      message = message.length > 60 ? `${message.slice(0, 60)}...` : message;
     } catch (error) {
     }
     return message;
@@ -897,9 +1168,9 @@
     }
     if (resource instanceof Blob) {
       const blobSlice = resource.slice(0, 5);
-      return await new Promise((resolve) => {
+      return await new Promise((resolve2) => {
         const reader = new FileReader();
-        reader.onload = (event) => resolve(event?.target?.result);
+        reader.onload = (event) => resolve2(event?.target?.result);
         reader.readAsDataURL(blobSlice);
       });
     }
@@ -932,12 +1203,12 @@
     return await makeResponse(url);
   }
 
-  // ../../node_modules/probe.gl/dist/esm/env/is-electron.js
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-electron.js
   function isElectron(mockUserAgent) {
     if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
       return true;
     }
-    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions.electron)) {
+    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) {
       return true;
     }
     const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent;
@@ -948,31 +1219,25 @@
     return false;
   }
 
-  // ../../node_modules/probe.gl/dist/esm/env/is-browser.js
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-browser.js
   function isBrowser3() {
     const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
     return !isNode || isElectron();
   }
 
-  // ../../node_modules/probe.gl/dist/esm/env/globals.js
-  var globals3 = {
-    self: typeof self !== "undefined" && self,
-    window: typeof window !== "undefined" && window,
-    global: typeof global !== "undefined" && global,
-    document: typeof document !== "undefined" && document,
-    process: typeof process === "object" && process
-  };
-  var self_3 = globals3.self || globals3.window || globals3.global;
-  var window_3 = globals3.window || globals3.self || globals3.global;
-  var global_3 = globals3.global || globals3.self || globals3.window;
-  var document_3 = globals3.document || {};
-  var process_ = globals3.process || {};
-
-  // ../../node_modules/probe.gl/dist/esm/utils/globals.js
-  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js
+  var self_3 = globalThis.self || globalThis.window || globalThis.global;
+  var window_3 = globalThis.window || globalThis.self || globalThis.global;
+  var document_3 = globalThis.document || {};
+  var process_ = globalThis.process || {};
+  var console_ = globalThis.console;
+  var navigator_ = globalThis.navigator || {};
+
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
+  var VERSION3 = true ? "4.0.0-alpha.11" : "untranspiled source";
   var isBrowser4 = isBrowser3();
 
-  // ../../node_modules/probe.gl/dist/esm/utils/local-storage.js
+  // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
   function getStorage(type) {
     try {
       const storage = window[type];
@@ -985,27 +1250,25 @@
     }
   }
   var LocalStorage = class {
-    constructor(id, defaultSettings, type = "sessionStorage") {
+    constructor(id, defaultConfig) {
+      let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage";
+      _defineProperty(this, "storage", void 0);
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "config", void 0);
       this.storage = getStorage(type);
       this.id = id;
-      this.config = {};
-      Object.assign(this.config, defaultSettings);
+      this.config = defaultConfig;
       this._loadConfiguration();
     }
     getConfiguration() {
       return this.config;
     }
     setConfiguration(configuration) {
-      this.config = {};
-      return this.updateConfiguration(configuration);
-    }
-    updateConfiguration(configuration) {
       Object.assign(this.config, configuration);
       if (this.storage) {
         const serialized = JSON.stringify(this.config);
         this.storage.setItem(this.id, serialized);
       }
-      return this;
     }
     _loadConfiguration() {
       let configuration = {};
@@ -1018,7 +1281,7 @@
     }
   };
 
-  // ../../node_modules/probe.gl/dist/esm/utils/formatters.js
+  // ../../node_modules/@probe.gl/log/dist/utils/formatters.js
   function formatTime(ms) {
     let formatted;
     if (ms < 10) {
@@ -1032,11 +1295,13 @@
     }
     return formatted;
   }
-  function leftPad(string, length = 8) {
-    const padLength = Math.max(length - string.length, 0);
+  function leftPad(string) {
+    let length2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8;
+    const padLength = Math.max(length2 - string.length, 0);
     return "".concat(" ".repeat(padLength)).concat(string);
   }
-  function formatImage(image, message, scale2, maxWidth = 600) {
+  function formatImage(image, message, scale2) {
+    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);
@@ -1047,69 +1312,80 @@
     return ["".concat(message, " %c+"), style];
   }
 
-  // ../../node_modules/probe.gl/dist/esm/utils/color.js
-  var COLOR = {
-    BLACK: 30,
-    RED: 31,
-    GREEN: 32,
-    YELLOW: 33,
-    BLUE: 34,
-    MAGENTA: 35,
-    CYAN: 36,
-    WHITE: 37,
-    BRIGHT_BLACK: 90,
-    BRIGHT_RED: 91,
-    BRIGHT_GREEN: 92,
-    BRIGHT_YELLOW: 93,
-    BRIGHT_BLUE: 94,
-    BRIGHT_MAGENTA: 95,
-    BRIGHT_CYAN: 96,
-    BRIGHT_WHITE: 97
-  };
+  // ../../node_modules/@probe.gl/log/dist/utils/color.js
+  var COLOR;
+  (function(COLOR2) {
+    COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
+    COLOR2[COLOR2["RED"] = 31] = "RED";
+    COLOR2[COLOR2["GREEN"] = 32] = "GREEN";
+    COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW";
+    COLOR2[COLOR2["BLUE"] = 34] = "BLUE";
+    COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA";
+    COLOR2[COLOR2["CYAN"] = 36] = "CYAN";
+    COLOR2[COLOR2["WHITE"] = 37] = "WHITE";
+    COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+    COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+    COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+    COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+    COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+    COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+    COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+    COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+  })(COLOR || (COLOR = {}));
+  var BACKGROUND_INCREMENT = 10;
   function getColor(color) {
-    return typeof color === "string" ? COLOR[color.toUpperCase()] || COLOR.WHITE : color;
+    if (typeof color !== "string") {
+      return color;
+    }
+    color = color.toUpperCase();
+    return COLOR[color] || COLOR.WHITE;
   }
   function addColor(string, color, background) {
-    if (!isBrowser4 && typeof string === "string") {
+    if (!isBrowser3 && typeof string === "string") {
       if (color) {
-        color = getColor(color);
-        string = "[".concat(color, "m").concat(string, "");
+        const colorCode = getColor(color);
+        string = "[".concat(colorCode, "m").concat(string, "");
       }
       if (background) {
-        color = getColor(background);
-        string = "[".concat(background + 10, "m").concat(string, "");
+        const colorCode = getColor(background);
+        string = "[".concat(colorCode + BACKGROUND_INCREMENT, "m").concat(string, "");
       }
     }
     return string;
   }
 
-  // ../../node_modules/probe.gl/dist/esm/utils/autobind.js
-  function autobind(obj, predefined = ["constructor"]) {
+  // ../../node_modules/@probe.gl/log/dist/utils/autobind.js
+  function autobind(obj) {
+    let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"];
     const proto = Object.getPrototypeOf(obj);
     const propNames = Object.getOwnPropertyNames(proto);
+    const object = obj;
     for (const key of propNames) {
-      if (typeof obj[key] === "function") {
+      const value = object[key];
+      if (typeof value === "function") {
         if (!predefined.find((name) => key === name)) {
-          obj[key] = obj[key].bind(obj);
+          object[key] = value.bind(obj);
         }
       }
     }
   }
 
-  // ../../node_modules/probe.gl/dist/esm/utils/assert.js
+  // ../../node_modules/@probe.gl/log/dist/utils/assert.js
   function assert3(condition, message) {
     if (!condition) {
       throw new Error(message || "Assertion failed");
     }
   }
 
-  // ../../node_modules/probe.gl/dist/esm/utils/hi-res-timestamp.js
-  function getHiResTimestamp2() {
+  // ../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
+  function getHiResTimestamp() {
     let timestamp;
-    if (isBrowser4 && window_3.performance) {
-      timestamp = window_3.performance.now();
-    } else if (process_.hrtime) {
-      const timeParts = process_.hrtime();
+    if (isBrowser3() && window_3.performance) {
+      var _window$performance, _window$performance$n;
+      timestamp = window_3 === null || window_3 === void 0 ? void 0 : (_window$performance = window_3.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance);
+    } else if ("hrtime" in process_) {
+      var _process$hrtime;
+      const timeParts = process_ === null || process_ === void 0 ? void 0 : (_process$hrtime = process_.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_);
       timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
     } else {
       timestamp = Date.now();
@@ -1117,15 +1393,15 @@
     return timestamp;
   }
 
-  // ../../node_modules/probe.gl/dist/esm/lib/log.js
+  // ../../node_modules/@probe.gl/log/dist/log.js
   var originalConsole = {
-    debug: isBrowser4 ? console.debug || console.log : console.log,
+    debug: isBrowser3() ? console.debug || console.log : console.log,
     log: console.log,
     info: console.info,
     warn: console.warn,
     error: console.error
   };
-  var DEFAULT_SETTINGS = {
+  var DEFAULT_LOG_CONFIGURATION = {
     enabled: true,
     level: 0
   };
@@ -1135,27 +1411,23 @@
   var ONCE = {
     once: true
   };
-  function getTableHeader(table) {
-    for (const key in table) {
-      for (const title in table[key]) {
-        return title || "untitled";
-      }
-    }
-    return "empty";
-  }
   var Log = class {
-    constructor({
-      id
-    } = {
-      id: ""
-    }) {
+    constructor() {
+      let {
+        id
+      } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+        id: ""
+      };
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "VERSION", VERSION3);
+      _defineProperty(this, "_startTs", getHiResTimestamp());
+      _defineProperty(this, "_deltaTs", getHiResTimestamp());
+      _defineProperty(this, "_storage", void 0);
+      _defineProperty(this, "userData", {});
+      _defineProperty(this, "LOG_THROTTLE_TIMEOUT", 0);
       this.id = id;
-      this.VERSION = VERSION3;
-      this._startTs = getHiResTimestamp2();
-      this._deltaTs = getHiResTimestamp2();
-      this.LOG_THROTTLE_TIMEOUT = 0;
-      this._storage = new LocalStorage("__probe-".concat(this.id, "__"), DEFAULT_SETTINGS);
       this.userData = {};
+      this._storage = new LocalStorage("__probe-".concat(this.id, "__"), DEFAULT_LOG_CONFIGURATION);
       this.timeStamp("".concat(this.id, " started"));
       autobind(this);
       Object.seal(this);
@@ -1173,10 +1445,10 @@
       return this._storage.config.level;
     }
     getTotal() {
-      return Number((getHiResTimestamp2() - this._startTs).toPrecision(10));
+      return Number((getHiResTimestamp() - this._startTs).toPrecision(10));
     }
     getDelta() {
-      return Number((getHiResTimestamp2() - this._deltaTs).toPrecision(10));
+      return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10));
     }
     set priority(newPriority) {
       this.level = newPriority;
@@ -1187,18 +1459,34 @@
     getPriority() {
       return this.level;
     }
-    enable(enabled = true) {
-      this._storage.updateConfiguration({
+    enable() {
+      let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+      this._storage.setConfiguration({
         enabled
       });
       return this;
     }
     setLevel(level) {
-      this._storage.updateConfiguration({
+      this._storage.setConfiguration({
         level
       });
       return this;
     }
+    get(setting) {
+      return this._storage.config[setting];
+    }
+    set(setting, value) {
+      this._storage.setConfiguration({
+        [setting]: value
+      });
+    }
+    settings() {
+      if (console.table) {
+        console.table(this._storage.config);
+      } else {
+        console.log(this._storage.config);
+      }
+    }
     assert(condition, message) {
       assert3(condition, message);
     }
@@ -1237,17 +1525,18 @@
       }
       return noop;
     }
-    image({
-      logLevel,
-      priority,
-      image,
-      message = "",
-      scale: scale2 = 1
-    }) {
+    image(_ref) {
+      let {
+        logLevel,
+        priority,
+        image,
+        message = "",
+        scale: scale2 = 1
+      } = _ref;
       if (!this._shouldLog(logLevel || priority)) {
         return noop;
       }
-      return isBrowser4 ? logImageInBrowser({
+      return isBrowser3() ? logImageInBrowser({
         image,
         message,
         scale: scale2
@@ -1257,21 +1546,6 @@
         scale: scale2
       });
     }
-    settings() {
-      if (console.table) {
-        console.table(this._storage.config);
-      } else {
-        console.log(this._storage.config);
-      }
-    }
-    get(setting) {
-      return this._storage.config[setting];
-    }
-    set(setting, value) {
-      this._storage.updateConfiguration({
-        [setting]: value
-      });
-    }
     time(logLevel, message) {
       return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
     }
@@ -1281,10 +1555,11 @@
     timeStamp(logLevel, message) {
       return this._getLogFunction(logLevel, message, console.timeStamp || noop);
     }
-    group(logLevel, message, opts = {
-      collapsed: false
-    }) {
-      opts = normalizeArguments({
+    group(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
+        collapsed: false
+      };
+      const options = normalizeArguments({
         logLevel,
         message,
         opts
@@ -1292,10 +1567,11 @@
       const {
         collapsed
       } = opts;
-      opts.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
-      return this._getLogFunction(opts);
+      options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
+      return this._getLogFunction(options);
     }
-    groupCollapsed(logLevel, message, opts = {}) {
+    groupCollapsed(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
       return this.group(logLevel, message, Object.assign({}, opts, {
         collapsed: true
       }));
@@ -1319,7 +1595,7 @@
     _shouldLog(logLevel) {
       return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
     }
-    _getLogFunction(logLevel, message, method, args = [], opts) {
+    _getLogFunction(logLevel, message, method, args, opts) {
       if (this._shouldLog(logLevel)) {
         opts = normalizeArguments({
           logLevel,
@@ -1331,11 +1607,11 @@
         assert3(method);
         opts.total = this.getTotal();
         opts.delta = this.getDelta();
-        this._deltaTs = getHiResTimestamp2();
+        this._deltaTs = getHiResTimestamp();
         const tag = opts.tag || opts.message;
-        if (opts.once) {
+        if (opts.once && tag) {
           if (!cache[tag]) {
-            cache[tag] = getHiResTimestamp2();
+            cache[tag] = getHiResTimestamp();
           } else {
             return noop;
           }
@@ -1346,7 +1622,7 @@
       return noop;
     }
   };
-  Log.VERSION = VERSION3;
+  _defineProperty(Log, "VERSION", VERSION3);
   function normalizeLogLevel(logLevel) {
     if (!logLevel) {
       return 0;
@@ -1374,7 +1650,6 @@
     const args = opts.args ? Array.from(opts.args) : [];
     while (args.length && args.shift() !== message) {
     }
-    opts.args = args;
     switch (typeof logLevel) {
       case "string":
       case "function":
@@ -1393,7 +1668,9 @@
     }
     const messageType = typeof opts.message;
     assert3(messageType === "string" || messageType === "object");
-    return Object.assign(opts, opts.opts);
+    return Object.assign(opts, {
+      args
+    }, opts.opts);
   }
   function decorateMessage(id, message, opts) {
     if (typeof message === "string") {
@@ -1403,29 +1680,21 @@
     }
     return message;
   }
-  function logImageInNode({
-    image,
-    message = "",
-    scale: scale2 = 1
-  }) {
-    let asciify = null;
-    try {
-      asciify = module.require("asciify-image");
-    } catch (error) {
-    }
-    if (asciify) {
-      return () => asciify(image, {
-        fit: "box",
-        width: "".concat(Math.round(80 * scale2), "%")
-      }).then((data) => console.log(data));
-    }
+  function logImageInNode(_ref2) {
+    let {
+      image,
+      message = "",
+      scale: scale2 = 1
+    } = _ref2;
+    console.warn("removed");
     return noop;
   }
-  function logImageInBrowser({
-    image,
-    message = "",
-    scale: scale2 = 1
-  }) {
+  function logImageInBrowser(_ref3) {
+    let {
+      image,
+      message = "",
+      scale: scale2 = 1
+    } = _ref3;
     if (typeof image === "string") {
       const img = new Image();
       img.onload = () => {
@@ -1448,10 +1717,18 @@
     }
     return noop;
   }
+  function getTableHeader(table) {
+    for (const key in table) {
+      for (const title in table[key]) {
+        return title || "untitled";
+      }
+    }
+    return "empty";
+  }
 
-  // ../../node_modules/probe.gl/dist/esm/index.js
-  var esm_default = new Log({
-    id: "probe.gl"
+  // ../../node_modules/@probe.gl/log/dist/index.js
+  var dist_default = new Log({
+    id: "@probe.gl/log"
   });
 
   // ../core/src/lib/loader-utils/loggers.ts
@@ -1502,7 +1779,8 @@
     worker: true,
     maxConcurrency: 3,
     maxMobileConcurrency: 1,
-    reuseWorkers: true,
+    reuseWorkers: isBrowser,
+    _nodeWorkers: false,
     _workerType: "",
     limit: 0,
     _limitMB: 0,
@@ -1547,20 +1825,6 @@
     validateOptions(options, loaders);
     return normalizeOptionsInternal(loader, options, url);
   }
-  function getFetchFunction(options, context) {
-    const globalOptions = getGlobalLoaderOptions();
-    const fetchOptions = options || globalOptions;
-    if (typeof fetchOptions.fetch === "function") {
-      return fetchOptions.fetch;
-    }
-    if (isObject(fetchOptions.fetch)) {
-      return (url) => fetchFile(url, fetchOptions);
-    }
-    if (context?.fetch) {
-      return context?.fetch;
-    }
-    return fetchFile;
-  }
   function validateOptions(options, loaders) {
     validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders);
     for (const loader of loaders) {
@@ -1678,6 +1942,9 @@
     return getGlobalLoaderRegistry();
   }
 
+  // ../core/src/lib/utils/log.ts
+  var log = new Log({ id: "loaders.gl" });
+
   // ../core/src/lib/api/select-loader.ts
   var EXT_PATTERN = /\.([^.]+)$/;
   async function selectLoader(data, loaders = [], options, context) {
@@ -1719,16 +1986,26 @@
     return loader;
   }
   function selectLoaderInternal(data, loaders, options, context) {
-    const { url, type } = getResourceUrlAndType(data);
-    const testUrl = url || context?.url;
+    const url = getResourceUrl(data);
+    const type = getResourceMIMEType(data);
+    const testUrl = stripQueryString(url) || context?.url;
     let loader = null;
+    let reason = "";
     if (options?.mimeType) {
       loader = findLoaderByMIMEType(loaders, options?.mimeType);
+      reason = `match forced by supplied MIME type ${options?.mimeType}`;
     }
     loader = loader || findLoaderByUrl(loaders, testUrl);
+    reason = reason || (loader ? `matched url ${testUrl}` : "");
     loader = loader || findLoaderByMIMEType(loaders, type);
+    reason = reason || (loader ? `matched MIME type ${type}` : "");
     loader = loader || findLoaderByInitialBytes(loaders, data);
+    reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : "");
     loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
+    reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+    if (reason) {
+      log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`);
+    }
     return loader;
   }
   function validHTTPResponse(data) {
@@ -1740,7 +2017,8 @@
     return true;
   }
   function getNoValidLoaderMessage(data) {
-    const { url, type } = getResourceUrlAndType(data);
+    const url = getResourceUrl(data);
+    const type = getResourceMIMEType(data);
     let message = "No valid loader found (";
     message += url ? `${path_exports.filename(url)}, ` : "no url provided, ";
     message += `MIME type: ${type ? `"${type}"` : "not provided"}, `;
@@ -1828,24 +2106,24 @@
         return false;
     }
   }
-  function getFirstCharacters(data, length = 5) {
+  function getFirstCharacters(data, length2 = 5) {
     if (typeof data === "string") {
-      return data.slice(0, length);
+      return data.slice(0, length2);
     } else if (ArrayBuffer.isView(data)) {
-      return getMagicString(data.buffer, data.byteOffset, length);
+      return getMagicString(data.buffer, data.byteOffset, length2);
     } else if (data instanceof ArrayBuffer) {
       const byteOffset = 0;
-      return getMagicString(data, byteOffset, length);
+      return getMagicString(data, byteOffset, length2);
     }
     return "";
   }
-  function getMagicString(arrayBuffer, byteOffset, length) {
-    if (arrayBuffer.byteLength < byteOffset + length) {
+  function getMagicString(arrayBuffer, byteOffset, length2) {
+    if (arrayBuffer.byteLength < byteOffset + length2) {
       return "";
     }
     const dataView = new DataView(arrayBuffer);
     let magic = "";
-    for (let i2 = 0; i2 < length; i2++) {
+    for (let i2 = 0; i2 < length2; i2++) {
       magic += String.fromCharCode(dataView.getUint8(byteOffset + i2));
     }
     return magic;
@@ -1911,7 +2189,7 @@
         if (done) {
           return;
         }
-        yield toArrayBuffer(value);
+        yield toArrayBuffer2(value);
       }
     } catch (error) {
       reader.releaseLock();
@@ -1919,7 +2197,7 @@
   }
   async function* makeNodeStreamIterator(stream, options) {
     for await (const chunk of stream) {
-      yield toArrayBuffer(chunk);
+      yield toArrayBuffer2(chunk);
     }
   }
 
@@ -1997,19 +2275,42 @@
     throw new Error(ERR_DATA);
   }
 
+  // ../core/src/lib/loader-utils/get-fetch-function.ts
+  function getFetchFunction(options, context) {
+    const globalOptions = getGlobalLoaderOptions();
+    const fetchOptions = options || globalOptions;
+    if (typeof fetchOptions.fetch === "function") {
+      return fetchOptions.fetch;
+    }
+    if (isObject(fetchOptions.fetch)) {
+      return (url) => fetchFile(url, fetchOptions);
+    }
+    if (context?.fetch) {
+      return context?.fetch;
+    }
+    return fetchFile;
+  }
+
   // ../core/src/lib/loader-utils/loader-context.ts
-  function getLoaderContext(context, options, previousContext = null) {
-    if (previousContext) {
-      return previousContext;
+  function getLoaderContext(context, options, parentContext) {
+    if (parentContext) {
+      return parentContext;
     }
-    const resolvedContext = {
+    const newContext = {
       fetch: getFetchFunction(options, context),
       ...context
     };
-    if (!Array.isArray(resolvedContext.loaders)) {
-      resolvedContext.loaders = null;
+    if (newContext.url) {
+      const baseUrl = stripQueryString(newContext.url);
+      newContext.baseUrl = baseUrl;
+      newContext.queryString = extractQueryString(newContext.url);
+      newContext.filename = path_exports.filename(baseUrl);
+      newContext.baseUrl = path_exports.dirname(baseUrl);
     }
-    return resolvedContext;
+    if (!Array.isArray(newContext.loaders)) {
+      newContext.loaders = null;
+    }
+    return newContext;
   }
   function getLoadersFromContext(loaders, context) {
     if (!context && loaders && !Array.isArray(loaders)) {
@@ -2036,7 +2337,7 @@
     }
     data = await data;
     options = options || {};
-    const { url } = getResourceUrlAndType(data);
+    const url = getResourceUrl(data);
     const typedLoaders = loaders;
     const candidateLoaders = getLoadersFromContext(typedLoaders, context);
     const loader = await selectLoader(data, candidateLoaders, options);
@@ -2044,11 +2345,17 @@
       return null;
     }
     options = normalizeOptions(options, loader, candidateLoaders, url);
-    context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context);
+    context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context || null);
     return await parseWithLoader(loader, data, options, context);
   }
   async function parseWithLoader(loader, data, options, context) {
     validateWorkerVersion(loader);
+    if (isResponse(data)) {
+      const response = data;
+      const { ok, redirected, status, statusText, type, url } = response;
+      const headers = Object.fromEntries(response.headers.entries());
+      context.response = { headers, ok, redirected, status, statusText, type, url };
+    }
     data = await getArrayBufferOrStringFromData(data, loader, options);
     if (loader.parseTextSync && typeof data === "string") {
       options.dataType = "text";
@@ -2069,12 +2376,17 @@
 
   // ../core/src/lib/api/load.ts
   async function load(url, loaders, options, context) {
+    let resolvedLoaders;
+    let resolvedOptions;
     if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+      resolvedLoaders = [];
+      resolvedOptions = loaders;
       context = void 0;
-      options = loaders;
-      loaders = void 0;
+    } else {
+      resolvedLoaders = loaders;
+      resolvedOptions = options;
     }
-    const fetch2 = getFetchFunction(options);
+    const fetch2 = getFetchFunction(resolvedOptions);
     let data = url;
     if (typeof url === "string") {
       data = await fetch2(url);
@@ -2082,7 +2394,7 @@
     if (isBlob(url)) {
       data = await fetch2(url);
     }
-    return await parse(data, loaders, options);
+    return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions);
   }
 
   // ../../node_modules/@math.gl/core/dist/esm/lib/assert.js
@@ -2095,18 +2407,16 @@
   // ../../node_modules/@math.gl/core/dist/esm/lib/common.js
   var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
   var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
-  var config = {};
-  config.EPSILON = 1e-12;
-  config.debug = false;
-  config.precision = 4;
-  config.printTypes = false;
-  config.printDegrees = false;
-  config.printRowMajor = true;
-  function round(value) {
-    return Math.round(value / config.EPSILON) * config.EPSILON;
-  }
+  var config = {
+    EPSILON: 1e-12,
+    debug: false,
+    precision: 4,
+    printTypes: false,
+    printDegrees: false,
+    printRowMajor: true
+  };
   function formatValue(value, {
-    precision = config.precision || 4
+    precision = config.precision
   } = {}) {
     value = round(value);
     return "".concat(parseFloat(value.toPrecision(precision)));
@@ -2114,6 +2424,18 @@
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
   }
+  function toRadians(degrees2) {
+    return radians(degrees2);
+  }
+  function toDegrees(radians2) {
+    return degrees(radians2);
+  }
+  function radians(degrees2, result) {
+    return map(degrees2, (degrees3) => degrees3 * DEGREES_TO_RADIANS, result);
+  }
+  function degrees(radians2, result) {
+    return map(radians2, (radians3) => radians3 * RADIANS_TO_DEGREES, result);
+  }
   function equals(a2, b, epsilon) {
     const oldEpsilon = config.EPSILON;
     if (epsilon) {
@@ -2140,7 +2462,7 @@
       if (b && b.equals) {
         return b.equals(a2);
       }
-      if (Number.isFinite(a2) && Number.isFinite(b)) {
+      if (typeof a2 === "number" && typeof b === "number") {
         return Math.abs(a2 - b) <= config.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b));
       }
       return false;
@@ -2148,6 +2470,23 @@
       config.EPSILON = oldEpsilon;
     }
   }
+  function round(value) {
+    return Math.round(value / config.EPSILON) * config.EPSILON;
+  }
+  function duplicateArray(array) {
+    return array.clone ? array.clone() : new Array(array.length);
+  }
+  function map(value, func, result) {
+    if (isArray(value)) {
+      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);
+      }
+      return result;
+    }
+    return func(value);
+  }
 
   // ../../node_modules/@math.gl/core/dist/esm/classes/base/math-array.js
   function _extendableBuiltin(cls) {
@@ -2172,22 +2511,24 @@
     return ExtendableBuiltin;
   }
   var MathArray = class extends _extendableBuiltin(Array) {
-    get ELEMENTS() {
-      assert4(false);
-      return 0;
-    }
     clone() {
       return new this.constructor().copy(this);
     }
-    from(arrayOrObject) {
-      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
-    }
     fromArray(array, offset = 0) {
       for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
         this[i2] = array[i2 + offset];
       }
       return this.check();
     }
+    toArray(targetArray = [], offset = 0) {
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        targetArray[offset + i2] = this[i2];
+      }
+      return targetArray;
+    }
+    from(arrayOrObject) {
+      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+    }
     to(arrayOrObject) {
       if (arrayOrObject === this) {
         return this;
@@ -2197,12 +2538,6 @@
     toTarget(target) {
       return target ? this.to(target) : this;
     }
-    toArray(array = [], offset = 0) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        array[offset + i2] = this[i2];
-      }
-      return array;
-    }
     toFloat32Array() {
       return new Float32Array(this);
     }
@@ -2246,9 +2581,7 @@
     }
     lerp(a2, b, t2) {
       if (t2 === void 0) {
-        t2 = b;
-        b = a2;
-        a2 = this;
+        return this.lerp(this, a2, b);
       }
       for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
         const ai = a2[i2];
@@ -2291,14 +2624,36 @@
       return this.check();
     }
     scale(scale2) {
-      if (Array.isArray(scale2)) {
-        return this.multiply(scale2);
+      if (typeof scale2 === "number") {
+        for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+          this[i2] *= scale2;
+        }
+      } else {
+        for (let i2 = 0; i2 < this.ELEMENTS && i2 < scale2.length; ++i2) {
+          this[i2] *= scale2[i2];
+        }
       }
+      return this.check();
+    }
+    multiplyByScalar(scalar) {
       for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] *= scale2;
+        this[i2] *= scalar;
       }
       return this.check();
     }
+    check() {
+      if (config.debug && !this.validate()) {
+        throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
+      }
+      return this;
+    }
+    validate() {
+      let valid = this.length === this.ELEMENTS;
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        valid = valid && Number.isFinite(this[i2]);
+      }
+      return valid;
+    }
     sub(a2) {
       return this.subtract(a2);
     }
@@ -2324,7 +2679,7 @@
       return this.check();
     }
     divideScalar(a2) {
-      return this.scale(1 / a2);
+      return this.multiplyByScalar(1 / a2);
     }
     clampScalar(min, max) {
       for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
@@ -2332,30 +2687,14 @@
       }
       return this.check();
     }
-    multiplyByScalar(scalar) {
-      return this.scale(scalar);
-    }
     get elements() {
       return this;
     }
-    check() {
-      if (config.debug && !this.validate()) {
-        throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
-      }
-      return this;
-    }
-    validate() {
-      let valid = this.length === this.ELEMENTS;
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        valid = valid && Number.isFinite(this[i2]);
-      }
-      return valid;
-    }
   };
 
   // ../../node_modules/@math.gl/core/dist/esm/lib/validators.js
-  function validateVector(v, length) {
-    if (v.length !== length) {
+  function validateVector(v, length2) {
+    if (v.length !== length2) {
       return false;
     }
     for (let i2 = 0; i2 < v.length; ++i2) {
@@ -2371,19 +2710,117 @@
     }
     return value;
   }
-  function checkVector(v, length, callerName = "") {
-    if (config.debug && !validateVector(v, length)) {
+  function checkVector(v, length2, callerName = "") {
+    if (config.debug && !validateVector(v, length2)) {
       throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
     }
     return v;
   }
-  var map = {};
-  function deprecated(method, version) {
-    if (!map[method]) {
-      map[method] = true;
-      console.warn("".concat(method, " has been removed in version ").concat(version, ", see upgrade guide for more information"));
+
+  // ../../node_modules/@math.gl/core/dist/esm/classes/base/vector.js
+  var Vector = class extends MathArray {
+    get x() {
+      return this[0];
     }
-  }
+    set x(value) {
+      this[0] = checkNumber(value);
+    }
+    get y() {
+      return this[1];
+    }
+    set y(value) {
+      this[1] = checkNumber(value);
+    }
+    len() {
+      return Math.sqrt(this.lengthSquared());
+    }
+    magnitude() {
+      return this.len();
+    }
+    lengthSquared() {
+      let length2 = 0;
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        length2 += this[i2] * this[i2];
+      }
+      return length2;
+    }
+    magnitudeSquared() {
+      return this.lengthSquared();
+    }
+    distance(mathArray) {
+      return Math.sqrt(this.distanceSquared(mathArray));
+    }
+    distanceSquared(mathArray) {
+      let length2 = 0;
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        const dist = this[i2] - mathArray[i2];
+        length2 += dist * dist;
+      }
+      return checkNumber(length2);
+    }
+    dot(mathArray) {
+      let product = 0;
+      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+        product += this[i2] * mathArray[i2];
+      }
+      return checkNumber(product);
+    }
+    normalize() {
+      const length2 = this.magnitude();
+      if (length2 !== 0) {
+        for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+          this[i2] /= length2;
+        }
+      }
+      return this.check();
+    }
+    multiply(...vectors) {
+      for (const vector of vectors) {
+        for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+          this[i2] *= vector[i2];
+        }
+      }
+      return this.check();
+    }
+    divide(...vectors) {
+      for (const vector of vectors) {
+        for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+          this[i2] /= vector[i2];
+        }
+      }
+      return this.check();
+    }
+    lengthSq() {
+      return this.lengthSquared();
+    }
+    distanceTo(vector) {
+      return this.distance(vector);
+    }
+    distanceToSquared(vector) {
+      return this.distanceSquared(vector);
+    }
+    getComponent(i2) {
+      assert4(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
+      return checkNumber(this[i2]);
+    }
+    setComponent(i2, value) {
+      assert4(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
+      this[i2] = value;
+      return this.check();
+    }
+    addVectors(a2, b) {
+      return this.copy(a2).add(b);
+    }
+    subVectors(a2, b) {
+      return this.copy(a2).subtract(b);
+    }
+    multiplyVectors(a2, b) {
+      return this.copy(a2).multiply(b);
+    }
+    addScaledVector(a2, b) {
+      return this.add(new this.constructor(a2).multiplyScalar(b));
+    }
+  };
 
   // ../../node_modules/gl-matrix/esm/common.js
   var EPSILON = 1e-6;
@@ -2459,6 +2896,14 @@
     out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;
     return out;
   }
+  function vec3_transformMat2(out, a2, m) {
+    const x = a2[0];
+    const y = a2[1];
+    out[0] = m[0] * x + m[2] * y;
+    out[1] = m[1] * x + m[3] * y;
+    out[2] = a2[2];
+    return out;
+  }
 
   // ../../node_modules/gl-matrix/esm/vec3.js
   function create2() {
@@ -2470,6 +2915,23 @@
     }
     return out;
   }
+  function length(a2) {
+    var x = a2[0];
+    var y = a2[1];
+    var z = a2[2];
+    return Math.hypot(x, y, z);
+  }
+  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];
+    out[0] = ay * bz - az * by;
+    out[1] = az * bx - ax * bz;
+    out[2] = ax * by - ay * bx;
+    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];
@@ -2479,6 +2941,73 @@
     out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
     return out;
   }
+  function transformMat3(out, a2, m) {
+    var x = a2[0], y = a2[1], 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;
+    uvx *= w2;
+    uvy *= w2;
+    uvz *= w2;
+    uuvx *= 2;
+    uuvy *= 2;
+    uuvz *= 2;
+    out[0] = x + uvx + uuvx;
+    out[1] = y + uvy + uuvy;
+    out[2] = z + uvz + uuvz;
+    return out;
+  }
+  function rotateX(out, a2, b, rad) {
+    var p2 = [], r2 = [];
+    p2[0] = a2[0] - b[0];
+    p2[1] = a2[1] - b[1];
+    p2[2] = a2[2] - b[2];
+    r2[0] = p2[0];
+    r2[1] = p2[1] * Math.cos(rad) - p2[2] * Math.sin(rad);
+    r2[2] = p2[1] * Math.sin(rad) + p2[2] * Math.cos(rad);
+    out[0] = r2[0] + b[0];
+    out[1] = r2[1] + b[1];
+    out[2] = r2[2] + b[2];
+    return out;
+  }
+  function rotateY(out, a2, b, rad) {
+    var p2 = [], r2 = [];
+    p2[0] = a2[0] - b[0];
+    p2[1] = a2[1] - b[1];
+    p2[2] = a2[2] - b[2];
+    r2[0] = p2[2] * Math.sin(rad) + p2[0] * Math.cos(rad);
+    r2[1] = p2[1];
+    r2[2] = p2[2] * Math.cos(rad) - p2[0] * Math.sin(rad);
+    out[0] = r2[0] + b[0];
+    out[1] = r2[1] + b[1];
+    out[2] = r2[2] + b[2];
+    return out;
+  }
+  function rotateZ(out, a2, b, rad) {
+    var p2 = [], r2 = [];
+    p2[0] = a2[0] - b[0];
+    p2[1] = a2[1] - b[1];
+    p2[2] = a2[2] - b[2];
+    r2[0] = p2[0] * Math.cos(rad) - p2[1] * Math.sin(rad);
+    r2[1] = p2[0] * Math.sin(rad) + p2[1] * Math.cos(rad);
+    r2[2] = p2[2];
+    out[0] = r2[0] + b[0];
+    out[1] = r2[1] + b[1];
+    out[2] = r2[2] + b[2];
+    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;
+    return Math.acos(Math.min(Math.max(cosine, -1), 1));
+  }
   var forEach3 = function() {
     var vec = create2();
     return function(a2, stride, offset, count, fn, arg) {
@@ -2507,16 +3036,125 @@
     };
   }();
 
-  // ../../node_modules/@math.gl/core/dist/esm/classes/base/matrix.js
-  var Matrix = class extends MathArray {
+  // ../../node_modules/@math.gl/core/dist/esm/classes/vector3.js
+  var ORIGIN = [0, 0, 0];
+  var ZERO;
+  var Vector3 = class extends Vector {
+    static get ZERO() {
+      if (!ZERO) {
+        ZERO = new Vector3(0, 0, 0);
+        Object.freeze(ZERO);
+      }
+      return ZERO;
+    }
+    constructor(x = 0, y = 0, z = 0) {
+      super(-0, -0, -0);
+      if (arguments.length === 1 && isArray(x)) {
+        this.copy(x);
+      } else {
+        if (config.debug) {
+          checkNumber(x);
+          checkNumber(y);
+          checkNumber(z);
+        }
+        this[0] = x;
+        this[1] = y;
+        this[2] = z;
+      }
+    }
+    set(x, y, z) {
+      this[0] = x;
+      this[1] = y;
+      this[2] = z;
+      return this.check();
+    }
+    copy(array) {
+      this[0] = array[0];
+      this[1] = array[1];
+      this[2] = array[2];
+      return this.check();
+    }
+    fromObject(object) {
+      if (config.debug) {
+        checkNumber(object.x);
+        checkNumber(object.y);
+        checkNumber(object.z);
+      }
+      this[0] = object.x;
+      this[1] = object.y;
+      this[2] = object.z;
+      return this.check();
+    }
+    toObject(object) {
+      object.x = this[0];
+      object.y = this[1];
+      object.z = this[2];
+      return object;
+    }
     get ELEMENTS() {
-      assert4(false);
-      return 0;
+      return 3;
     }
-    get RANK() {
-      assert4(false);
-      return 0;
+    get z() {
+      return this[2];
+    }
+    set z(value) {
+      this[2] = checkNumber(value);
     }
+    angle(vector) {
+      return angle(this, vector);
+    }
+    cross(vector) {
+      cross(this, this, vector);
+      return this.check();
+    }
+    rotateX({
+      radians: radians2,
+      origin = ORIGIN
+    }) {
+      rotateX(this, this, origin, radians2);
+      return this.check();
+    }
+    rotateY({
+      radians: radians2,
+      origin = ORIGIN
+    }) {
+      rotateY(this, this, origin, radians2);
+      return this.check();
+    }
+    rotateZ({
+      radians: radians2,
+      origin = ORIGIN
+    }) {
+      rotateZ(this, this, origin, radians2);
+      return this.check();
+    }
+    transform(matrix4) {
+      return this.transformAsPoint(matrix4);
+    }
+    transformAsPoint(matrix4) {
+      transformMat42(this, this, matrix4);
+      return this.check();
+    }
+    transformAsVector(matrix4) {
+      vec3_transformMat4AsVector(this, this, matrix4);
+      return this.check();
+    }
+    transformByMatrix3(matrix3) {
+      transformMat3(this, this, matrix3);
+      return this.check();
+    }
+    transformByMatrix2(matrix2) {
+      vec3_transformMat2(this, this, matrix2);
+      return this.check();
+    }
+    transformByQuaternion(quaternion) {
+      transformQuat(this, this, quaternion);
+      return this.check();
+    }
+  };
+
+  // ../../node_modules/@math.gl/core/dist/esm/classes/base/matrix.js
+  var Matrix = class extends MathArray {
     toString() {
       let string = "[";
       if (config.printRowMajor) {
@@ -2836,7 +3474,7 @@
     }
     return out;
   }
-  function rotateX(out, a2, rad) {
+  function rotateX2(out, a2, rad) {
     var s2 = Math.sin(rad);
     var c2 = Math.cos(rad);
     var a10 = a2[4];
@@ -2867,7 +3505,7 @@
     out[11] = a23 * c2 - a13 * s2;
     return out;
   }
-  function rotateY(out, a2, rad) {
+  function rotateY2(out, a2, rad) {
     var s2 = Math.sin(rad);
     var c2 = Math.cos(rad);
     var a00 = a2[0];
@@ -2898,7 +3536,7 @@
     out[11] = a03 * s2 + a23 * c2;
     return out;
   }
-  function rotateZ(out, a2, rad) {
+  function rotateZ2(out, a2, rad) {
     var s2 = Math.sin(rad);
     var c2 = Math.cos(rad);
     var a00 = a2[0];
@@ -2983,7 +3621,7 @@
     out[15] = 0;
     return out;
   }
-  function perspective(out, fovy, aspect, near, far) {
+  function perspectiveNO(out, fovy, aspect, near, far) {
     var f2 = 1 / Math.tan(fovy / 2), nf;
     out[0] = f2 / aspect;
     out[1] = 0;
@@ -3009,7 +3647,8 @@
     }
     return out;
   }
-  function ortho(out, left, right, bottom, top, near, far) {
+  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);
@@ -3031,6 +3670,7 @@
     out[15] = 1;
     return out;
   }
+  var ortho = orthoNO;
   function lookAt(out, eye, center, up) {
     var x0, x1, x2, y0, y1, y2, z0, z1, z2, len;
     var eyex = eye[0];
@@ -3149,38 +3789,36 @@
   }();
 
   // ../../node_modules/@math.gl/core/dist/esm/classes/matrix4.js
-  var IDENTITY = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-  var ZERO = Object.freeze([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
-  var INDICES = Object.freeze({
-    COL0ROW0: 0,
-    COL0ROW1: 1,
-    COL0ROW2: 2,
-    COL0ROW3: 3,
-    COL1ROW0: 4,
-    COL1ROW1: 5,
-    COL1ROW2: 6,
-    COL1ROW3: 7,
-    COL2ROW0: 8,
-    COL2ROW1: 9,
-    COL2ROW2: 10,
-    COL2ROW3: 11,
-    COL3ROW0: 12,
-    COL3ROW1: 13,
-    COL3ROW2: 14,
-    COL3ROW3: 15
-  });
-  var constants = {};
+  var INDICES;
+  (function(INDICES2) {
+    INDICES2[INDICES2["COL0ROW0"] = 0] = "COL0ROW0";
+    INDICES2[INDICES2["COL0ROW1"] = 1] = "COL0ROW1";
+    INDICES2[INDICES2["COL0ROW2"] = 2] = "COL0ROW2";
+    INDICES2[INDICES2["COL0ROW3"] = 3] = "COL0ROW3";
+    INDICES2[INDICES2["COL1ROW0"] = 4] = "COL1ROW0";
+    INDICES2[INDICES2["COL1ROW1"] = 5] = "COL1ROW1";
+    INDICES2[INDICES2["COL1ROW2"] = 6] = "COL1ROW2";
+    INDICES2[INDICES2["COL1ROW3"] = 7] = "COL1ROW3";
+    INDICES2[INDICES2["COL2ROW0"] = 8] = "COL2ROW0";
+    INDICES2[INDICES2["COL2ROW1"] = 9] = "COL2ROW1";
+    INDICES2[INDICES2["COL2ROW2"] = 10] = "COL2ROW2";
+    INDICES2[INDICES2["COL2ROW3"] = 11] = "COL2ROW3";
+    INDICES2[INDICES2["COL3ROW0"] = 12] = "COL3ROW0";
+    INDICES2[INDICES2["COL3ROW1"] = 13] = "COL3ROW1";
+    INDICES2[INDICES2["COL3ROW2"] = 14] = "COL3ROW2";
+    INDICES2[INDICES2["COL3ROW3"] = 15] = "COL3ROW3";
+  })(INDICES || (INDICES = {}));
+  var DEFAULT_FOVY = 45 * Math.PI / 180;
+  var DEFAULT_ASPECT = 1;
+  var DEFAULT_NEAR = 0.1;
+  var DEFAULT_FAR = 500;
+  var IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
   var Matrix4 = class extends Matrix {
     static get IDENTITY() {
-      constants.IDENTITY = constants.IDENTITY || Object.freeze(new Matrix4(IDENTITY));
-      return constants.IDENTITY;
+      return getIdentityMatrix();
     }
     static get ZERO() {
-      constants.ZERO = constants.ZERO || Object.freeze(new Matrix4(ZERO));
-      return constants.ZERO;
-    }
-    get INDICES() {
-      return INDICES;
+      return getZeroMatrix();
     }
     get ELEMENTS() {
       return 16;
@@ -3188,6 +3826,9 @@
     get RANK() {
       return 4;
     }
+    get INDICES() {
+      return INDICES;
+    }
     constructor(array) {
       super(-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0);
       if (arguments.length === 1 && Array.isArray(array)) {
@@ -3273,91 +3914,65 @@
       return result;
     }
     identity() {
-      return this.copy(IDENTITY);
+      return this.copy(IDENTITY_MATRIX);
     }
-    fromQuaternion(q) {
-      fromQuat(this, q);
+    fromObject(object) {
       return this.check();
     }
-    frustum({
-      left,
-      right,
-      bottom,
-      top,
-      near,
-      far
-    }) {
+    fromQuaternion(quaternion) {
+      fromQuat(this, quaternion);
+      return this.check();
+    }
+    frustum(view) {
+      const {
+        left,
+        right,
+        bottom,
+        top,
+        near = DEFAULT_NEAR,
+        far = DEFAULT_FAR
+      } = view;
       if (far === Infinity) {
-        Matrix4._computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
+        computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
       } else {
         frustum(this, left, right, bottom, top, near, far);
       }
       return this.check();
     }
-    static _computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) {
-      const column0Row0 = 2 * near / (right - left);
-      const column1Row1 = 2 * near / (top - bottom);
-      const column2Row0 = (right + left) / (right - left);
-      const column2Row1 = (top + bottom) / (top - bottom);
-      const column2Row2 = -1;
-      const column2Row3 = -1;
-      const column3Row2 = -2 * near;
-      result[0] = column0Row0;
-      result[1] = 0;
-      result[2] = 0;
-      result[3] = 0;
-      result[4] = 0;
-      result[5] = column1Row1;
-      result[6] = 0;
-      result[7] = 0;
-      result[8] = column2Row0;
-      result[9] = column2Row1;
-      result[10] = column2Row2;
-      result[11] = column2Row3;
-      result[12] = 0;
-      result[13] = 0;
-      result[14] = column3Row2;
-      result[15] = 0;
-      return result;
-    }
-    lookAt(eye, center, up) {
-      if (arguments.length === 1) {
-        ({
-          eye,
-          center,
-          up
-        } = eye);
-      }
-      center = center || [0, 0, 0];
-      up = up || [0, 1, 0];
+    lookAt(view) {
+      const {
+        eye,
+        center = [0, 0, 0],
+        up = [0, 1, 0]
+      } = view;
       lookAt(this, eye, center, up);
       return this.check();
     }
-    ortho({
-      left,
-      right,
-      bottom,
-      top,
-      near = 0.1,
-      far = 500
-    }) {
+    ortho(view) {
+      const {
+        left,
+        right,
+        bottom,
+        top,
+        near = DEFAULT_NEAR,
+        far = DEFAULT_FAR
+      } = view;
       ortho(this, left, right, bottom, top, near, far);
       return this.check();
     }
-    orthographic({
-      fovy = 45 * Math.PI / 180,
-      aspect = 1,
-      focalDistance = 1,
-      near = 0.1,
-      far = 500
-    }) {
-      if (fovy > Math.PI * 2) {
-        throw Error("radians");
-      }
+    orthographic(view) {
+      const {
+        fovy = DEFAULT_FOVY,
+        aspect = DEFAULT_ASPECT,
+        focalDistance = 1,
+        near = DEFAULT_NEAR,
+        far = DEFAULT_FAR
+      } = view;
+      checkRadians(fovy);
       const halfY = fovy / 2;
       const top = focalDistance * Math.tan(halfY);
       const right = top * aspect;
-      return new Matrix4().ortho({
+      return this.ortho({
         left: -right,
         right,
         bottom: -top,
@@ -3366,17 +3981,14 @@
         far
       });
     }
-    perspective({
-      fovy = void 0,
-      fov = 45 * Math.PI / 180,
-      aspect = 1,
-      near = 0.1,
-      far = 500
-    } = {}) {
-      fovy = fovy || fov;
-      if (fovy > Math.PI * 2) {
-        throw Error("radians");
-      }
+    perspective(view) {
+      const {
+        fovy = 45 * Math.PI / 180,
+        aspect = 1,
+        near = 0.1,
+        far = 500
+      } = view;
+      checkRadians(fovy);
       perspective(this, fovy, aspect, near, far);
       return this.check();
     }
@@ -3395,8 +4007,10 @@
       result[2] = this[14];
       return result;
     }
-    getRotation(result = [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0], scaleResult = null) {
-      const scale2 = this.getScale(scaleResult || [-0, -0, -0]);
+    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];
@@ -3418,8 +4032,10 @@
       result[15] = 1;
       return result;
     }
-    getRotationMatrix3(result = [-0, -0, -0, -0, -0, -0, -0, -0, -0], scaleResult = null) {
-      const scale2 = this.getScale(scaleResult || [-0, -0, -0]);
+    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];
@@ -3450,35 +4066,31 @@
       multiply(this, this, a2);
       return this.check();
     }
-    rotateX(radians) {
-      rotateX(this, this, radians);
+    rotateX(radians2) {
+      rotateX2(this, this, radians2);
       return this.check();
     }
-    rotateY(radians) {
-      rotateY(this, this, radians);
+    rotateY(radians2) {
+      rotateY2(this, this, radians2);
       return this.check();
     }
-    rotateZ(radians) {
-      rotateZ(this, this, radians);
+    rotateZ(radians2) {
+      rotateZ2(this, this, radians2);
       return this.check();
     }
-    rotateXYZ([rx, ry, rz]) {
-      return this.rotateX(rx).rotateY(ry).rotateZ(rz);
+    rotateXYZ(angleXYZ) {
+      return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]);
     }
-    rotateAxis(radians, axis) {
-      rotate(this, this, radians, axis);
+    rotateAxis(radians2, axis) {
+      rotate(this, this, radians2, axis);
       return this.check();
     }
     scale(factor) {
-      if (Array.isArray(factor)) {
-        scale(this, this, factor);
-      } else {
-        scale(this, this, [factor, factor, factor]);
-      }
+      scale(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
       return this.check();
     }
-    translate(vec) {
-      translate(this, this, vec);
+    translate(vector) {
+      translate(this, this, vector);
       return this.check();
     }
     transform(vector, result) {
@@ -3491,68 +4103,486 @@
     }
     transformAsPoint(vector, result) {
       const {
-        length
+        length: length2
       } = vector;
-      switch (length) {
+      let out;
+      switch (length2) {
         case 2:
-          result = transformMat4(result || [-0, -0], vector, this);
+          out = transformMat4(result || [-0, -0], vector, this);
           break;
         case 3:
-          result = transformMat42(result || [-0, -0, -0], vector, this);
+          out = transformMat42(result || [-0, -0, -0], vector, this);
           break;
         default:
           throw new Error("Illegal vector");
       }
-      checkVector(result, vector.length);
-      return result;
+      checkVector(out, vector.length);
+      return out;
     }
     transformAsVector(vector, result) {
+      let out;
       switch (vector.length) {
         case 2:
-          result = vec2_transformMat4AsVector(result || [-0, -0], vector, this);
+          out = vec2_transformMat4AsVector(result || [-0, -0], vector, this);
           break;
         case 3:
-          result = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this);
+          out = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this);
           break;
         default:
           throw new Error("Illegal vector");
       }
-      checkVector(result, vector.length);
-      return result;
-    }
-    makeRotationX(radians) {
-      return this.identity().rotateX(radians);
-    }
-    makeTranslation(x, y, z) {
-      return this.identity().translate([x, y, z]);
+      checkVector(out, vector.length);
+      return out;
     }
     transformPoint(vector, result) {
-      deprecated("Matrix4.transformPoint", "3.0");
       return this.transformAsPoint(vector, result);
     }
     transformVector(vector, result) {
-      deprecated("Matrix4.transformVector", "3.0");
       return this.transformAsPoint(vector, result);
     }
     transformDirection(vector, result) {
-      deprecated("Matrix4.transformDirection", "3.0");
       return this.transformAsVector(vector, result);
     }
+    makeRotationX(radians2) {
+      return this.identity().rotateX(radians2);
+    }
+    makeTranslation(x, y, z) {
+      return this.identity().translate([x, y, z]);
+    }
   };
+  var ZERO2;
+  var IDENTITY;
+  function getZeroMatrix() {
+    if (!ZERO2) {
+      ZERO2 = new Matrix4([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+      Object.freeze(ZERO2);
+    }
+    return ZERO2;
+  }
+  function getIdentityMatrix() {
+    if (!IDENTITY) {
+      IDENTITY = new Matrix4();
+      Object.freeze(IDENTITY);
+    }
+    return IDENTITY;
+  }
+  function checkRadians(possiblyDegrees) {
+    if (possiblyDegrees > Math.PI * 2) {
+      throw Error("expected radians");
+    }
+  }
+  function computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) {
+    const column0Row0 = 2 * near / (right - left);
+    const column1Row1 = 2 * near / (top - bottom);
+    const column2Row0 = (right + left) / (right - left);
+    const column2Row1 = (top + bottom) / (top - bottom);
+    const column2Row2 = -1;
+    const column2Row3 = -1;
+    const column3Row2 = -2 * near;
+    result[0] = column0Row0;
+    result[1] = 0;
+    result[2] = 0;
+    result[3] = 0;
+    result[4] = 0;
+    result[5] = column1Row1;
+    result[6] = 0;
+    result[7] = 0;
+    result[8] = column2Row0;
+    result[9] = column2Row1;
+    result[10] = column2Row2;
+    result[11] = column2Row3;
+    result[12] = 0;
+    result[13] = 0;
+    result[14] = column3Row2;
+    result[15] = 0;
+    return result;
+  }
 
-  // ../../node_modules/@math.gl/core/dist/esm/index.js
-  var globals4 = {
-    self: typeof self !== "undefined" && self,
-    window: typeof window !== "undefined" && window,
-    global: typeof global !== "undefined" && global
+  // ../../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
   };
-  var global_4 = globals4.global || globals4.self || globals4.window;
-  global_4.mathgl = {
-    config
+
+  // ../../node_modules/@math.gl/geospatial/dist/esm/constants.js
+  var WGS84_RADIUS_X = 6378137;
+  var WGS84_RADIUS_Y = 6378137;
+  var WGS84_RADIUS_Z = 6356752314245179e-9;
+  var WGS84_CONSTANTS = {
+    radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],
+    radiiSquared: [WGS84_RADIUS_X * WGS84_RADIUS_X, WGS84_RADIUS_Y * WGS84_RADIUS_Y, WGS84_RADIUS_Z * WGS84_RADIUS_Z],
+    oneOverRadii: [1 / WGS84_RADIUS_X, 1 / WGS84_RADIUS_Y, 1 / WGS84_RADIUS_Z],
+    oneOverRadiiSquared: [1 / (WGS84_RADIUS_X * WGS84_RADIUS_X), 1 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y), 1 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)],
+    maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),
+    centerToleranceSquared: 0.1
   };
 
+  // ../../node_modules/@math.gl/geospatial/dist/esm/type-utils.js
+  function identity2(x) {
+    return x;
+  }
+  var scratchVector = new Vector3();
+  function fromCartographic(cartographic, result = [], map2 = identity2) {
+    if ("longitude" in cartographic) {
+      result[0] = map2(cartographic.longitude);
+      result[1] = map2(cartographic.latitude);
+      result[2] = cartographic.height;
+    } else if ("x" in cartographic) {
+      result[0] = map2(cartographic.x);
+      result[1] = map2(cartographic.y);
+      result[2] = cartographic.z;
+    } else {
+      result[0] = map2(cartographic[0]);
+      result[1] = map2(cartographic[1]);
+      result[2] = cartographic[2];
+    }
+    return result;
+  }
+  function fromCartographicToRadians(cartographic, vector = []) {
+    return fromCartographic(cartographic, vector, config._cartographicRadians ? identity2 : toRadians);
+  }
+  function toCartographic(vector, cartographic, map2 = identity2) {
+    if ("longitude" in cartographic) {
+      cartographic.longitude = map2(vector[0]);
+      cartographic.latitude = map2(vector[1]);
+      cartographic.height = vector[2];
+    } else if ("x" in cartographic) {
+      cartographic.x = map2(vector[0]);
+      cartographic.y = map2(vector[1]);
+      cartographic.z = vector[2];
+    } else {
+      cartographic[0] = map2(vector[0]);
+      cartographic[1] = map2(vector[1]);
+      cartographic[2] = vector[2];
+    }
+    return cartographic;
+  }
+  function toCartographicFromRadians(vector, cartographic) {
+    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;
+  var scratchOrigin = new Vector3();
+  var VECTOR_PRODUCT_LOCAL_FRAME = {
+    up: {
+      south: "east",
+      north: "west",
+      west: "south",
+      east: "north"
+    },
+    down: {
+      south: "west",
+      north: "east",
+      west: "north",
+      east: "south"
+    },
+    south: {
+      up: "west",
+      down: "east",
+      west: "down",
+      east: "up"
+    },
+    north: {
+      up: "east",
+      down: "west",
+      west: "up",
+      east: "down"
+    },
+    west: {
+      up: "north",
+      down: "south",
+      north: "down",
+      south: "up"
+    },
+    east: {
+      up: "south",
+      down: "north",
+      north: "up",
+      south: "down"
+    }
+  };
+  var degeneratePositionLocalFrame = {
+    north: [-1, 0, 0],
+    east: [0, 1, 0],
+    up: [0, 0, 1],
+    south: [1, 0, 0],
+    west: [0, -1, 0],
+    down: [0, 0, -1]
+  };
+  var scratchAxisVectors = {
+    east: new Vector3(),
+    north: new Vector3(),
+    up: new Vector3(),
+    west: new Vector3(),
+    south: new Vector3(),
+    down: new Vector3()
+  };
+  var scratchVector1 = new Vector3();
+  var scratchVector22 = 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];
+    assert4(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
+    let firstAxisVector;
+    let secondAxisVector;
+    let thirdAxisVector;
+    const origin = scratchOrigin.copy(cartesianOrigin);
+    const atPole = equals(origin.x, 0, EPSILON14) && equals(origin.y, 0, EPSILON14);
+    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]);
+      if (secondAxis !== "east" && secondAxis !== "west") {
+        secondAxisVector.scale(sign);
+      }
+      thirdAxisVector = scratchVector3.fromArray(degeneratePositionLocalFrame[thirdAxis]);
+      if (thirdAxis !== "east" && thirdAxis !== "west") {
+        thirdAxisVector.scale(sign);
+      }
+    } else {
+      const {
+        up,
+        east,
+        north
+      } = scratchAxisVectors;
+      east.set(-origin.y, origin.x, 0).normalize();
+      ellipsoid.geodeticSurfaceNormal(origin, up);
+      north.copy(up).cross(east);
+      const {
+        down,
+        west,
+        south
+      } = scratchAxisVectors;
+      down.copy(up).scale(-1);
+      west.copy(east).scale(-1);
+      south.copy(north).scale(-1);
+      firstAxisVector = scratchAxisVectors[firstAxis];
+      secondAxisVector = scratchAxisVectors[secondAxis];
+      thirdAxisVector = scratchAxisVectors[thirdAxis];
+    }
+    result[0] = firstAxisVector.x;
+    result[1] = firstAxisVector.y;
+    result[2] = firstAxisVector.z;
+    result[3] = 0;
+    result[4] = secondAxisVector.x;
+    result[5] = secondAxisVector.y;
+    result[6] = secondAxisVector.z;
+    result[7] = 0;
+    result[8] = thirdAxisVector.x;
+    result[9] = thirdAxisVector.y;
+    result[10] = thirdAxisVector.z;
+    result[11] = 0;
+    result[12] = origin.x;
+    result[13] = origin.y;
+    result[14] = origin.z;
+    result[15] = 1;
+    return result;
+  }
+
+  // ../../node_modules/@math.gl/geospatial/dist/esm/ellipsoid/ellipsoid.js
+  var scratchVector4 = new Vector3();
+  var scratchNormal = new Vector3();
+  var scratchK = new Vector3();
+  var scratchPosition = new Vector3();
+  var scratchHeight = new Vector3();
+  var scratchCartesian = new Vector3();
+  var Ellipsoid = class {
+    constructor(x = 0, y = 0, z = 0) {
+      _defineProperty(this, "radii", void 0);
+      _defineProperty(this, "radiiSquared", void 0);
+      _defineProperty(this, "radiiToTheFourth", void 0);
+      _defineProperty(this, "oneOverRadii", void 0);
+      _defineProperty(this, "oneOverRadiiSquared", void 0);
+      _defineProperty(this, "minimumRadius", void 0);
+      _defineProperty(this, "maximumRadius", void 0);
+      _defineProperty(this, "centerToleranceSquared", math_utils_default.EPSILON1);
+      _defineProperty(this, "squaredXOverSquaredZ", void 0);
+      assert4(x >= 0);
+      assert4(y >= 0);
+      assert4(z >= 0);
+      this.radii = new Vector3(x, y, z);
+      this.radiiSquared = new Vector3(x * x, y * y, z * z);
+      this.radiiToTheFourth = new Vector3(x * x * x * x, y * y * y * y, z * z * z * z);
+      this.oneOverRadii = new Vector3(x === 0 ? 0 : 1 / x, y === 0 ? 0 : 1 / y, z === 0 ? 0 : 1 / z);
+      this.oneOverRadiiSquared = new Vector3(x === 0 ? 0 : 1 / (x * x), y === 0 ? 0 : 1 / (y * y), z === 0 ? 0 : 1 / (z * z));
+      this.minimumRadius = Math.min(x, y, z);
+      this.maximumRadius = Math.max(x, y, z);
+      if (this.radiiSquared.z !== 0) {
+        this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;
+      }
+      Object.freeze(this);
+    }
+    equals(right) {
+      return this === right || Boolean(right && this.radii.equals(right.radii));
+    }
+    toString() {
+      return this.radii.toString();
+    }
+    cartographicToCartesian(cartographic, result = [0, 0, 0]) {
+      const normal = scratchNormal;
+      const k = scratchK;
+      const [, , height] = cartographic;
+      this.geodeticSurfaceNormalCartographic(cartographic, normal);
+      k.copy(this.radiiSquared).scale(normal);
+      const gamma = Math.sqrt(normal.dot(k));
+      k.scale(1 / gamma);
+      normal.scale(height);
+      k.add(normal);
+      return k.to(result);
+    }
+    cartesianToCartographic(cartesian, result = [0, 0, 0]) {
+      scratchCartesian.from(cartesian);
+      const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);
+      if (!point) {
+        return void 0;
+      }
+      const normal = this.geodeticSurfaceNormal(point, scratchNormal);
+      const h = scratchHeight;
+      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);
+      return toCartographicFromRadians([longitude, latitude, height], result);
+    }
+    eastNorthUpToFixedFrame(origin, result = new Matrix4()) {
+      return localFrameToFixedFrame(this, "east", "north", "up", origin, result);
+    }
+    localFrameToFixedFrame(firstAxis, secondAxis, thirdAxis, origin, result = new Matrix4()) {
+      return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);
+    }
+    geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {
+      return scratchVector4.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);
+    }
+    geodeticSurfaceNormal(cartesian, result = [0, 0, 0]) {
+      return scratchVector4.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);
+    }
+    scaleToGeodeticSurface(cartesian, result) {
+      return scaleToGeodeticSurface(cartesian, this, result);
+    }
+    scaleToGeocentricSurface(cartesian, result = [0, 0, 0]) {
+      scratchPosition.from(cartesian);
+      const positionX = scratchPosition.x;
+      const positionY = scratchPosition.y;
+      const positionZ = scratchPosition.z;
+      const oneOverRadiiSquared = this.oneOverRadiiSquared;
+      const beta = 1 / Math.sqrt(positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z);
+      return scratchPosition.multiplyScalar(beta).to(result);
+    }
+    transformPositionToScaledSpace(position, result = [0, 0, 0]) {
+      return scratchPosition.from(position).scale(this.oneOverRadii).to(result);
+    }
+    transformPositionFromScaledSpace(position, result = [0, 0, 0]) {
+      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(this.radii.z > 0);
+      scratchPosition.from(position);
+      const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);
+      if (Math.abs(z) >= this.radii.z - buffer) {
+        return void 0;
+      }
+      return scratchPosition.set(0, 0, z).to(result);
+    }
+  };
+  _defineProperty(Ellipsoid, "WGS84", new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z));
+
   // ../images/src/lib/utils/version.ts
-  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION4 = true ? "4.0.0-alpha.11" : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var { _parseImageNode } = globalThis;
@@ -3676,9 +4706,9 @@
       await image.decode();
       return image;
     }
-    return await new Promise((resolve, reject) => {
+    return await new Promise((resolve2, reject) => {
       try {
-        image.onload = () => resolve(image);
+        image.onload = () => resolve2(image);
         image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));
       } catch (error) {
         reject(error);
@@ -3721,12 +4751,60 @@
     return true;
   }
 
+  // ../images/src/lib/category-api/parse-isobmff-binary.ts
+  function getISOBMFFMediaType(buffer) {
+    if (!checkString(buffer, "ftyp", 4)) {
+      return null;
+    }
+    if ((buffer[8] & 96) === 0) {
+      return null;
+    }
+    return decodeMajorBrand(buffer);
+  }
+  function decodeMajorBrand(buffer) {
+    const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim();
+    switch (brandMajor) {
+      case "avif":
+      case "avis":
+        return { extension: "avif", mimeType: "image/avif" };
+      default:
+        return null;
+    }
+  }
+  function getUTF8String(array, start, end) {
+    return String.fromCharCode(...array.slice(start, end));
+  }
+  function stringToBytes(string) {
+    return [...string].map((character) => character.charCodeAt(0));
+  }
+  function checkString(buffer, header, offset = 0) {
+    const headerBytes = stringToBytes(header);
+    for (let i2 = 0; i2 < headerBytes.length; ++i2) {
+      if (headerBytes[i2] !== buffer[i2 + offset]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   // ../images/src/lib/category-api/binary-image-api.ts
   var BIG_ENDIAN = false;
   var LITTLE_ENDIAN = true;
   function getBinaryImageMetadata(binaryData) {
     const dataView = toDataView(binaryData);
-    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView);
+    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView);
+  }
+  function getISOBMFFMetadata(binaryData) {
+    const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
+    const mediaType = getISOBMFFMediaType(buffer);
+    if (!mediaType) {
+      return null;
+    }
+    return {
+      mimeType: mediaType.mimeType,
+      width: 0,
+      height: 0
+    };
   }
   function getPngMetadata(binaryData) {
     const dataView = toDataView(binaryData);
@@ -3871,581 +4949,140 @@
   }
 
   // ../images/src/image-loader.ts
-  var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg"];
+  var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
   var MIME_TYPES = [
     "image/png",
     "image/jpeg",
     "image/gif",
     "image/webp",
+    "image/avif",
     "image/bmp",
     "image/vnd.microsoft.icon",
     "image/svg+xml"
   ];
-  var DEFAULT_IMAGE_LOADER_OPTIONS = {
-    image: {
-      type: "auto",
-      decode: true
-    }
-  };
-  var ImageLoader = {
-    id: "image",
-    module: "images",
-    name: "Images",
-    version: VERSION4,
-    mimeTypes: MIME_TYPES,
-    extensions: EXTENSIONS,
-    parse: parseImage,
-    tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
-    options: DEFAULT_IMAGE_LOADER_OPTIONS
-  };
-
-  // ../draco/src/lib/utils/version.ts
-  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-
-  // ../draco/src/draco-loader.ts
-  var DEFAULT_DRACO_OPTIONS = {
-    draco: {
-      decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
-      libraryPath: "libs/",
-      extraAttributes: {},
-      attributeNameEntry: void 0
-    }
-  };
-  var DracoLoader = {
-    name: "Draco",
-    id: "draco",
-    module: "draco",
-    shapes: ["mesh"],
-    version: VERSION5,
-    worker: true,
-    extensions: ["drc"],
-    mimeTypes: ["application/octet-stream"],
-    binary: true,
-    tests: ["DRACO"],
-    options: DEFAULT_DRACO_OPTIONS
-  };
-
-  // ../schema/src/category/mesh/mesh-utils.ts
-  function getMeshBoundingBox(attributes) {
-    let minX = Infinity;
-    let minY = Infinity;
-    let minZ = Infinity;
-    let maxX = -Infinity;
-    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 x = positions[i2];
-      const y = positions[i2 + 1];
-      const z = positions[i2 + 2];
-      minX = x < minX ? x : minX;
-      minY = y < minY ? y : minY;
-      minZ = z < minZ ? z : minZ;
-      maxX = x > maxX ? x : maxX;
-      maxY = y > maxY ? y : maxY;
-      maxZ = z > maxZ ? z : maxZ;
-    }
-    return [
-      [minX, minY, minZ],
-      [maxX, maxY, maxZ]
-    ];
-  }
-
-  // ../schema/src/lib/utils/assert.ts
-  function assert5(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loader assertion failed.");
-    }
-  }
-
-  // ../schema/src/lib/schema/impl/schema.ts
-  var Schema = class {
-    constructor(fields, metadata) {
-      assert5(Array.isArray(fields));
-      checkNames(fields);
-      this.fields = fields;
-      this.metadata = metadata || new Map();
-    }
-    compareTo(other) {
-      if (this.metadata !== other.metadata) {
-        return false;
-      }
-      if (this.fields.length !== other.fields.length) {
-        return false;
-      }
-      for (let i2 = 0; i2 < this.fields.length; ++i2) {
-        if (!this.fields[i2].compareTo(other.fields[i2])) {
-          return false;
-        }
-      }
-      return true;
-    }
-    select(...columnNames) {
-      const nameMap = Object.create(null);
-      for (const name of columnNames) {
-        nameMap[name] = true;
-      }
-      const selectedFields = this.fields.filter((field) => nameMap[field.name]);
-      return new Schema(selectedFields, this.metadata);
-    }
-    selectAt(...columnIndices) {
-      const selectedFields = columnIndices.map((index) => this.fields[index]).filter(Boolean);
-      return new Schema(selectedFields, this.metadata);
-    }
-    assign(schemaOrFields) {
-      let fields;
-      let metadata = this.metadata;
-      if (schemaOrFields instanceof Schema) {
-        const otherSchema = schemaOrFields;
-        fields = otherSchema.fields;
-        metadata = mergeMaps(mergeMaps(new Map(), this.metadata), otherSchema.metadata);
-      } else {
-        fields = schemaOrFields;
-      }
-      const fieldMap = Object.create(null);
-      for (const field of this.fields) {
-        fieldMap[field.name] = field;
-      }
-      for (const field of fields) {
-        fieldMap[field.name] = field;
-      }
-      const mergedFields = Object.values(fieldMap);
-      return new Schema(mergedFields, metadata);
-    }
-  };
-  function checkNames(fields) {
-    const usedNames = {};
-    for (const field of fields) {
-      if (usedNames[field.name]) {
-        console.warn("Schema: duplicated field name", field.name, field);
-      }
-      usedNames[field.name] = true;
-    }
-  }
-  function mergeMaps(m1, m2) {
-    return new Map([...m1 || new Map(), ...m2 || new Map()]);
-  }
-
-  // ../schema/src/lib/schema/impl/field.ts
-  var Field = class {
-    constructor(name, type, nullable = false, metadata = new Map()) {
-      this.name = name;
-      this.type = type;
-      this.nullable = nullable;
-      this.metadata = metadata;
-    }
-    get typeId() {
-      return this.type && this.type.typeId;
-    }
-    clone() {
-      return new Field(this.name, this.type, this.nullable, this.metadata);
-    }
-    compareTo(other) {
-      return this.name === other.name && this.type === other.type && this.nullable === other.nullable && this.metadata === other.metadata;
-    }
-    toString() {
-      return `${this.type}${this.nullable ? ", nullable" : ""}${this.metadata ? `, metadata: ${this.metadata}` : ""}`;
-    }
-  };
-
-  // ../schema/src/lib/schema/impl/enum.ts
-  var Type;
-  (function(Type2) {
-    Type2[Type2["NONE"] = 0] = "NONE";
-    Type2[Type2["Null"] = 1] = "Null";
-    Type2[Type2["Int"] = 2] = "Int";
-    Type2[Type2["Float"] = 3] = "Float";
-    Type2[Type2["Binary"] = 4] = "Binary";
-    Type2[Type2["Utf8"] = 5] = "Utf8";
-    Type2[Type2["Bool"] = 6] = "Bool";
-    Type2[Type2["Decimal"] = 7] = "Decimal";
-    Type2[Type2["Date"] = 8] = "Date";
-    Type2[Type2["Time"] = 9] = "Time";
-    Type2[Type2["Timestamp"] = 10] = "Timestamp";
-    Type2[Type2["Interval"] = 11] = "Interval";
-    Type2[Type2["List"] = 12] = "List";
-    Type2[Type2["Struct"] = 13] = "Struct";
-    Type2[Type2["Union"] = 14] = "Union";
-    Type2[Type2["FixedSizeBinary"] = 15] = "FixedSizeBinary";
-    Type2[Type2["FixedSizeList"] = 16] = "FixedSizeList";
-    Type2[Type2["Map"] = 17] = "Map";
-    Type2[Type2["Dictionary"] = -1] = "Dictionary";
-    Type2[Type2["Int8"] = -2] = "Int8";
-    Type2[Type2["Int16"] = -3] = "Int16";
-    Type2[Type2["Int32"] = -4] = "Int32";
-    Type2[Type2["Int64"] = -5] = "Int64";
-    Type2[Type2["Uint8"] = -6] = "Uint8";
-    Type2[Type2["Uint16"] = -7] = "Uint16";
-    Type2[Type2["Uint32"] = -8] = "Uint32";
-    Type2[Type2["Uint64"] = -9] = "Uint64";
-    Type2[Type2["Float16"] = -10] = "Float16";
-    Type2[Type2["Float32"] = -11] = "Float32";
-    Type2[Type2["Float64"] = -12] = "Float64";
-    Type2[Type2["DateDay"] = -13] = "DateDay";
-    Type2[Type2["DateMillisecond"] = -14] = "DateMillisecond";
-    Type2[Type2["TimestampSecond"] = -15] = "TimestampSecond";
-    Type2[Type2["TimestampMillisecond"] = -16] = "TimestampMillisecond";
-    Type2[Type2["TimestampMicrosecond"] = -17] = "TimestampMicrosecond";
-    Type2[Type2["TimestampNanosecond"] = -18] = "TimestampNanosecond";
-    Type2[Type2["TimeSecond"] = -19] = "TimeSecond";
-    Type2[Type2["TimeMillisecond"] = -20] = "TimeMillisecond";
-    Type2[Type2["TimeMicrosecond"] = -21] = "TimeMicrosecond";
-    Type2[Type2["TimeNanosecond"] = -22] = "TimeNanosecond";
-    Type2[Type2["DenseUnion"] = -23] = "DenseUnion";
-    Type2[Type2["SparseUnion"] = -24] = "SparseUnion";
-    Type2[Type2["IntervalDayTime"] = -25] = "IntervalDayTime";
-    Type2[Type2["IntervalYearMonth"] = -26] = "IntervalYearMonth";
-  })(Type || (Type = {}));
-
-  // ../schema/src/lib/schema/impl/type.ts
-  var DataType = class {
-    static isNull(x) {
-      return x && x.typeId === Type.Null;
-    }
-    static isInt(x) {
-      return x && x.typeId === Type.Int;
-    }
-    static isFloat(x) {
-      return x && x.typeId === Type.Float;
-    }
-    static isBinary(x) {
-      return x && x.typeId === Type.Binary;
-    }
-    static isUtf8(x) {
-      return x && x.typeId === Type.Utf8;
-    }
-    static isBool(x) {
-      return x && x.typeId === Type.Bool;
-    }
-    static isDecimal(x) {
-      return x && x.typeId === Type.Decimal;
-    }
-    static isDate(x) {
-      return x && x.typeId === Type.Date;
-    }
-    static isTime(x) {
-      return x && x.typeId === Type.Time;
-    }
-    static isTimestamp(x) {
-      return x && x.typeId === Type.Timestamp;
-    }
-    static isInterval(x) {
-      return x && x.typeId === Type.Interval;
-    }
-    static isList(x) {
-      return x && x.typeId === Type.List;
-    }
-    static isStruct(x) {
-      return x && x.typeId === Type.Struct;
-    }
-    static isUnion(x) {
-      return x && x.typeId === Type.Union;
-    }
-    static isFixedSizeBinary(x) {
-      return x && x.typeId === Type.FixedSizeBinary;
-    }
-    static isFixedSizeList(x) {
-      return x && x.typeId === Type.FixedSizeList;
-    }
-    static isMap(x) {
-      return x && x.typeId === Type.Map;
-    }
-    static isDictionary(x) {
-      return x && x.typeId === Type.Dictionary;
-    }
-    get typeId() {
-      return Type.NONE;
-    }
-    compareTo(other) {
-      return this === other;
-    }
-  };
-  var Null = class extends DataType {
-    get typeId() {
-      return Type.Null;
-    }
-    get [Symbol.toStringTag]() {
-      return "Null";
-    }
-    toString() {
-      return "Null";
-    }
-  };
-  var Bool = class extends DataType {
-    get typeId() {
-      return Type.Bool;
-    }
-    get [Symbol.toStringTag]() {
-      return "Bool";
-    }
-    toString() {
-      return "Bool";
-    }
-  };
-  var Int = class extends DataType {
-    constructor(isSigned, bitWidth) {
-      super();
-      this.isSigned = isSigned;
-      this.bitWidth = bitWidth;
-    }
-    get typeId() {
-      return Type.Int;
-    }
-    get [Symbol.toStringTag]() {
-      return "Int";
-    }
-    toString() {
-      return `${this.isSigned ? "I" : "Ui"}nt${this.bitWidth}`;
-    }
-  };
-  var Int8 = class extends Int {
-    constructor() {
-      super(true, 8);
-    }
-  };
-  var Int16 = class extends Int {
-    constructor() {
-      super(true, 16);
-    }
-  };
-  var Int32 = class extends Int {
-    constructor() {
-      super(true, 32);
-    }
-  };
-  var Uint8 = class extends Int {
-    constructor() {
-      super(false, 8);
-    }
-  };
-  var Uint16 = class extends Int {
-    constructor() {
-      super(false, 16);
-    }
-  };
-  var Uint32 = class extends Int {
-    constructor() {
-      super(false, 32);
-    }
-  };
-  var Precision = {
-    HALF: 16,
-    SINGLE: 32,
-    DOUBLE: 64
-  };
-  var Float = class extends DataType {
-    constructor(precision) {
-      super();
-      this.precision = precision;
-    }
-    get typeId() {
-      return Type.Float;
-    }
-    get [Symbol.toStringTag]() {
-      return "Float";
-    }
-    toString() {
-      return `Float${this.precision}`;
-    }
-  };
-  var Float32 = class extends Float {
-    constructor() {
-      super(Precision.SINGLE);
-    }
-  };
-  var Float64 = class extends Float {
-    constructor() {
-      super(Precision.DOUBLE);
-    }
-  };
-  var Binary = class extends DataType {
-    constructor() {
-      super();
-    }
-    get typeId() {
-      return Type.Binary;
-    }
-    toString() {
-      return "Binary";
-    }
-    get [Symbol.toStringTag]() {
-      return "Binary";
-    }
-  };
-  var Utf8 = class extends DataType {
-    get typeId() {
-      return Type.Utf8;
-    }
-    get [Symbol.toStringTag]() {
-      return "Utf8";
-    }
-    toString() {
-      return "Utf8";
-    }
-  };
-  var DateUnit = {
-    DAY: 0,
-    MILLISECOND: 1
-  };
-  var Date2 = class extends DataType {
-    constructor(unit) {
-      super();
-      this.unit = unit;
-    }
-    get typeId() {
-      return Type.Date;
-    }
-    get [Symbol.toStringTag]() {
-      return "Date";
-    }
-    toString() {
-      return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`;
-    }
-  };
-  var TimeUnit = {
-    SECOND: 1,
-    MILLISECOND: 1e3,
-    MICROSECOND: 1e6,
-    NANOSECOND: 1e9
-  };
-  var Time = class extends DataType {
-    constructor(unit, bitWidth) {
-      super();
-      this.unit = unit;
-      this.bitWidth = bitWidth;
-    }
-    get typeId() {
-      return Type.Time;
-    }
-    toString() {
-      return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`;
-    }
-    get [Symbol.toStringTag]() {
-      return "Time";
-    }
-  };
-  var Timestamp = class extends DataType {
-    constructor(unit, timezone = null) {
-      super();
-      this.unit = unit;
-      this.timezone = timezone;
-    }
-    get typeId() {
-      return Type.Timestamp;
-    }
-    get [Symbol.toStringTag]() {
-      return "Timestamp";
-    }
-    toString() {
-      return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ""}>`;
-    }
-  };
-  var IntervalUnit = {
-    DAY_TIME: 0,
-    YEAR_MONTH: 1
-  };
-  var Interval = class extends DataType {
-    constructor(unit) {
-      super();
-      this.unit = unit;
-    }
-    get typeId() {
-      return Type.Interval;
-    }
-    get [Symbol.toStringTag]() {
-      return "Interval";
-    }
-    toString() {
-      return `Interval<${IntervalUnit[this.unit]}>`;
+  var DEFAULT_IMAGE_LOADER_OPTIONS = {
+    image: {
+      type: "auto",
+      decode: true
     }
   };
-  var FixedSizeList = class extends DataType {
-    constructor(listSize, child) {
-      super();
-      this.listSize = listSize;
-      this.children = [child];
-    }
-    get typeId() {
-      return Type.FixedSizeList;
-    }
-    get valueType() {
-      return this.children[0].type;
-    }
-    get valueField() {
-      return this.children[0];
-    }
-    get [Symbol.toStringTag]() {
-      return "FixedSizeList";
-    }
-    toString() {
-      return `FixedSizeList[${this.listSize}]<${this.valueType}>`;
-    }
+  var ImageLoader = {
+    id: "image",
+    module: "images",
+    name: "Images",
+    version: VERSION4,
+    mimeTypes: MIME_TYPES,
+    extensions: EXTENSIONS,
+    parse: parseImage,
+    tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
+    options: DEFAULT_IMAGE_LOADER_OPTIONS
   };
-  var Struct = class extends DataType {
-    constructor(children) {
-      super();
-      this.children = children;
-    }
-    get typeId() {
-      return Type.Struct;
-    }
-    toString() {
-      return `Struct<{${this.children.map((f2) => `${f2.name}:${f2.type}`).join(", ")}}>`;
-    }
-    get [Symbol.toStringTag]() {
-      return "Struct";
+
+  // ../draco/src/lib/utils/version.ts
+  var VERSION5 = true ? "4.0.0-alpha.11" : "latest";
+
+  // ../draco/src/draco-loader.ts
+  var DEFAULT_DRACO_OPTIONS = {
+    draco: {
+      decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
+      libraryPath: "libs/",
+      extraAttributes: {},
+      attributeNameEntry: void 0
     }
   };
+  var DracoLoader = {
+    name: "Draco",
+    id: "draco",
+    module: "draco",
+    version: VERSION5,
+    worker: true,
+    extensions: ["drc"],
+    mimeTypes: ["application/octet-stream"],
+    binary: true,
+    tests: ["DRACO"],
+    options: DEFAULT_DRACO_OPTIONS
+  };
 
-  // ../schema/src/lib/arrow/arrow-like-type-utils.ts
-  function getArrowTypeFromTypedArray(array) {
+  // ../schema/src/lib/table/simple-table/data-type.ts
+  function getDataTypeFromTypedArray(array) {
     switch (array.constructor) {
       case Int8Array:
-        return new Int8();
+        return "int8";
       case Uint8Array:
-        return new Uint8();
+      case Uint8ClampedArray:
+        return "uint8";
       case Int16Array:
-        return new Int16();
+        return "int16";
       case Uint16Array:
-        return new Uint16();
+        return "uint16";
       case Int32Array:
-        return new Int32();
+        return "int32";
       case Uint32Array:
-        return new Uint32();
+        return "uint32";
       case Float32Array:
-        return new Float32();
+        return "float32";
       case Float64Array:
-        return new Float64();
+        return "float64";
       default:
-        throw new Error("array type not supported");
+        return "null";
+    }
+  }
+
+  // ../schema/src/lib/mesh/mesh-utils.ts
+  function getMeshBoundingBox(attributes) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    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 x = positions[i2];
+      const y = positions[i2 + 1];
+      const z = positions[i2 + 2];
+      minX = x < minX ? x : minX;
+      minY = y < minY ? y : minY;
+      minZ = z < minZ ? z : minZ;
+      maxX = x > maxX ? x : maxX;
+      maxY = y > maxY ? y : maxY;
+      maxZ = z > maxZ ? z : maxZ;
     }
+    return [
+      [minX, minY, minZ],
+      [maxX, maxY, maxZ]
+    ];
   }
 
-  // ../schema/src/category/mesh/deduce-mesh-schema.ts
-  function deduceMeshField(attributeName, attribute, optionalMetadata) {
-    const type = getArrowTypeFromTypedArray(attribute.value);
+  // ../schema/src/lib/mesh/deduce-mesh-schema.ts
+  function deduceMeshField(name, attribute, optionalMetadata) {
+    const type = getDataTypeFromTypedArray(attribute.value);
     const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
-    const field = new Field(attributeName, new FixedSizeList(attribute.size, new Field("value", type)), false, metadata);
-    return field;
+    return {
+      name,
+      type: { type: "fixed-size-list", listSize: attribute.size, children: [{ name: "value", type }] },
+      nullable: false,
+      metadata
+    };
   }
   function makeMeshAttributeMetadata(attribute) {
-    const result = new Map();
+    const result = {};
     if ("byteOffset" in attribute) {
-      result.set("byteOffset", attribute.byteOffset.toString(10));
+      result.byteOffset = attribute.byteOffset.toString(10);
     }
     if ("byteStride" in attribute) {
-      result.set("byteStride", attribute.byteStride.toString(10));
+      result.byteStride = attribute.byteStride.toString(10);
     }
     if ("normalized" in attribute) {
-      result.set("normalized", attribute.normalized.toString());
+      result.normalized = attribute.normalized.toString();
     }
     return result;
   }
 
   // ../draco/src/lib/utils/get-draco-schema.ts
   function getDracoSchema(attributes, loaderData, indices) {
-    const metadataMap = makeMetadata(loaderData.metadata);
+    const metadata = makeMetadata(loaderData.metadata);
     const fields = [];
     const namedLoaderDataAttributes = transformAttributesLoaderData(loaderData.attributes);
     for (const attributeName in attributes) {
@@ -4457,7 +5094,7 @@
       const indicesField = getArrowFieldFromAttribute("indices", indices);
       fields.push(indicesField);
     }
-    return new Schema(fields, metadataMap);
+    return { fields, metadata };
   }
   function transformAttributesLoaderData(loaderData) {
     const result = {};
@@ -4473,11 +5110,12 @@
     return field;
   }
   function makeMetadata(metadata) {
-    const metadataMap = new Map();
+    Object.entries(metadata);
+    const serializedMetadata = {};
     for (const key in metadata) {
-      metadataMap.set(`${key}.string`, JSON.stringify(metadata[key]));
+      serializedMetadata[`${key}.string`] = JSON.stringify(metadata[key]);
     }
-    return metadataMap;
+    return serializedMetadata;
   }
 
   // ../draco/src/lib/draco-parser.ts
@@ -4821,11 +5459,13 @@
   }
 
   // ../draco/src/lib/draco-module-loader.ts
-  var DRACO_VERSION = "1.4.1";
-  var DRACO_JS_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_decoder.js`;
-  var DRACO_WASM_WRAPPER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_wasm_wrapper.js`;
-  var DRACO_WASM_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_VERSION}/draco_decoder.wasm`;
-  var DRACO_ENCODER_URL = `https://raw.githubusercontent.com/google/draco/${DRACO_VERSION}/javascript/draco_encoder.js`;
+  var DRACO_DECODER_VERSION = "1.5.5";
+  var DRACO_ENCODER_VERSION = "1.4.1";
+  var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
+  var DRACO_JS_DECODER_URL = `${STATIC_DECODER_URL}/draco_decoder.js`;
+  var DRACO_WASM_WRAPPER_URL = `${STATIC_DECODER_URL}/draco_wasm_wrapper.js`;
+  var DRACO_WASM_DECODER_URL = `${STATIC_DECODER_URL}/draco_decoder.wasm`;
+  var DRACO_ENCODER_URL = `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/draco_encoder.js`;
   var loadDecoderPromise;
   async function loadDracoDecoderModule(options) {
     const modules = options.modules || {};
@@ -4860,10 +5500,10 @@
     if (wasmBinary) {
       options.wasmBinary = wasmBinary;
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       DracoDecoderModule({
         ...options,
-        onModuleLoaded: (draco) => resolve({ draco })
+        onModuleLoaded: (draco) => resolve2({ draco })
       });
     });
   }
@@ -4884,10 +5524,10 @@
   }
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+  var VERSION6 = true ? "4.0.0-alpha.11" : "beta";
 
   // ../textures/src/lib/parsers/basis-module-loader.ts
-  var VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+  var VERSION7 = true ? "4.0.0-alpha.11" : "beta";
   var BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION7}/dist/libs/basis_encoder.wasm`;
   var BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION7}/dist/libs/basis_encoder.js`;
   var loadBasisTranscoderPromise;
@@ -4914,11 +5554,11 @@
     if (wasmBinary) {
       options.wasmBinary = wasmBinary;
     }
-    return new Promise((resolve) => {
-      BasisModule(options).then((module2) => {
-        const { BasisFile, initializeBasis } = module2;
+    return new Promise((resolve2) => {
+      BasisModule(options).then((module) => {
+        const { BasisFile, initializeBasis } = module;
         initializeBasis();
-        resolve({ BasisFile });
+        resolve2({ BasisFile });
       });
     });
   }
@@ -4946,17 +5586,17 @@
     if (wasmBinary) {
       options.wasmBinary = wasmBinary;
     }
-    return new Promise((resolve) => {
-      BasisEncoderModule(options).then((module2) => {
-        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module2;
+    return new Promise((resolve2) => {
+      BasisEncoderModule(options).then((module) => {
+        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
         initializeBasis();
-        resolve({ BasisFile, KTX2File, BasisEncoder });
+        resolve2({ BasisFile, KTX2File, BasisEncoder });
       });
     });
   }
 
-  // ../textures/src/lib/gl-constants.ts
-  var GL = {
+  // ../textures/src/lib/gl-extensions.ts
+  var GL_EXTENSIONS_CONSTANTS = {
     COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
     COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
     COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
@@ -5017,6 +5657,43 @@
     COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 35919
   };
 
+  // ../textures/src/lib/utils/texture-formats.ts
+  var BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
+  var WEBGL_EXTENSIONS = {
+    WEBGL_compressed_texture_s3tc: "dxt",
+    WEBGL_compressed_texture_s3tc_srgb: "dxt-srgb",
+    WEBGL_compressed_texture_etc1: "etc1",
+    WEBGL_compressed_texture_etc: "etc2",
+    WEBGL_compressed_texture_pvrtc: "pvrtc",
+    WEBGL_compressed_texture_atc: "atc",
+    WEBGL_compressed_texture_astc: "astc",
+    EXT_texture_compression_rgtc: "rgtc"
+  };
+  var formats = null;
+  function getSupportedGPUTextureFormats(gl) {
+    if (!formats) {
+      gl = gl || getWebGLContext() || void 0;
+      formats = new Set();
+      for (const prefix of BROWSER_PREFIXES) {
+        for (const extension in WEBGL_EXTENSIONS) {
+          if (gl && gl.getExtension(`${prefix}${extension}`)) {
+            const gpuTextureFormat = WEBGL_EXTENSIONS[extension];
+            formats.add(gpuTextureFormat);
+          }
+        }
+      }
+    }
+    return formats;
+  }
+  function getWebGLContext() {
+    try {
+      const canvas = document.createElement("canvas");
+      return canvas.getContext("webgl");
+    } catch (error) {
+      return null;
+    }
+  }
+
   // ../../node_modules/ktx-parse/dist/ktx-parse.modern.js
   var t = new Uint8Array([0]);
   var e = [171, 75, 84, 88, 32, 50, 48, 187, 13, 10, 26, 10];
@@ -5151,72 +5828,72 @@
 
   // ../textures/src/lib/utils/ktx-format-helper.ts
   var VULKAN_TO_WEBGL_FORMAT_MAP = {
-    131: GL.COMPRESSED_RGB_S3TC_DXT1_EXT,
-    132: GL.COMPRESSED_SRGB_S3TC_DXT1_EXT,
-    133: GL.COMPRESSED_RGBA_S3TC_DXT1_EXT,
-    134: GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
-    135: GL.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-    136: GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
-    137: GL.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-    138: GL.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
-    139: GL.COMPRESSED_RED_RGTC1_EXT,
-    140: GL.COMPRESSED_SIGNED_RED_RGTC1_EXT,
-    141: GL.COMPRESSED_RED_GREEN_RGTC2_EXT,
-    142: GL.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT,
-    147: GL.COMPRESSED_RGB8_ETC2,
-    148: GL.COMPRESSED_SRGB8_ETC2,
-    149: GL.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
-    150: GL.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
-    151: GL.COMPRESSED_RGBA8_ETC2_EAC,
-    152: GL.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
-    153: GL.COMPRESSED_R11_EAC,
-    154: GL.COMPRESSED_SIGNED_R11_EAC,
-    155: GL.COMPRESSED_RG11_EAC,
-    156: GL.COMPRESSED_SIGNED_RG11_EAC,
-    157: GL.COMPRESSED_RGBA_ASTC_4x4_KHR,
-    158: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
-    159: GL.COMPRESSED_RGBA_ASTC_5x4_KHR,
-    160: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR,
-    161: GL.COMPRESSED_RGBA_ASTC_5x5_KHR,
-    162: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
-    163: GL.COMPRESSED_RGBA_ASTC_6x5_KHR,
-    164: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
-    165: GL.COMPRESSED_RGBA_ASTC_6x6_KHR,
-    166: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
-    167: GL.COMPRESSED_RGBA_ASTC_8x5_KHR,
-    168: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
-    169: GL.COMPRESSED_RGBA_ASTC_8x6_KHR,
-    170: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
-    171: GL.COMPRESSED_RGBA_ASTC_8x8_KHR,
-    172: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
-    173: GL.COMPRESSED_RGBA_ASTC_10x5_KHR,
-    174: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
-    175: GL.COMPRESSED_RGBA_ASTC_10x6_KHR,
-    176: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
-    177: GL.COMPRESSED_RGBA_ASTC_10x8_KHR,
-    178: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
-    179: GL.COMPRESSED_RGBA_ASTC_10x10_KHR,
-    180: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
-    181: GL.COMPRESSED_RGBA_ASTC_12x10_KHR,
-    182: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
-    183: GL.COMPRESSED_RGBA_ASTC_12x12_KHR,
-    184: GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
-    1000054e3: GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,
-    1000054001: GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
-    1000066e3: GL.COMPRESSED_RGBA_ASTC_4x4_KHR,
-    1000066001: GL.COMPRESSED_RGBA_ASTC_5x4_KHR,
-    1000066002: GL.COMPRESSED_RGBA_ASTC_5x5_KHR,
-    1000066003: GL.COMPRESSED_RGBA_ASTC_6x5_KHR,
-    1000066004: GL.COMPRESSED_RGBA_ASTC_6x6_KHR,
-    1000066005: GL.COMPRESSED_RGBA_ASTC_8x5_KHR,
-    1000066006: GL.COMPRESSED_RGBA_ASTC_8x6_KHR,
-    1000066007: GL.COMPRESSED_RGBA_ASTC_8x8_KHR,
-    1000066008: GL.COMPRESSED_RGBA_ASTC_10x5_KHR,
-    1000066009: GL.COMPRESSED_RGBA_ASTC_10x6_KHR,
-    1000066010: GL.COMPRESSED_RGBA_ASTC_10x8_KHR,
-    1000066011: GL.COMPRESSED_RGBA_ASTC_10x10_KHR,
-    1000066012: GL.COMPRESSED_RGBA_ASTC_12x10_KHR,
-    1000066013: GL.COMPRESSED_RGBA_ASTC_12x12_KHR
+    131: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
+    132: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_S3TC_DXT1_EXT,
+    133: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
+    134: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
+    135: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+    136: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
+    137: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+    138: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
+    139: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RED_RGTC1_EXT,
+    140: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RED_RGTC1_EXT,
+    141: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RED_GREEN_RGTC2_EXT,
+    142: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT,
+    147: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_ETC2,
+    148: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ETC2,
+    149: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+    150: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+    151: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA8_ETC2_EAC,
+    152: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
+    153: GL_EXTENSIONS_CONSTANTS.COMPRESSED_R11_EAC,
+    154: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_R11_EAC,
+    155: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RG11_EAC,
+    156: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RG11_EAC,
+    157: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4x4_KHR,
+    158: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
+    159: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x4_KHR,
+    160: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR,
+    161: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x5_KHR,
+    162: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
+    163: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x5_KHR,
+    164: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
+    165: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x6_KHR,
+    166: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
+    167: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x5_KHR,
+    168: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
+    169: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x6_KHR,
+    170: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
+    171: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x8_KHR,
+    172: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
+    173: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x5_KHR,
+    174: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
+    175: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x6_KHR,
+    176: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
+    177: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x8_KHR,
+    178: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
+    179: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x10_KHR,
+    180: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
+    181: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x10_KHR,
+    182: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
+    183: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x12_KHR,
+    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,
+    1000066e3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4x4_KHR,
+    1000066001: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x4_KHR,
+    1000066002: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x5_KHR,
+    1000066003: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x5_KHR,
+    1000066004: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x6_KHR,
+    1000066005: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x5_KHR,
+    1000066006: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x6_KHR,
+    1000066007: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x8_KHR,
+    1000066008: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x5_KHR,
+    1000066009: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x6_KHR,
+    1000066010: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x8_KHR,
+    1000066011: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x10_KHR,
+    1000066012: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x10_KHR,
+    1000066013: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x12_KHR
   };
   function mapVkFormatToWebGL(vkFormat) {
     return VULKAN_TO_WEBGL_FORMAT_MAP[vkFormat];
@@ -5258,19 +5935,43 @@
     });
   }
 
-  // ../textures/src/lib/parsers/parse-basis.js
+  // ../textures/src/lib/parsers/parse-basis.ts
   var OutputFormat = {
-    etc1: { basisFormat: 0, compressed: true, format: GL.COMPRESSED_RGB_ETC1_WEBGL },
+    etc1: {
+      basisFormat: 0,
+      compressed: true,
+      format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
+    },
     etc2: { basisFormat: 1, compressed: true },
-    bc1: { basisFormat: 2, compressed: true, format: GL.COMPRESSED_RGB_S3TC_DXT1_EXT },
-    bc3: { basisFormat: 3, compressed: true, format: GL.COMPRESSED_RGBA_S3TC_DXT5_EXT },
+    bc1: {
+      basisFormat: 2,
+      compressed: true,
+      format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
+    },
+    bc3: {
+      basisFormat: 3,
+      compressed: true,
+      format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
+    },
     bc4: { basisFormat: 4, compressed: true },
     bc5: { basisFormat: 5, compressed: true },
     "bc7-m6-opaque-only": { basisFormat: 6, compressed: true },
     "bc7-m5": { basisFormat: 7, compressed: true },
-    "pvrtc1-4-rgb": { basisFormat: 8, compressed: true, format: GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG },
-    "pvrtc1-4-rgba": { basisFormat: 9, compressed: true, format: GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG },
-    "astc-4x4": { basisFormat: 10, compressed: true, format: GL.COMPRESSED_RGBA_ASTC_4X4_KHR },
+    "pvrtc1-4-rgb": {
+      basisFormat: 8,
+      compressed: true,
+      format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+    },
+    "pvrtc1-4-rgba": {
+      basisFormat: 9,
+      compressed: true,
+      format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+    },
+    "astc-4x4": {
+      basisFormat: 10,
+      compressed: true,
+      format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
+    },
     "atc-rgb": { basisFormat: 11, compressed: true },
     "atc-rgba-interpolated-alpha": { basisFormat: 12, compressed: true },
     rgba32: { basisFormat: 13, compressed: false },
@@ -5307,7 +6008,7 @@
     const basisFile = new BasisFile(new Uint8Array(data));
     try {
       if (!basisFile.startTranscoding()) {
-        return null;
+        throw new Error("Failed to start basis transcoding");
       }
       const imageCount = basisFile.getNumImages();
       const images = [];
@@ -5333,22 +6034,22 @@
     const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
     const decodedData = new Uint8Array(decodedSize);
     if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
-      return null;
+      throw new Error("failed to start Basis transcoding");
     }
     return {
       width,
       height,
       data: decodedData,
       compressed,
-      hasAlpha,
-      format
+      format,
+      hasAlpha
     };
   }
   function parseKTX2File(KTX2File, data, options) {
     const ktx2File = new KTX2File(new Uint8Array(data));
     try {
       if (!ktx2File.startTranscoding()) {
-        return null;
+        throw new Error("failed to start KTX2 transcoding");
       }
       const levelsCount = ktx2File.getLevels();
       const levels = [];
@@ -5356,7 +6057,7 @@
         levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
         break;
       }
-      return levels;
+      return [levels];
     } finally {
       ktx2File.close();
       ktx2File.delete();
@@ -5368,14 +6069,15 @@
     const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0, 0, basisFormat);
     const decodedData = new Uint8Array(decodedSize);
     if (!ktx2File.transcodeImage(decodedData, levelIndex, 0, 0, basisFormat, 0, -1, -1)) {
-      return null;
+      throw new Error("Failed to transcode KTX2 image");
     }
     return {
       width,
       height,
       data: decodedData,
       compressed,
-      alphaFlag,
+      levelSize: decodedSize,
+      hasAlpha: alphaFlag,
       format
     };
   }
@@ -5453,12 +6155,12 @@
     DDPF_FOURCC: 4
   };
   var DDS_PIXEL_FORMATS = {
-    DXT1: GL.COMPRESSED_RGB_S3TC_DXT1_EXT,
-    DXT3: GL.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-    DXT5: GL.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-    "ATC ": GL.COMPRESSED_RGB_ATC_WEBGL,
-    ATCA: GL.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
-    ATCI: GL.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL
+    DXT1: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
+    DXT3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+    DXT5: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+    "ATC ": GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ATC_WEBGL,
+    ATCA: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
+    ATCI: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL
   };
   var getATCLevelSize = getDxt1LevelSize;
   var getATCALevelSize = getDxtXLevelSize;
@@ -5525,33 +6227,75 @@
     METADATA_SIZE_INDEX: 12
   };
   var PVR_PIXEL_FORMATS = {
-    0: [GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG],
-    1: [GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG],
-    2: [GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG],
-    3: [GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG],
-    6: [GL.COMPRESSED_RGB_ETC1_WEBGL],
-    7: [GL.COMPRESSED_RGB_S3TC_DXT1_EXT],
-    9: [GL.COMPRESSED_RGBA_S3TC_DXT3_EXT],
-    11: [GL.COMPRESSED_RGBA_S3TC_DXT5_EXT],
-    22: [GL.COMPRESSED_RGB8_ETC2],
-    23: [GL.COMPRESSED_RGBA8_ETC2_EAC],
-    24: [GL.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2],
-    25: [GL.COMPRESSED_R11_EAC],
-    26: [GL.COMPRESSED_RG11_EAC],
-    27: [GL.COMPRESSED_RGBA_ASTC_4X4_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR],
-    28: [GL.COMPRESSED_RGBA_ASTC_5X4_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR],
-    29: [GL.COMPRESSED_RGBA_ASTC_5X5_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR],
-    30: [GL.COMPRESSED_RGBA_ASTC_6X5_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR],
-    31: [GL.COMPRESSED_RGBA_ASTC_6X6_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR],
-    32: [GL.COMPRESSED_RGBA_ASTC_8X5_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR],
-    33: [GL.COMPRESSED_RGBA_ASTC_8X6_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR],
-    34: [GL.COMPRESSED_RGBA_ASTC_8X8_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR],
-    35: [GL.COMPRESSED_RGBA_ASTC_10X5_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR],
-    36: [GL.COMPRESSED_RGBA_ASTC_10X6_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR],
-    37: [GL.COMPRESSED_RGBA_ASTC_10X8_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR],
-    38: [GL.COMPRESSED_RGBA_ASTC_10X10_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR],
-    39: [GL.COMPRESSED_RGBA_ASTC_12X10_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR],
-    40: [GL.COMPRESSED_RGBA_ASTC_12X12_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR]
+    0: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_2BPPV1_IMG],
+    1: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG],
+    2: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG],
+    3: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG],
+    6: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL],
+    7: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT],
+    9: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT],
+    11: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT],
+    22: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_ETC2],
+    23: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA8_ETC2_EAC],
+    24: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2],
+    25: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_R11_EAC],
+    26: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RG11_EAC],
+    27: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR
+    ],
+    28: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5X4_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR
+    ],
+    29: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5X5_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR
+    ],
+    30: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6X5_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR
+    ],
+    31: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6X6_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR
+    ],
+    32: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8X5_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR
+    ],
+    33: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8X6_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR
+    ],
+    34: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8X8_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR
+    ],
+    35: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X5_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR
+    ],
+    36: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X6_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR
+    ],
+    37: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X8_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR
+    ],
+    38: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X10_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR
+    ],
+    39: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12X10_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR
+    ],
+    40: [
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12X12_KHR,
+      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR
+    ]
   };
   var PVR_SIZE_FUNCTIONS = {
     0: pvrtc2bppSize,
@@ -5719,48 +6463,30 @@
           containerFormat: "ktx2",
           module: "encoder"
         };
-        return await parseBasis(arrayBuffer, options);
+        return (await parseBasis(arrayBuffer, options))[0];
       }
       return parseCompressedTexture(arrayBuffer);
     }
   };
 
-  // ../textures/src/lib/utils/texture-formats.ts
-  var BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
-  var WEBGL_EXTENSIONS = {
-    WEBGL_compressed_texture_s3tc: "dxt",
-    WEBGL_compressed_texture_s3tc_srgb: "dxt-srgb",
-    WEBGL_compressed_texture_etc1: "etc1",
-    WEBGL_compressed_texture_etc: "etc2",
-    WEBGL_compressed_texture_pvrtc: "pvrtc",
-    WEBGL_compressed_texture_atc: "atc",
-    WEBGL_compressed_texture_astc: "astc",
-    EXT_texture_compression_rgtc: "rgtc"
-  };
-  var formats = null;
-  function getSupportedGPUTextureFormats(gl) {
-    if (!formats) {
-      gl = gl || getWebGLContext() || void 0;
-      formats = new Set();
-      for (const prefix of BROWSER_PREFIXES) {
-        for (const extension in WEBGL_EXTENSIONS) {
-          if (gl && gl.getExtension(`${prefix}${extension}`)) {
-            const gpuTextureFormat = WEBGL_EXTENSIONS[extension];
-            formats.add(gpuTextureFormat);
-          }
-        }
-      }
-    }
-    return formats;
-  }
-  function getWebGLContext() {
-    try {
-      const canvas = document.createElement("canvas");
-      return canvas.getContext("webgl");
-    } catch (error) {
-      return null;
-    }
-  }
+  // src/types.ts
+  var DATA_TYPE;
+  (function(DATA_TYPE2) {
+    DATA_TYPE2["UInt8"] = "UInt8";
+    DATA_TYPE2["UInt16"] = "UInt16";
+    DATA_TYPE2["UInt32"] = "UInt32";
+    DATA_TYPE2["UInt64"] = "UInt64";
+    DATA_TYPE2["Int16"] = "Int16";
+    DATA_TYPE2["Int32"] = "Int32";
+    DATA_TYPE2["Int64"] = "Int64";
+    DATA_TYPE2["Float32"] = "Float32";
+    DATA_TYPE2["Float64"] = "Float64";
+  })(DATA_TYPE || (DATA_TYPE = {}));
+  var HeaderAttributeProperty;
+  (function(HeaderAttributeProperty2) {
+    HeaderAttributeProperty2["vertexCount"] = "vertexCount";
+    HeaderAttributeProperty2["featureCount"] = "featureCount";
+  })(HeaderAttributeProperty || (HeaderAttributeProperty = {}));
 
   // src/lib/utils/url-utils.ts
   function getUrlWithToken(url, token = null) {
@@ -5768,7 +6494,7 @@
   }
 
   // ../../node_modules/@luma.gl/constants/dist/esm/index.js
-  var esm_default2 = {
+  var esm_default = {
     DEPTH_BUFFER_BIT: 256,
     STENCIL_BUFFER_BIT: 1024,
     COLOR_BUFFER_BIT: 16384,
@@ -6386,72 +7112,252 @@
   };
 
   // src/lib/parsers/constants.ts
-  var TYPE_ARRAY_MAP = {
-    UInt8: Uint8Array,
-    UInt16: Uint16Array,
-    UInt32: Uint32Array,
-    Float32: Float32Array,
-    UInt64: Float64Array
-  };
+  function getConstructorForDataFormat(dataType) {
+    switch (dataType) {
+      case DATA_TYPE.UInt8:
+        return Uint8Array;
+      case DATA_TYPE.UInt16:
+        return Uint16Array;
+      case DATA_TYPE.UInt32:
+        return Uint32Array;
+      case DATA_TYPE.Float32:
+        return Float32Array;
+      case DATA_TYPE.UInt64:
+        return Float64Array;
+      default:
+        throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
+    }
+  }
   var GL_TYPE_MAP = {
-    UInt8: esm_default2.UNSIGNED_BYTE,
-    UInt16: esm_default2.UNSIGNED_INT,
-    Float32: esm_default2.FLOAT,
-    UInt32: esm_default2.UNSIGNED_INT,
-    UInt64: esm_default2.DOUBLE
-  };
-  var I3S_NAMED_VERTEX_ATTRIBUTES = {
-    position: "position",
-    normal: "normal",
-    uv0: "uv0",
-    color: "color",
-    region: "region"
-  };
-  var I3S_NAMED_GEOMETRY_ATTRIBUTES = {
-    vertexAttributes: "vertexAttributes",
-    featureAttributeOrder: "featureAttributeOrder",
-    featureAttributes: "featureAttributes"
+    UInt8: esm_default.UNSIGNED_BYTE,
+    UInt16: esm_default.UNSIGNED_SHORT,
+    Float32: esm_default.FLOAT,
+    UInt32: esm_default.UNSIGNED_INT,
+    UInt64: esm_default.DOUBLE
   };
-  var I3S_NAMED_HEADER_ATTRIBUTES = {
-    header: "header",
-    vertexCount: "vertexCount",
-    featureCount: "featureCount"
-  };
-  var SIZEOF = {
-    UInt8: 1,
-    UInt16: 2,
-    UInt32: 4,
-    Float32: 4,
-    UInt64: 8
+  function sizeOf(dataType) {
+    switch (dataType) {
+      case DATA_TYPE.UInt8:
+        return 1;
+      case DATA_TYPE.UInt16:
+      case DATA_TYPE.Int16:
+        return 2;
+      case DATA_TYPE.UInt32:
+      case DATA_TYPE.Int32:
+      case DATA_TYPE.Float32:
+        return 4;
+      case DATA_TYPE.UInt64:
+      case DATA_TYPE.Int64:
+      case DATA_TYPE.Float64:
+        return 8;
+      default:
+        throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
+    }
+  }
+  var STRING_ATTRIBUTE_TYPE = "String";
+  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) {
+    const { attributeName, attributeType } = options;
+    if (!attributeName) {
+      return {};
+    }
+    return {
+      [attributeName]: attributeType ? parseAttribute(attributeType, arrayBuffer) : null
+    };
+  }
+  function parseAttribute(attributeType, arrayBuffer) {
+    switch (attributeType) {
+      case STRING_ATTRIBUTE_TYPE:
+        return parseStringsAttribute(arrayBuffer);
+      case OBJECT_ID_ATTRIBUTE_TYPE:
+        return parseShortNumberAttribute(arrayBuffer);
+      case FLOAT_64_TYPE:
+        return parseFloatAttribute(arrayBuffer);
+      case INT_16_ATTRIBUTE_TYPE:
+        return parseInt16ShortNumberAttribute(arrayBuffer);
+      default:
+        return parseShortNumberAttribute(arrayBuffer);
+    }
+  }
+  function parseShortNumberAttribute(arrayBuffer) {
+    const countOffset = 4;
+    return new Uint32Array(arrayBuffer, countOffset);
+  }
+  function parseInt16ShortNumberAttribute(arrayBuffer) {
+    const countOffset = 4;
+    return new Int16Array(arrayBuffer, countOffset);
+  }
+  function parseFloatAttribute(arrayBuffer) {
+    const countOffset = 8;
+    return new Float64Array(arrayBuffer, countOffset);
+  }
+  function parseStringsAttribute(arrayBuffer) {
+    const stringsCountOffset = 0;
+    const dataOffset = 8;
+    const bytesPerStringSize = 4;
+    const stringsArray = [];
+    try {
+      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) {
+        const textDecoder = new TextDecoder("utf-8");
+        const stringAttribute = new Uint8Array(arrayBuffer, stringOffset, stringByteSize);
+        stringsArray.push(textDecoder.decode(stringAttribute));
+        stringOffset += stringByteSize;
+      }
+    } catch (error) {
+      console.error("Parse string attribute error: ", error.message);
+    }
+    return stringsArray;
+  }
+
+  // src/i3s-attribute-loader.ts
+  var VERSION8 = true ? "4.0.0-alpha.11" : "latest";
+  var I3SAttributeLoader = {
+    name: "I3S Attribute",
+    id: "i3s-attribute",
+    module: "i3s",
+    version: VERSION8,
+    mimeTypes: ["application/binary"],
+    parse: async (arrayBuffer, options) => parseI3STileAttribute(arrayBuffer, options),
+    extensions: ["bin"],
+    options: {},
+    binary: true
   };
+  function getAttributeValueType(attribute) {
+    if (attribute.hasOwnProperty("objectIds")) {
+      return "Oid32";
+    } else if (attribute.hasOwnProperty("attributeValues")) {
+      return attribute.attributeValues.valueType;
+    }
+    return "";
+  }
+
+  // src/lib/utils/customize-сolors.ts
+  async function customizeColors(colors, featureIds, tileOptions, tilesetOptions, options) {
+    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)) {
+      return colors;
+    }
+    const colorizeAttributeData = await loadFeatureAttributeData(colorizeAttributeField.name, tileOptions, tilesetOptions, options);
+    if (!colorizeAttributeData) {
+      return colors;
+    }
+    const objectIdField = tilesetOptions.fields.find(({ type }) => type === "esriFieldTypeOID");
+    if (!objectIdField) {
+      return colors;
+    }
+    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);
+    }
+    for (let i2 = 0; i2 < featureIds.value.length; i2++) {
+      const color = attributeValuesMap[featureIds.value[i2]];
+      if (!color) {
+        continue;
+      }
+      if (options.i3s.colorsByAttribute.mode === "multiply") {
+        color.forEach((colorItem, index) => {
+          colors.value[i2 * 4 + index] = colors.value[i2 * 4 + index] * colorItem / 255;
+        });
+      } else {
+        colors.value.set(color, i2 * 4);
+      }
+    }
+    return colors;
+  }
+  function calculateColorForAttribute(attributeValue, options) {
+    if (!options?.i3s?.colorsByAttribute) {
+      return [255, 255, 255, 255];
+    }
+    const { minValue, maxValue, minColor, maxColor } = options.i3s.colorsByAttribute;
+    const rate = (attributeValue - minValue) / (maxValue - minValue);
+    const color = [255, 255, 255, 255];
+    for (let i2 = 0; i2 < minColor.length; i2++) {
+      color[i2] = Math.round((maxColor[i2] - minColor[i2]) * rate + minColor[i2]);
+    }
+    return color;
+  }
+  async function loadFeatureAttributeData(attributeName, { attributeUrls }, { attributeStorageInfo }, options) {
+    const attributeIndex = attributeStorageInfo.findIndex(({ name }) => attributeName === name);
+    if (attributeIndex === -1) {
+      return null;
+    }
+    const objectIdAttributeUrl = getUrlWithToken(attributeUrls[attributeIndex], options?.i3s?.token);
+    const attributeType = getAttributeValueType(attributeStorageInfo[attributeIndex]);
+    const objectIdAttributeData = await load(objectIdAttributeUrl, I3SAttributeLoader, {
+      attributeName,
+      attributeType
+    });
+    return objectIdAttributeData;
+  }
 
   // src/lib/parsers/parse-i3s-tile-content.ts
-  var COORDINATE_SYSTEM_LNGLAT_OFFSETS = 3;
-  var FORMAT_LOADER_MAP = {
-    jpeg: ImageLoader,
-    png: ImageLoader,
-    "ktx-etc2": CompressedTextureLoader,
-    dds: CompressedTextureLoader,
-    ktx2: BasisLoader
-  };
+  var scratchVector5 = new Vector3([0, 0, 0]);
+  function getLoaderForTextureFormat(textureFormat) {
+    switch (textureFormat) {
+      case "ktx-etc2":
+      case "dds":
+        return CompressedTextureLoader;
+      case "ktx2":
+        return BasisLoader;
+      case "jpg":
+      case "png":
+      default:
+        return ImageLoader;
+    }
+  }
   var I3S_ATTRIBUTE_TYPE = "i3s-attribute-type";
-  async function parseI3STileContent(arrayBuffer, tile, tileset, options, context) {
-    tile.content = tile.content || {};
-    tile.content.featureIds = tile.content.featureIds || null;
-    tile.content.featureData = constructFeatureDataStruct(tile, tileset);
-    tile.content.attributes = {};
-    if (tile.textureUrl) {
-      const url = getUrlWithToken(tile.textureUrl, options?.i3s?.token);
-      const loader = FORMAT_LOADER_MAP[tile.textureFormat] || ImageLoader;
-      const response = await fetch(url);
+  async function parseI3STileContent(arrayBuffer, tileOptions, tilesetOptions, options, context) {
+    const content = {
+      attributes: {},
+      indices: null,
+      featureIds: [],
+      vertexCount: 0,
+      modelMatrix: new Matrix4(),
+      coordinateSystem: 0,
+      byteLength: 0,
+      texture: null
+    };
+    if (tileOptions.textureUrl) {
+      const url = getUrlWithToken(tileOptions.textureUrl, options?.i3s?.token);
+      const loader = getLoaderForTextureFormat(tileOptions.textureFormat);
+      const response = await fetch(url, options?.fetch);
       const arrayBuffer2 = await response.arrayBuffer();
       if (options?.i3s.decodeTextures) {
         if (loader === ImageLoader) {
-          const options2 = { ...tile.textureLoaderOptions, image: { type: "data" } };
-          tile.content.texture = await context.parse(arrayBuffer2, options2);
+          const options2 = { ...tileOptions.textureLoaderOptions, image: { type: "data" } };
+          try {
+            content.texture = await context.parse(arrayBuffer2, options2);
+          } catch (e2) {
+            content.texture = await parse(arrayBuffer2, loader, options2);
+          }
         } else if (loader === CompressedTextureLoader || loader === BasisLoader) {
-          const texture = await load(arrayBuffer2, loader, tile.textureLoaderOptions);
-          tile.content.texture = {
+          let texture = await load(arrayBuffer2, loader, tileOptions.textureLoaderOptions);
+          if (loader === BasisLoader) {
+            texture = texture[0];
+          }
+          content.texture = {
             compressed: true,
             mipmaps: false,
             width: texture[0].width,
@@ -6460,32 +7366,30 @@
           };
         }
       } else {
-        tile.content.texture = arrayBuffer2;
+        content.texture = arrayBuffer2;
       }
     }
-    tile.content.material = makePbrMaterial(tile.materialDefinition, tile.content.texture);
-    if (tile.content.material) {
-      tile.content.texture = null;
+    content.material = makePbrMaterial(tileOptions.materialDefinition, content.texture);
+    if (content.material) {
+      content.texture = null;
     }
-    return await parseI3SNodeGeometry(arrayBuffer, tile, context);
+    return await parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOptions, options);
   }
-  async function parseI3SNodeGeometry(arrayBuffer, tile = {}, context) {
-    if (!tile.content) {
-      return tile;
-    }
-    const content = tile.content;
+  async function parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOptions, options) {
+    const contentByteLength = arrayBuffer.byteLength;
     let attributes;
     let vertexCount;
     let byteOffset = 0;
     let featureCount = 0;
-    if (tile.isDracoGeometry) {
+    let indices;
+    if (tileOptions.isDracoGeometry) {
       const decompressedGeometry = await parse(arrayBuffer, DracoLoader2, {
         draco: {
           attributeNameEntry: I3S_ATTRIBUTE_TYPE
         }
       });
       vertexCount = decompressedGeometry.header.vertexCount;
-      const indices = decompressedGeometry.indices.value;
+      indices = decompressedGeometry.indices?.value;
       const {
         POSITION,
         NORMAL,
@@ -6500,8 +7404,7 @@
         color: COLOR_0,
         uv0: TEXCOORD_0,
         uvRegion,
-        id: featureIndex,
-        indices
+        id: featureIndex
       };
       updateAttributesMetadata(attributes, decompressedGeometry);
       const featureIds = getFeatureIdsFromFeatureIndexMetadata(featureIndex);
@@ -6509,8 +7412,13 @@
         flattenFeatureIdsByFeatureIndices(attributes, featureIds);
       }
     } else {
-      const { vertexAttributes, attributesOrder, featureAttributes, featureAttributeOrder } = content.featureData;
-      const headers = parseHeaders(content, arrayBuffer);
+      const {
+        vertexAttributes,
+        ordering: attributesOrder,
+        featureAttributes,
+        featureAttributeOrder
+      } = tilesetOptions.store.defaultGeometrySchema;
+      const headers = parseHeaders(arrayBuffer, tilesetOptions);
       byteOffset = headers.byteOffset;
       vertexCount = headers.vertexCount;
       featureCount = headers.featureCount;
@@ -6519,16 +7427,25 @@
       flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes);
       attributes = concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes);
     }
+    if (!options?.i3s?.coordinateSystem || options.i3s.coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) {
+      const enuMatrix = parsePositions(attributes.position, tileOptions);
+      content.modelMatrix = enuMatrix.invert();
+      content.coordinateSystem = COORDINATE_SYSTEM.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.attributes = {
       positions: attributes.position,
       normals: attributes.normal,
       colors: normalizeAttribute(attributes.color),
       texCoords: attributes.uv0,
-      uvRegions: normalizeAttribute(attributes.uvRegion)
+      uvRegions: normalizeAttribute(attributes.uvRegion || attributes.region)
     };
-    content.indices = attributes.indices || null;
+    content.indices = indices || null;
     if (attributes.id && attributes.id.value) {
-      tile.content.featureIds = attributes.id.value;
+      content.featureIds = attributes.id.value;
     }
     for (const attributeIndex in content.attributes) {
       if (!content.attributes[attributeIndex]) {
@@ -6536,10 +7453,8 @@
       }
     }
     content.vertexCount = vertexCount;
-    content.modelMatrix = getModelMatrix(attributes.position);
-    content.coordinateSystem = COORDINATE_SYSTEM_LNGLAT_OFFSETS;
-    content.byteLength = arrayBuffer.byteLength;
-    return tile;
+    content.byteLength = contentByteLength;
+    return content;
   }
   function updateAttributesMetadata(attributes, decompressedGeometry) {
     for (const key in decompressedGeometry.loaderData.attributes) {
@@ -6566,41 +7481,23 @@
     attribute.normalized = true;
     return attribute;
   }
-  function constructFeatureDataStruct(tile, tileset) {
-    const defaultGeometrySchema = tileset.store.defaultGeometrySchema;
-    const featureData = defaultGeometrySchema;
-    for (const geometryAttribute in I3S_NAMED_GEOMETRY_ATTRIBUTES) {
-      for (const namedAttribute in I3S_NAMED_VERTEX_ATTRIBUTES) {
-        const attribute = defaultGeometrySchema[geometryAttribute][namedAttribute];
-        if (attribute) {
-          const { byteOffset = 0, count = 0, valueType, valuesPerElement } = attribute;
-          featureData[geometryAttribute][namedAttribute] = {
-            valueType,
-            valuesPerElement,
-            byteOffset,
-            count
-          };
-        }
-      }
-    }
-    featureData.attributesOrder = defaultGeometrySchema.ordering;
-    return featureData;
-  }
-  function parseHeaders(content, buffer) {
+  function parseHeaders(arrayBuffer, options) {
     let byteOffset = 0;
     let vertexCount = 0;
     let featureCount = 0;
-    const headers = content.featureData[I3S_NAMED_HEADER_ATTRIBUTES.header];
-    for (const header in headers) {
-      const { property, type } = headers[header];
-      const TypedArrayTypeHeader = TYPE_ARRAY_MAP[type];
-      if (property === I3S_NAMED_HEADER_ATTRIBUTES.vertexCount) {
-        vertexCount = new TypedArrayTypeHeader(buffer, 0, 4)[0];
-        byteOffset += SIZEOF[type];
-      }
-      if (property === I3S_NAMED_HEADER_ATTRIBUTES.featureCount) {
-        featureCount = new TypedArrayTypeHeader(buffer, 4, 4)[0];
-        byteOffset += SIZEOF[type];
+    for (const { property, type } of options.store.defaultGeometrySchema.header) {
+      const TypedArrayTypeHeader = getConstructorForDataFormat(type);
+      switch (property) {
+        case HeaderAttributeProperty.vertexCount:
+          vertexCount = new TypedArrayTypeHeader(arrayBuffer, 0, 4)[0];
+          byteOffset += sizeOf(type);
+          break;
+        case HeaderAttributeProperty.featureCount:
+          featureCount = new TypedArrayTypeHeader(arrayBuffer, 4, 4)[0];
+          byteOffset += sizeOf(type);
+          break;
+        default:
+          break;
       }
     }
     return {
@@ -6609,38 +7506,38 @@
       byteOffset
     };
   }
-  function normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, vertexCount, attributesOrder) {
+  function normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, attributeCount, attributesOrder) {
     const attributes = {};
     for (const attribute of attributesOrder) {
       if (vertexAttributes[attribute]) {
         const { valueType, valuesPerElement } = vertexAttributes[attribute];
-        const count = vertexCount;
-        if (byteOffset + count * valuesPerElement > arrayBuffer.byteLength) {
+        if (byteOffset + attributeCount * valuesPerElement * sizeOf(valueType) <= arrayBuffer.byteLength) {
+          const buffer = arrayBuffer.slice(byteOffset);
+          let value;
+          if (valueType === "UInt64") {
+            value = parseUint64Values(buffer, attributeCount * valuesPerElement, sizeOf(valueType));
+          } else {
+            const TypedArrayType = getConstructorForDataFormat(valueType);
+            value = new TypedArrayType(buffer, 0, attributeCount * valuesPerElement);
+          }
+          attributes[attribute] = {
+            value,
+            type: GL_TYPE_MAP[valueType],
+            size: valuesPerElement
+          };
+          switch (attribute) {
+            case "color":
+              attributes.color.normalized = true;
+              break;
+            case "position":
+            case "region":
+            case "normal":
+            default:
+          }
+          byteOffset = byteOffset + attributeCount * valuesPerElement * sizeOf(valueType);
+        } else if (attribute !== "uv0") {
           break;
         }
-        const buffer = arrayBuffer.slice(byteOffset);
-        let value = [];
-        if (valueType === "UInt64") {
-          value = parseUint64Values(buffer, count * valuesPerElement, SIZEOF[valueType]);
-        } else {
-          const TypedArrayType = TYPE_ARRAY_MAP[valueType];
-          value = new TypedArrayType(buffer, 0, count * valuesPerElement);
-        }
-        attributes[attribute] = {
-          value,
-          type: GL_TYPE_MAP[valueType],
-          size: valuesPerElement
-        };
-        switch (attribute) {
-          case "color":
-            attributes.color.normalized = true;
-            break;
-          case "position":
-          case "region":
-          case "normal":
-          default:
-        }
-        byteOffset = byteOffset + count * valuesPerElement * SIZEOF[valueType];
       }
     }
     return { attributes, byteOffset };
@@ -6656,7 +7553,36 @@
       values.push(value);
       offset += attributeSize;
     }
-    return values;
+    return new Uint32Array(values);
+  }
+  function parsePositions(attribute, options) {
+    const mbs = options.mbs;
+    const value = attribute.value;
+    const metadata = attribute.metadata;
+    const enuMatrix = new Matrix4();
+    const cartographicOrigin = new Vector3(mbs[0], mbs[1], mbs[2]);
+    const cartesianOrigin = new Vector3();
+    Ellipsoid.WGS84.cartographicToCartesian(cartographicOrigin, cartesianOrigin);
+    Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin, enuMatrix);
+    attribute.value = offsetsToCartesians(value, metadata, cartographicOrigin);
+    return enuMatrix;
+  }
+  function offsetsToCartesians(vertices, metadata = {}, cartographicOrigin) {
+    const positions = new Float64Array(vertices.length);
+    const scaleX = metadata["i3s-scale_x"] && metadata["i3s-scale_x"].double || 1;
+    const scaleY = metadata["i3s-scale_y"] && metadata["i3s-scale_y"].double || 1;
+    for (let i2 = 0; i2 < positions.length; i2 += 3) {
+      positions[i2] = vertices[i2] * scaleX + cartographicOrigin.x;
+      positions[i2 + 1] = vertices[i2 + 1] * scaleY + cartographicOrigin.y;
+      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;
+    }
+    return positions;
   }
   function getModelMatrix(positions) {
     const metadata = positions.metadata;
@@ -6694,7 +7620,9 @@
     if (pbrMaterial.pbrMetallicRoughness && pbrMaterial.pbrMetallicRoughness.baseColorFactor) {
       pbrMaterial.pbrMetallicRoughness.baseColorFactor = convertColorFormat(pbrMaterial.pbrMetallicRoughness.baseColorFactor);
     }
-    setMaterialTexture(pbrMaterial, texture);
+    if (texture) {
+      setMaterialTexture(pbrMaterial, texture);
+    }
     return pbrMaterial;
   }
   function convertColorFormat(colorFactor) {
@@ -6756,17 +7684,17 @@
     attributes.id.value = result;
   }
   function getFeatureIdsFromFeatureIndexMetadata(featureIndex) {
-    return featureIndex && featureIndex.metadata && featureIndex.metadata["i3s-feature-ids"] && featureIndex.metadata["i3s-feature-ids"].intArray;
+    return featureIndex?.metadata?.["i3s-feature-ids"]?.intArray;
   }
 
   // src/i3s-content-loader.ts
-  var VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+  var VERSION9 = true ? "4.0.0-alpha.11" : "beta";
   var I3SContentLoader = {
     name: "I3S Content (Indexed Scene Layers)",
     id: "i3s-content",
     module: "i3s",
     worker: true,
-    version: VERSION8,
+    version: VERSION9,
     mimeTypes: ["application/octet-stream"],
     parse: parse3,
     extensions: ["bin"],
@@ -6775,9 +7703,13 @@
     }
   };
   async function parse3(data, options, context) {
-    const { tile, tileset } = options?.i3s || {};
-    await parseI3STileContent(data, tile, tileset, options, context);
-    return tile.content;
+    const { tile, _tileOptions, tileset, _tilesetOptions } = options?.i3s || {};
+    const tileOptions = _tileOptions || tile;
+    const tilesetOptions = _tilesetOptions || tileset;
+    if (!tileOptions || !tilesetOptions) {
+      return null;
+    }
+    return await parseI3STileContent(data, tileOptions, tilesetOptions, options, context);
   }
 
   // src/workers/i3s-content-worker.ts