@loaders.gl/i3s 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/i3s-content-worker.js

@@ -14,16 +14,16 @@
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
-  var __reExport = (target, module2, desc) => {
-    if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-      for (let key of __getOwnPropNames(module2))
+  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: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
     }
     return target;
   };
-  var __toModule = (module2) => {
-    return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+  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
@@ -55,7 +55,7 @@
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
   // ../worker-utils/src/lib/env-utils/version.ts
-  var VERSION = true ? "4.0.0-alpha.5" : DEFAULT_VERSION;
+  var VERSION = true ? "4.0.0-alpha.6" : 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.");
   }
@@ -87,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;
       });
     }
@@ -118,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) {
@@ -205,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;
@@ -251,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
@@ -271,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;
@@ -360,9 +390,9 @@
   var DEFAULT_PROPS = {
     maxConcurrency: 3,
     maxMobileConcurrency: 1,
+    reuseWorkers: true,
     onDebug: () => {
-    },
-    reuseWorkers: true
+    }
   };
   var WorkerFarm = class {
     constructor(props) {
@@ -383,6 +413,7 @@
       for (const workerPool of this.workerPools.values()) {
         workerPool.destroy();
       }
+      this.workerPools = new Map();
     }
     setProps(props) {
       this.props = { ...this.props, ...props };
@@ -415,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);
@@ -433,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);
       }
     }
   };
@@ -564,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
               }
             });
@@ -591,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) {
@@ -600,7 +663,7 @@
         switch (type) {
           case "done":
             WorkerBody.removeEventListener(onMessage2);
-            resolve(payload2.result);
+            resolve2(payload2.result);
             break;
           case "error":
             WorkerBody.removeEventListener(onMessage2);
@@ -640,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) {
@@ -648,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;
@@ -679,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) {
@@ -750,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 = {};
@@ -766,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) {
@@ -794,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";
@@ -917,7 +1143,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;
@@ -929,9 +1155,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);
       });
     }
@@ -964,12 +1190,12 @@
     return await makeResponse(url);
   }
 
-  // ../../node_modules/probe.gl/dist/esm/env/is-electron.js
+  // ../../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;
@@ -980,31 +1206,25 @@
     return false;
   }
 
-  // ../../node_modules/probe.gl/dist/esm/env/is-browser.js
+  // ../../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 = true ? "4.0.0-alpha.5" : "untranspiled source";
+  // ../../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/env/dist/utils/globals.js
+  var VERSION3 = true ? "4.0.0-alpha.6" : "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];
@@ -1017,27 +1237,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 = {};
@@ -1050,7 +1268,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) {
@@ -1064,11 +1282,13 @@
     }
     return formatted;
   }
-  function leftPad(string, length2 = 8) {
+  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);
@@ -1079,69 +1299,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
+  // ../../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();
@@ -1149,15 +1380,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
   };
@@ -1167,27 +1398,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 = getHiResTimestamp();
-      this._deltaTs = getHiResTimestamp();
-      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);
@@ -1219,18 +1446,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);
     }
@@ -1269,17 +1512,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
@@ -1289,21 +1533,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);
     }
@@ -1313,10 +1542,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
@@ -1324,10 +1554,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
       }));
@@ -1351,7 +1582,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,
@@ -1365,7 +1596,7 @@
         opts.delta = this.getDelta();
         this._deltaTs = getHiResTimestamp();
         const tag = opts.tag || opts.message;
-        if (opts.once) {
+        if (opts.once && tag) {
           if (!cache[tag]) {
             cache[tag] = getHiResTimestamp();
           } else {
@@ -1378,7 +1609,7 @@
       return noop;
     }
   };
-  Log.VERSION = VERSION3;
+  _defineProperty(Log, "VERSION", VERSION3);
   function normalizeLogLevel(logLevel) {
     if (!logLevel) {
       return 0;
@@ -1406,7 +1637,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":
@@ -1425,7 +1655,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") {
@@ -1435,29 +1667,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 = () => {
@@ -1480,10 +1704,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
@@ -1534,7 +1766,8 @@
     worker: true,
     maxConcurrency: 3,
     maxMobileConcurrency: 1,
-    reuseWorkers: true,
+    reuseWorkers: isBrowser,
+    _nodeWorkers: false,
     _workerType: "",
     limit: 0,
     _limitMB: 0,
@@ -1579,20 +1812,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) {
@@ -1710,6 +1929,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) {
@@ -1754,13 +1976,22 @@
     const { url, type } = getResourceUrlAndType(data);
     const testUrl = 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) {
@@ -1943,7 +2174,7 @@
         if (done) {
           return;
         }
-        yield toArrayBuffer(value);
+        yield toArrayBuffer2(value);
       }
     } catch (error) {
       reader.releaseLock();
@@ -1951,7 +2182,7 @@
   }
   async function* makeNodeStreamIterator(stream, options) {
     for await (const chunk of stream) {
-      yield toArrayBuffer(chunk);
+      yield toArrayBuffer2(chunk);
     }
   }
 
@@ -2029,6 +2260,22 @@
     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) {
@@ -2081,6 +2328,12 @@
   }
   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";
@@ -2101,12 +2354,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);
@@ -2114,7 +2372,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
@@ -2127,18 +2385,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)));
@@ -2146,19 +2402,6 @@
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
   }
-  function duplicateArray(array) {
-    return array.clone ? array.clone() : new Array(array.length);
-  }
-  function map(value, func, result) {
-    if (isArray(value)) {
-      result = result || duplicateArray(value);
-      for (let i2 = 0; i2 < result.length && i2 < value.length; ++i2) {
-        result[i2] = func(value[i2], i2, result);
-      }
-      return result;
-    }
-    return func(value);
-  }
   function toRadians(degrees2) {
     return radians(degrees2);
   }
@@ -2197,7 +2440,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;
@@ -2205,6 +2448,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) {
@@ -2229,22 +2489,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;
@@ -2254,12 +2516,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);
     }
@@ -2303,9 +2559,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];
@@ -2348,14 +2602,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);
     }
@@ -2381,7 +2657,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) {
@@ -2389,25 +2665,9 @@
       }
       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
@@ -2434,24 +2694,9 @@
     }
     return v;
   }
-  var map2 = {};
-  function deprecated(method, version) {
-    if (!map2[method]) {
-      map2[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 ELEMENTS() {
-      assert4(false);
-      return 0;
-    }
-    copy(vector) {
-      assert4(false);
-      return this;
-    }
     get x() {
       return this[0];
     }
@@ -2771,10 +3016,14 @@
 
   // ../../node_modules/@math.gl/core/dist/esm/classes/vector3.js
   var ORIGIN = [0, 0, 0];
-  var constants = {};
+  var ZERO;
   var Vector3 = class extends Vector {
     static get ZERO() {
-      return constants.ZERO = constants.ZERO || Object.freeze(new Vector3(0, 0, 0, 0));
+      if (!ZERO) {
+        ZERO = new Vector3(0, 0, 0);
+        Object.freeze(ZERO);
+      }
+      return ZERO;
     }
     constructor(x = 0, y = 0, z = 0) {
       super(-0, -0, -0);
@@ -2884,14 +3133,6 @@
 
   // ../../node_modules/@math.gl/core/dist/esm/classes/base/matrix.js
   var Matrix = class extends MathArray {
-    get ELEMENTS() {
-      assert4(false);
-      return 0;
-    }
-    get RANK() {
-      assert4(false);
-      return 0;
-    }
     toString() {
       let string = "[";
       if (config.printRowMajor) {
@@ -3358,7 +3599,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;
@@ -3384,7 +3625,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);
@@ -3406,6 +3648,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];
@@ -3524,38 +3767,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 constants2 = {};
+  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() {
-      constants2.IDENTITY = constants2.IDENTITY || Object.freeze(new Matrix4(IDENTITY));
-      return constants2.IDENTITY;
+      return getIdentityMatrix();
     }
     static get ZERO() {
-      constants2.ZERO = constants2.ZERO || Object.freeze(new Matrix4(ZERO));
-      return constants2.ZERO;
-    }
-    get INDICES() {
-      return INDICES;
+      return getZeroMatrix();
     }
     get ELEMENTS() {
       return 16;
@@ -3563,6 +3804,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)) {
@@ -3648,91 +3892,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,
@@ -3741,17 +3959,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();
     }
@@ -3770,8 +3985,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];
@@ -3793,8 +4010,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];
@@ -3837,23 +4056,19 @@
       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(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) {
@@ -3868,52 +4083,98 @@
       const {
         length: length2
       } = vector;
+      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(radians2) {
-      return this.identity().rotateX(radians2);
-    }
-    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/lib/math-utils.js
   var math_utils_default = {
@@ -3943,17 +4204,6 @@
     TWO_PI: Math.PI * 2
   };
 
-  // ../../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
-  };
-  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;
@@ -3968,61 +4218,63 @@
   };
 
   // ../../node_modules/@math.gl/geospatial/dist/esm/type-utils.js
-  var noop2 = (x) => x;
+  function identity2(x) {
+    return x;
+  }
   var scratchVector = new Vector3();
-  function fromCartographic(cartographic, result, map3 = noop2) {
-    if (isArray(cartographic)) {
-      result[0] = map3(cartographic[0]);
-      result[1] = map3(cartographic[1]);
-      result[2] = cartographic[2];
-    } else if ("longitude" in cartographic) {
-      result[0] = map3(cartographic.longitude);
-      result[1] = map3(cartographic.latitude);
+  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 {
-      result[0] = map3(cartographic.x);
-      result[1] = map3(cartographic.y);
+    } 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 = scratchVector) {
-    return fromCartographic(cartographic, vector, config._cartographicRadians ? noop2 : toRadians);
+  function fromCartographicToRadians(cartographic, vector = []) {
+    return fromCartographic(cartographic, vector, config._cartographicRadians ? identity2 : toRadians);
   }
-  function toCartographic(vector, cartographic, map3 = noop2) {
-    if (isArray(cartographic)) {
-      cartographic[0] = map3(vector[0]);
-      cartographic[1] = map3(vector[1]);
-      cartographic[2] = vector[2];
-    } else if ("longitude" in cartographic) {
-      cartographic.longitude = map3(vector[0]);
-      cartographic.latitude = map3(vector[1]);
+  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 {
-      cartographic.x = map3(vector[0]);
-      cartographic.y = map3(vector[1]);
+    } 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 ? noop2 : toDegrees);
+    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 = new Vector3()) {
+  function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
     const {
       oneOverRadii,
       oneOverRadiiSquared,
       centerToleranceSquared
     } = ellipsoid;
     scratchVector2.from(cartesian);
-    const positionX = cartesian.x;
-    const positionY = cartesian.y;
-    const positionZ = cartesian.z;
+    const positionX = scratchVector2.x;
+    const positionY = scratchVector2.y;
+    const positionZ = scratchVector2.z;
     const oneOverRadiiX = oneOverRadii.x;
     const oneOverRadiiY = oneOverRadii.y;
     const oneOverRadiiZ = oneOverRadii.z;
@@ -4044,7 +4296,7 @@
     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) * cartesian.len() / (0.5 * gradient.len());
+    let lambda = (1 - ratio) * scratchVector2.len() / (0.5 * gradient.len());
     let correction = 0;
     let xMultiplier;
     let yMultiplier;
@@ -4198,13 +4450,17 @@
   var scratchPosition = new Vector3();
   var scratchHeight = new Vector3();
   var scratchCartesian = new Vector3();
-  var wgs84;
   var Ellipsoid = class {
-    static get WGS84() {
-      wgs84 = wgs84 || new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
-      return wgs84;
-    }
     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);
@@ -4215,7 +4471,6 @@
       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);
-      this.centerToleranceSquared = math_utils_default.EPSILON1;
       if (this.radiiSquared.z !== 0) {
         this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;
       }
@@ -4302,9 +4557,10 @@
       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 = true ? "4.0.0-alpha.5" : "latest";
+  var VERSION4 = true ? "4.0.0-alpha.6" : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var { _parseImageNode } = globalThis;
@@ -4428,9 +4684,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);
@@ -4473,12 +4729,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);
@@ -4623,12 +4927,13 @@
   }
 
   // ../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"
@@ -4652,7 +4957,7 @@
   };
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION5 = true ? "4.0.0-alpha.5" : "latest";
+  var VERSION5 = true ? "4.0.0-alpha.6" : "latest";
 
   // ../draco/src/draco-loader.ts
   var DEFAULT_DRACO_OPTIONS = {
@@ -4665,9 +4970,8 @@
   };
   var DracoLoader = {
     name: "Draco",
-    id: "draco",
+    id: isBrowser2 ? "draco" : "draco-nodejs",
     module: "draco",
-    shapes: ["mesh"],
     version: VERSION5,
     worker: true,
     extensions: ["drc"],
@@ -4677,7 +4981,32 @@
     options: DEFAULT_DRACO_OPTIONS
   };
 
-  // ../schema/src/category/mesh/mesh-utils.ts
+  // ../schema/src/lib/table/simple-table/data-type.ts
+  function getDataTypeFromTypedArray(array) {
+    switch (array.constructor) {
+      case Int8Array:
+        return "int8";
+      case Uint8Array:
+      case Uint8ClampedArray:
+        return "uint8";
+      case Int16Array:
+        return "int16";
+      case Uint16Array:
+        return "uint16";
+      case Int32Array:
+        return "int32";
+      case Uint32Array:
+        return "uint32";
+      case Float32Array:
+        return "float32";
+      case Float64Array:
+        return "float64";
+      default:
+        return "null";
+    }
+  }
+
+  // ../schema/src/lib/mesh/mesh-utils.ts
   function getMeshBoundingBox(attributes) {
     let minX = Infinity;
     let minY = Infinity;
@@ -4704,500 +5033,34 @@
     ];
   }
 
-  // ../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 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 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";
-    }
-  };
-
-  // ../schema/src/lib/arrow/arrow-like-type-utils.ts
-  function getArrowTypeFromTypedArray(array) {
-    switch (array.constructor) {
-      case Int8Array:
-        return new Int8();
-      case Uint8Array:
-        return new Uint8();
-      case Int16Array:
-        return new Int16();
-      case Uint16Array:
-        return new Uint16();
-      case Int32Array:
-        return new Int32();
-      case Uint32Array:
-        return new Uint32();
-      case Float32Array:
-        return new Float32();
-      case Float64Array:
-        return new Float64();
-      default:
-        throw new Error("array type not supported");
-    }
-  }
-
-  // ../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) {
@@ -5209,7 +5072,7 @@
       const indicesField = getArrowFieldFromAttribute("indices", indices);
       fields.push(indicesField);
     }
-    return new Schema(fields, metadataMap);
+    return { fields, metadata };
   }
   function transformAttributesLoaderData(loaderData) {
     const result = {};
@@ -5225,11 +5088,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
@@ -5573,11 +5437,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 || {};
@@ -5612,10 +5478,10 @@
     if (wasmBinary) {
       options.wasmBinary = wasmBinary;
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       DracoDecoderModule({
         ...options,
-        onModuleLoaded: (draco) => resolve({ draco })
+        onModuleLoaded: (draco) => resolve2({ draco })
       });
     });
   }
@@ -5636,10 +5502,10 @@
   }
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION6 = true ? "4.0.0-alpha.5" : "beta";
+  var VERSION6 = true ? "4.0.0-alpha.6" : "beta";
 
   // ../textures/src/lib/parsers/basis-module-loader.ts
-  var VERSION7 = true ? "4.0.0-alpha.5" : "beta";
+  var VERSION7 = true ? "4.0.0-alpha.6" : "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;
@@ -5666,11 +5532,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 });
       });
     });
   }
@@ -5698,11 +5564,11 @@
     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 });
       });
     });
   }
@@ -6188,6 +6054,7 @@
       height,
       data: decodedData,
       compressed,
+      levelSize: decodedSize,
       hasAlpha: alphaFlag,
       format
     };
@@ -6228,7 +6095,7 @@
   // ../textures/src/basis-loader.ts
   var BasisWorkerLoader = {
     name: "Basis",
-    id: "basis",
+    id: isBrowser2 ? "basis" : "basis-nodejs",
     module: "textures",
     version: VERSION6,
     worker: true,
@@ -6605,7 +6472,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,
@@ -7240,11 +7107,11 @@
     }
   }
   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
+    UInt8: esm_default.UNSIGNED_BYTE,
+    UInt16: esm_default.UNSIGNED_SHORT,
+    Float32: esm_default.FLOAT,
+    UInt32: esm_default.UNSIGNED_INT,
+    UInt64: esm_default.DOUBLE
   };
   function sizeOf(dataType) {
     switch (dataType) {
@@ -7265,6 +7132,10 @@
         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";
@@ -7274,6 +7145,145 @@
     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.6" : "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/customizeColors.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;
+      }
+      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 scratchVector5 = new Vector3([0, 0, 0]);
   function getLoaderForTextureFormat(textureFormat) {
@@ -7290,29 +7300,36 @@
     }
   }
   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.attributes = {};
-    if (tile.textureUrl) {
-      const url = getUrlWithToken(tile.textureUrl, options?.i3s?.token);
-      const loader = getLoaderForTextureFormat(tile.textureFormat);
-      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" } };
+          const options2 = { ...tileOptions.textureLoaderOptions, image: { type: "data" } };
           try {
-            tile.content.texture = await context.parse(arrayBuffer2, options2);
+            content.texture = await context.parse(arrayBuffer2, options2);
           } catch (e2) {
-            tile.content.texture = await parse(arrayBuffer2, loader, options2);
+            content.texture = await parse(arrayBuffer2, loader, options2);
           }
         } else if (loader === CompressedTextureLoader || loader === BasisLoader) {
-          let texture = await load(arrayBuffer2, loader, tile.textureLoaderOptions);
+          let texture = await load(arrayBuffer2, loader, tileOptions.textureLoaderOptions);
           if (loader === BasisLoader) {
             texture = texture[0];
           }
-          tile.content.texture = {
+          content.texture = {
             compressed: true,
             mipmaps: false,
             width: texture[0].width,
@@ -7321,26 +7338,23 @@
           };
         }
       } 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, tileset, options);
+    return await parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOptions, options);
   }
-  async function parseI3SNodeGeometry(arrayBuffer, tile, tileset, options) {
-    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;
     let indices;
-    if (tile.isDracoGeometry) {
+    if (tileOptions.isDracoGeometry) {
       const decompressedGeometry = await parse(arrayBuffer, DracoLoader2, {
         draco: {
           attributeNameEntry: I3S_ATTRIBUTE_TYPE
@@ -7375,8 +7389,8 @@
         ordering: attributesOrder,
         featureAttributes,
         featureAttributeOrder
-      } = tileset.store.defaultGeometrySchema;
-      const headers = parseHeaders(tileset, arrayBuffer);
+      } = tilesetOptions.store.defaultGeometrySchema;
+      const headers = parseHeaders(arrayBuffer, tilesetOptions);
       byteOffset = headers.byteOffset;
       vertexCount = headers.vertexCount;
       featureCount = headers.featureCount;
@@ -7386,23 +7400,24 @@
       attributes = concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes);
     }
     if (!options?.i3s?.coordinateSystem || options.i3s.coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) {
-      const enuMatrix = parsePositions(attributes.position, tile);
+      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 = 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]) {
@@ -7410,8 +7425,8 @@
       }
     }
     content.vertexCount = vertexCount;
-    content.byteLength = arrayBuffer.byteLength;
-    return tile;
+    content.byteLength = contentByteLength;
+    return content;
   }
   function updateAttributesMetadata(attributes, decompressedGeometry) {
     for (const key in decompressedGeometry.loaderData.attributes) {
@@ -7438,11 +7453,11 @@
     attribute.normalized = true;
     return attribute;
   }
-  function parseHeaders(tileset, arrayBuffer) {
+  function parseHeaders(arrayBuffer, options) {
     let byteOffset = 0;
     let vertexCount = 0;
     let featureCount = 0;
-    for (const { property, type } of tileset.store.defaultGeometrySchema.header) {
+    for (const { property, type } of options.store.defaultGeometrySchema.header) {
       const TypedArrayTypeHeader = getConstructorForDataFormat(type);
       switch (property) {
         case HeaderAttributeProperty.vertexCount:
@@ -7463,38 +7478,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 = getConstructorForDataFormat(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 };
@@ -7512,8 +7527,8 @@
     }
     return new Uint32Array(values);
   }
-  function parsePositions(attribute, tile) {
-    const mbs = tile.mbs;
+  function parsePositions(attribute, options) {
+    const mbs = options.mbs;
     const value = attribute.value;
     const metadata = attribute.metadata;
     const enuMatrix = new Matrix4();
@@ -7645,13 +7660,13 @@
   }
 
   // src/i3s-content-loader.ts
-  var VERSION8 = true ? "4.0.0-alpha.5" : "beta";
+  var VERSION9 = true ? "4.0.0-alpha.6" : "beta";
   var I3SContentLoader = {
     name: "I3S Content (Indexed Scene Layers)",
-    id: "i3s-content",
+    id: isBrowser2 ? "i3s-content" : "i3s-content-nodejs",
     module: "i3s",
     worker: true,
-    version: VERSION8,
+    version: VERSION9,
     mimeTypes: ["application/octet-stream"],
     parse: parse3,
     extensions: ["bin"],
@@ -7660,9 +7675,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