@loaders.gl/i3s 3.1.6 → 3.2.0-alpha.1

package/dist/i3s-content-worker.js

@@ -55,7 +55,7 @@
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
   // ../worker-utils/src/lib/env-utils/version.ts
-  var VERSION = true ? "3.1.6" : DEFAULT_VERSION;
+  var VERSION = true ? "3.2.0-alpha.1" : 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,13 +87,13 @@
   // ../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.name = jobName;
+      this.workerThread = workerThread;
       this.result = new Promise((resolve, reject) => {
         this._resolve = resolve;
         this._reject = reject;
@@ -118,6 +118,16 @@
     }
   };
 
+  // ../worker-utils/src/lib/node/worker_threads-browser.js
+  var Worker2 = class {
+    on(message, cb) {
+    }
+    postMessage(...args) {
+    }
+    terminate() {
+    }
+  };
+
   // ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
   var workerURLCache = new Map();
   function getLoadableWorkerURL(props) {
@@ -205,10 +215,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;
     }
     destroy() {
       this.onMessage = NOOP;
@@ -251,6 +261,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 +302,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 +394,9 @@
   var DEFAULT_PROPS = {
     maxConcurrency: 3,
     maxMobileConcurrency: 1,
+    reuseWorkers: true,
     onDebug: () => {
-    },
-    reuseWorkers: true
+    }
   };
   var WorkerFarm = class {
     constructor(props) {
@@ -383,6 +417,7 @@
       for (const workerPool of this.workerPools.values()) {
         workerPool.destroy();
       }
+      this.workerPools = new Map();
     }
     setProps(props) {
       this.props = { ...this.props, ...props };
@@ -415,16 +450,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 +485,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);
       }
     }
   };
@@ -458,7 +524,7 @@
   }
 
   // ../worker-utils/src/lib/worker-api/get-worker-url.ts
-  var NPM_TAG = "latest";
+  var NPM_TAG = "beta";
   function getWorkerURL(worker, options = {}) {
     const workerOptions = options[worker.id] || {};
     const workerFile = `${worker.id}-worker.js`;
@@ -493,7 +559,7 @@
 
   // ../worker-utils/src/lib/library-utils/library-utils.ts
   var node = __toModule(require_require_utils());
-  var LATEST = "latest";
+  var LATEST = "beta";
   var VERSION2 = typeof VERSION !== "undefined" ? VERSION : LATEST;
   var loadLibraryPromises = {};
   async function loadLibrary(libraryUrl, moduleName = null, options = {}) {
@@ -564,7 +630,7 @@
   // ../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) => {
@@ -640,6 +706,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) {
@@ -750,6 +819,21 @@
     return concatenateArrayBuffers(...arrayBuffers);
   }
 
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  function _defineProperty(obj, key, value) {
+    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 = {};
@@ -1001,7 +1085,7 @@
   var process_ = globals3.process || {};
 
   // ../../node_modules/probe.gl/dist/esm/utils/globals.js
-  var VERSION3 = true ? "3.1.6" : "untranspiled source";
+  var VERSION3 = true ? "3.2.0-alpha.1" : "untranspiled source";
   var isBrowser4 = isBrowser3();
 
   // ../../node_modules/probe.gl/dist/esm/utils/local-storage.js
@@ -1534,7 +1618,8 @@
     worker: true,
     maxConcurrency: 3,
     maxMobileConcurrency: 1,
-    reuseWorkers: true,
+    reuseWorkers: isBrowser,
+    _nodeWorkers: false,
     _workerType: "",
     limit: 0,
     _limitMB: 0,
@@ -1710,6 +1795,555 @@
     return getGlobalLoaderRegistry();
   }
 
+  // ../../node_modules/@probe.gl/env/dist/esm/lib/is-electron.js
+  function isElectron2(mockUserAgent) {
+    if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
+      return true;
+    }
+    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions.electron)) {
+      return true;
+    }
+    const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent;
+    const userAgent = mockUserAgent || realUserAgent;
+    if (userAgent && userAgent.indexOf("Electron") >= 0) {
+      return true;
+    }
+    return false;
+  }
+
+  // ../../node_modules/@probe.gl/env/dist/esm/lib/is-browser.js
+  function isBrowser5() {
+    const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
+    return !isNode || isElectron2();
+  }
+
+  // ../../node_modules/@probe.gl/env/dist/esm/lib/globals.js
+  var globals4 = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document,
+    process: typeof process === "object" && process
+  };
+  var self_4 = globals4.self || globals4.window || globals4.global;
+  var window_4 = globals4.window || globals4.self || globals4.global;
+  var document_4 = globals4.document || {};
+  var process_2 = globals4.process || {};
+
+  // ../../node_modules/@probe.gl/env/dist/esm/utils/globals.js
+  var VERSION4 = true ? "3.2.0-alpha.1" : "untranspiled source";
+  var isBrowser6 = isBrowser5();
+
+  // ../../node_modules/@probe.gl/log/dist/esm/utils/local-storage.js
+  function getStorage2(type) {
+    try {
+      const storage = window[type];
+      const x = "__storage_test__";
+      storage.setItem(x, x);
+      storage.removeItem(x);
+      return storage;
+    } catch (e2) {
+      return null;
+    }
+  }
+  var LocalStorage2 = class {
+    constructor(id) {
+      let defaultSettings = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      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", {});
+      this.storage = getStorage2(type);
+      this.id = id;
+      this.config = {};
+      Object.assign(this.config, defaultSettings);
+      this._loadConfiguration();
+    }
+    getConfiguration() {
+      return this.config;
+    }
+    setConfiguration(configuration) {
+      this.config = {};
+      return this.updateConfiguration(configuration);
+    }
+    updateConfiguration(configuration) {
+      Object.assign(this.config, configuration);
+      if (this.storage) {
+        const serialized = JSON.stringify(this.config);
+        this.storage.setItem(this.id, serialized);
+      }
+      return this;
+    }
+    _loadConfiguration() {
+      let configuration = {};
+      if (this.storage) {
+        const serializedConfiguration = this.storage.getItem(this.id);
+        configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
+      }
+      Object.assign(this.config, configuration);
+      return this;
+    }
+  };
+
+  // ../../node_modules/@probe.gl/log/dist/esm/utils/formatters.js
+  function formatTime2(ms) {
+    let formatted;
+    if (ms < 10) {
+      formatted = "".concat(ms.toFixed(2), "ms");
+    } else if (ms < 100) {
+      formatted = "".concat(ms.toFixed(1), "ms");
+    } else if (ms < 1e3) {
+      formatted = "".concat(ms.toFixed(0), "ms");
+    } else {
+      formatted = "".concat((ms / 1e3).toFixed(2), "s");
+    }
+    return formatted;
+  }
+  function leftPad2(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 formatImage2(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);
+    }
+    const width = image.width * scale2;
+    const height = image.height * scale2;
+    const style = ["font-size:1px;", "padding:".concat(Math.floor(height / 2), "px ").concat(Math.floor(width / 2), "px;"), "line-height:".concat(height, "px;"), "background:url(".concat(imageUrl, ");"), "background-size:".concat(width, "px ").concat(height, "px;"), "color:transparent;"].join("");
+    return ["".concat(message, " %c+"), style];
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/esm/utils/color.js
+  var COLOR2;
+  (function(COLOR3) {
+    COLOR3[COLOR3["BLACK"] = 30] = "BLACK";
+    COLOR3[COLOR3["RED"] = 31] = "RED";
+    COLOR3[COLOR3["GREEN"] = 32] = "GREEN";
+    COLOR3[COLOR3["YELLOW"] = 33] = "YELLOW";
+    COLOR3[COLOR3["BLUE"] = 34] = "BLUE";
+    COLOR3[COLOR3["MAGENTA"] = 35] = "MAGENTA";
+    COLOR3[COLOR3["CYAN"] = 36] = "CYAN";
+    COLOR3[COLOR3["WHITE"] = 37] = "WHITE";
+    COLOR3[COLOR3["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+    COLOR3[COLOR3["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+    COLOR3[COLOR3["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+    COLOR3[COLOR3["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+    COLOR3[COLOR3["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+    COLOR3[COLOR3["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+    COLOR3[COLOR3["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+    COLOR3[COLOR3["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+  })(COLOR2 || (COLOR2 = {}));
+  function getColor2(color) {
+    return typeof color === "string" ? COLOR2[color.toUpperCase()] || COLOR2.WHITE : color;
+  }
+  function addColor2(string, color, background) {
+    if (!isBrowser5 && typeof string === "string") {
+      if (color) {
+        color = getColor2(color);
+        string = "[".concat(color, "m").concat(string, "");
+      }
+      if (background) {
+        color = getColor2(background);
+        string = "[".concat(background + 10, "m").concat(string, "");
+      }
+    }
+    return string;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/esm/utils/autobind.js
+  function autobind2(obj) {
+    let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"];
+    const proto = Object.getPrototypeOf(obj);
+    const propNames = Object.getOwnPropertyNames(proto);
+    for (const key of propNames) {
+      if (typeof obj[key] === "function") {
+        if (!predefined.find((name) => key === name)) {
+          obj[key] = obj[key].bind(obj);
+        }
+      }
+    }
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/esm/utils/assert.js
+  function assert4(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failed");
+    }
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/esm/utils/hi-res-timestamp.js
+  function getHiResTimestamp3() {
+    let timestamp;
+    if (isBrowser5 && "performance" in window_4) {
+      var _window$performance, _window$performance$n;
+      timestamp = window_4 === null || window_4 === void 0 ? void 0 : (_window$performance = window_4.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_2) {
+      var _process$hrtime;
+      const timeParts = process_2 === null || process_2 === void 0 ? void 0 : (_process$hrtime = process_2.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_2);
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
+    }
+    return timestamp;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/esm/log.js
+  var originalConsole2 = {
+    debug: isBrowser5 ? console.debug || console.log : console.log,
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  var DEFAULT_SETTINGS2 = {
+    enabled: true,
+    level: 0
+  };
+  function noop2() {
+  }
+  var cache2 = {};
+  var ONCE2 = {
+    once: true
+  };
+  var Log2 = class {
+    constructor() {
+      let {
+        id
+      } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+        id: ""
+      };
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "VERSION", VERSION4);
+      _defineProperty(this, "_startTs", getHiResTimestamp3());
+      _defineProperty(this, "_deltaTs", getHiResTimestamp3());
+      _defineProperty(this, "_storage", void 0);
+      _defineProperty(this, "userData", {});
+      _defineProperty(this, "LOG_THROTTLE_TIMEOUT", 0);
+      this.id = id;
+      this._storage = new LocalStorage2("__probe-".concat(this.id, "__"), DEFAULT_SETTINGS2);
+      this.userData = {};
+      this.timeStamp("".concat(this.id, " started"));
+      autobind2(this);
+      Object.seal(this);
+    }
+    set level(newLevel) {
+      this.setLevel(newLevel);
+    }
+    get level() {
+      return this.getLevel();
+    }
+    isEnabled() {
+      return this._storage.config.enabled;
+    }
+    getLevel() {
+      return this._storage.config.level;
+    }
+    getTotal() {
+      return Number((getHiResTimestamp3() - this._startTs).toPrecision(10));
+    }
+    getDelta() {
+      return Number((getHiResTimestamp3() - this._deltaTs).toPrecision(10));
+    }
+    set priority(newPriority) {
+      this.level = newPriority;
+    }
+    get priority() {
+      return this.level;
+    }
+    getPriority() {
+      return this.level;
+    }
+    enable() {
+      let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+      this._storage.updateConfiguration({
+        enabled
+      });
+      return this;
+    }
+    setLevel(level) {
+      this._storage.updateConfiguration({
+        level
+      });
+      return this;
+    }
+    get(setting) {
+      return this._storage.config[setting];
+    }
+    set(setting, value) {
+      this._storage.updateConfiguration({
+        [setting]: value
+      });
+    }
+    settings() {
+      if (console.table) {
+        console.table(this._storage.config);
+      } else {
+        console.log(this._storage.config);
+      }
+    }
+    assert(condition, message) {
+      assert4(condition, message);
+    }
+    warn(message) {
+      return this._getLogFunction(0, message, originalConsole2.warn, arguments, ONCE2);
+    }
+    error(message) {
+      return this._getLogFunction(0, message, originalConsole2.error, arguments);
+    }
+    deprecated(oldUsage, newUsage) {
+      return this.warn("`".concat(oldUsage, "` is deprecated and will be removed in a later version. Use `").concat(newUsage, "` instead"));
+    }
+    removed(oldUsage, newUsage) {
+      return this.error("`".concat(oldUsage, "` has been removed. Use `").concat(newUsage, "` instead"));
+    }
+    probe(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole2.log, arguments, {
+        time: true,
+        once: true
+      });
+    }
+    log(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole2.debug, arguments);
+    }
+    info(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.info, arguments);
+    }
+    once(logLevel, message) {
+      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        args[_key - 2] = arguments[_key];
+      }
+      return this._getLogFunction(logLevel, message, originalConsole2.debug || originalConsole2.info, arguments, ONCE2);
+    }
+    table(logLevel, table, columns) {
+      if (table) {
+        return this._getLogFunction(logLevel, table, console.table || noop2, columns && [columns], {
+          tag: getTableHeader2(table)
+        });
+      }
+      return noop2;
+    }
+    image(_ref) {
+      let {
+        logLevel,
+        priority,
+        image,
+        message = "",
+        scale: scale2 = 1
+      } = _ref;
+      if (!this._shouldLog(logLevel || priority)) {
+        return noop2;
+      }
+      return isBrowser5 ? logImageInBrowser2({
+        image,
+        message,
+        scale: scale2
+      }) : logImageInNode2({
+        image,
+        message,
+        scale: scale2
+      });
+    }
+    time(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
+    }
+    timeEnd(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
+    }
+    timeStamp(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.timeStamp || noop2);
+    }
+    group(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
+        collapsed: false
+      };
+      const options = normalizeArguments2({
+        logLevel,
+        message,
+        opts
+      });
+      const {
+        collapsed
+      } = opts;
+      options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
+      return this._getLogFunction(options);
+    }
+    groupCollapsed(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      return this.group(logLevel, message, Object.assign({}, opts, {
+        collapsed: true
+      }));
+    }
+    groupEnd(logLevel) {
+      return this._getLogFunction(logLevel, "", console.groupEnd || noop2);
+    }
+    withGroup(logLevel, message, func) {
+      this.group(logLevel, message)();
+      try {
+        func();
+      } finally {
+        this.groupEnd(logLevel)();
+      }
+    }
+    trace() {
+      if (console.trace) {
+        console.trace();
+      }
+    }
+    _shouldLog(logLevel) {
+      return this.isEnabled() && this.getLevel() >= normalizeLogLevel2(logLevel);
+    }
+    _getLogFunction(logLevel, message, method, args, opts) {
+      if (this._shouldLog(logLevel)) {
+        opts = normalizeArguments2({
+          logLevel,
+          message,
+          args,
+          opts
+        });
+        method = method || opts.method;
+        assert4(method);
+        opts.total = this.getTotal();
+        opts.delta = this.getDelta();
+        this._deltaTs = getHiResTimestamp3();
+        const tag = opts.tag || opts.message;
+        if (opts.once) {
+          if (!cache2[tag]) {
+            cache2[tag] = getHiResTimestamp3();
+          } else {
+            return noop2;
+          }
+        }
+        message = decorateMessage2(this.id, opts.message, opts);
+        return method.bind(console, message, ...opts.args);
+      }
+      return noop2;
+    }
+  };
+  _defineProperty(Log2, "VERSION", VERSION4);
+  function normalizeLogLevel2(logLevel) {
+    if (!logLevel) {
+      return 0;
+    }
+    let resolvedLevel;
+    switch (typeof logLevel) {
+      case "number":
+        resolvedLevel = logLevel;
+        break;
+      case "object":
+        resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+        break;
+      default:
+        return 0;
+    }
+    assert4(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+    return resolvedLevel;
+  }
+  function normalizeArguments2(opts) {
+    const {
+      logLevel,
+      message
+    } = opts;
+    opts.logLevel = normalizeLogLevel2(logLevel);
+    const args = opts.args ? Array.from(opts.args) : [];
+    while (args.length && args.shift() !== message) {
+    }
+    switch (typeof logLevel) {
+      case "string":
+      case "function":
+        if (message !== void 0) {
+          args.unshift(message);
+        }
+        opts.message = logLevel;
+        break;
+      case "object":
+        Object.assign(opts, logLevel);
+        break;
+      default:
+    }
+    if (typeof opts.message === "function") {
+      opts.message = opts.message();
+    }
+    const messageType = typeof opts.message;
+    assert4(messageType === "string" || messageType === "object");
+    return Object.assign(opts, {
+      args
+    }, opts.opts);
+  }
+  function decorateMessage2(id, message, opts) {
+    if (typeof message === "string") {
+      const time = opts.time ? leftPad2(formatTime2(opts.total)) : "";
+      message = opts.time ? "".concat(id, ": ").concat(time, "  ").concat(message) : "".concat(id, ": ").concat(message);
+      message = addColor2(message, opts.color, opts.background);
+    }
+    return message;
+  }
+  function logImageInNode2(_ref2) {
+    let {
+      image,
+      message = "",
+      scale: scale2 = 1
+    } = _ref2;
+    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));
+    }
+    return noop2;
+  }
+  function logImageInBrowser2(_ref3) {
+    let {
+      image,
+      message = "",
+      scale: scale2 = 1
+    } = _ref3;
+    if (typeof image === "string") {
+      const img = new Image();
+      img.onload = () => {
+        const args = formatImage2(img, message, scale2);
+        console.log(...args);
+      };
+      img.src = image;
+      return noop2;
+    }
+    const element = image.nodeName || "";
+    if (element.toLowerCase() === "img") {
+      console.log(...formatImage2(image, message, scale2));
+      return noop2;
+    }
+    if (element.toLowerCase() === "canvas") {
+      const img = new Image();
+      img.onload = () => console.log(...formatImage2(img, message, scale2));
+      img.src = image.toDataURL();
+      return noop2;
+    }
+    return noop2;
+  }
+  function getTableHeader2(table) {
+    for (const key in table) {
+      for (const title in table[key]) {
+        return title || "untitled";
+      }
+    }
+    return "empty";
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/esm/index.js
+  var esm_default2 = new Log2({
+    id: "@probe.gl/log"
+  });
+
+  // ../core/src/lib/utils/log.ts
+  var log = new Log2({ id: "loaders.gl" });
+
   // ../core/src/lib/api/select-loader.ts
   var EXT_PATTERN = /\.([^.]+)$/;
   async function selectLoader(data, loaders = [], options, context) {
@@ -1754,13 +2388,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) {
@@ -2118,7 +2761,7 @@
   }
 
   // ../../node_modules/@math.gl/core/dist/esm/lib/assert.js
-  function assert4(condition, message) {
+  function assert5(condition, message) {
     if (!condition) {
       throw new Error("math.gl assertion ".concat(message));
     }
@@ -2230,7 +2873,7 @@
   }
   var MathArray = class extends _extendableBuiltin(Array) {
     get ELEMENTS() {
-      assert4(false);
+      assert5(false);
       return 0;
     }
     clone() {
@@ -2445,11 +3088,11 @@
   // ../../node_modules/@math.gl/core/dist/esm/classes/base/vector.js
   var Vector = class extends MathArray {
     get ELEMENTS() {
-      assert4(false);
+      assert5(false);
       return 0;
     }
     copy(vector) {
-      assert4(false);
+      assert5(false);
       return this;
     }
     get x() {
@@ -2533,11 +3176,11 @@
       return this.distanceSquared(vector);
     }
     getComponent(i2) {
-      assert4(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
+      assert5(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
       return checkNumber(this[i2]);
     }
     setComponent(i2, value) {
-      assert4(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
+      assert5(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
       this[i2] = value;
       return this.check();
     }
@@ -2885,11 +3528,11 @@
   // ../../node_modules/@math.gl/core/dist/esm/classes/base/matrix.js
   var Matrix = class extends MathArray {
     get ELEMENTS() {
-      assert4(false);
+      assert5(false);
       return 0;
     }
     get RANK() {
-      assert4(false);
+      assert5(false);
       return 0;
     }
     toString() {
@@ -3944,13 +4587,13 @@
   };
 
   // ../../node_modules/@math.gl/core/dist/esm/index.js
-  var globals4 = {
+  var globals5 = {
     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 = {
+  var global_5 = globals5.global || globals5.self || globals5.window;
+  global_5.mathgl = {
     config
   };
 
@@ -3968,9 +4611,9 @@
   };
 
   // ../../node_modules/@math.gl/geospatial/dist/esm/type-utils.js
-  var noop2 = (x) => x;
+  var noop3 = (x) => x;
   var scratchVector = new Vector3();
-  function fromCartographic(cartographic, result, map3 = noop2) {
+  function fromCartographic(cartographic, result, map3 = noop3) {
     if (isArray(cartographic)) {
       result[0] = map3(cartographic[0]);
       result[1] = map3(cartographic[1]);
@@ -3987,9 +4630,9 @@
     return result;
   }
   function fromCartographicToRadians(cartographic, vector = scratchVector) {
-    return fromCartographic(cartographic, vector, config._cartographicRadians ? noop2 : toRadians);
+    return fromCartographic(cartographic, vector, config._cartographicRadians ? noop3 : toRadians);
   }
-  function toCartographic(vector, cartographic, map3 = noop2) {
+  function toCartographic(vector, cartographic, map3 = noop3) {
     if (isArray(cartographic)) {
       cartographic[0] = map3(vector[0]);
       cartographic[1] = map3(vector[1]);
@@ -4006,7 +4649,7 @@
     return cartographic;
   }
   function toCartographicFromRadians(vector, cartographic) {
-    return toCartographic(vector, cartographic, config._cartographicRadians ? noop2 : toDegrees);
+    return toCartographic(vector, cartographic, config._cartographicRadians ? noop3 : toDegrees);
   }
 
   // ../../node_modules/@math.gl/geospatial/dist/esm/ellipsoid/helpers/scale-to-geodetic-surface.js
@@ -4131,7 +4774,7 @@
   var scratchVector3 = new Vector3();
   function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {
     const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
-    assert4(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
+    assert5(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
     let firstAxisVector;
     let secondAxisVector;
     let thirdAxisVector;
@@ -4205,9 +4848,9 @@
       return wgs84;
     }
     constructor(x = 0, y = 0, z = 0) {
-      assert4(x >= 0);
-      assert4(y >= 0);
-      assert4(z >= 0);
+      assert5(x >= 0);
+      assert5(y >= 0);
+      assert5(z >= 0);
       this.radii = new Vector3(x, y, z);
       this.radiiSquared = new Vector3(x * x, y * y, z * z);
       this.radiiToTheFourth = new Vector3(x * x * x * x, y * y * y * y, z * z * z * z);
@@ -4292,8 +4935,8 @@
       return scratchPosition.from(position).scale(this.radii).to(result);
     }
     getSurfaceNormalIntersectionWithZAxis(position, buffer = 0, result = [0, 0, 0]) {
-      assert4(equals(this.radii.x, this.radii.y, math_utils_default.EPSILON15));
-      assert4(this.radii.z > 0);
+      assert5(equals(this.radii.x, this.radii.y, math_utils_default.EPSILON15));
+      assert5(this.radii.z > 0);
       scratchPosition.from(position);
       const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);
       if (Math.abs(z) >= this.radii.z - buffer) {
@@ -4304,7 +4947,7 @@
   };
 
   // ../images/src/lib/utils/version.ts
-  var VERSION4 = true ? "3.1.6" : "latest";
+  var VERSION5 = true ? "3.2.0-alpha.1" : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var { _parseImageNode } = globalThis;
@@ -4643,7 +5286,7 @@
     id: "image",
     module: "images",
     name: "Images",
-    version: VERSION4,
+    version: VERSION5,
     mimeTypes: MIME_TYPES,
     extensions: EXTENSIONS,
     parse: parseImage,
@@ -4652,7 +5295,7 @@
   };
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION5 = true ? "3.1.6" : "latest";
+  var VERSION6 = true ? "3.2.0-alpha.1" : "latest";
 
   // ../draco/src/draco-loader.ts
   var DEFAULT_DRACO_OPTIONS = {
@@ -4668,7 +5311,7 @@
     id: "draco",
     module: "draco",
     shapes: ["mesh"],
-    version: VERSION5,
+    version: VERSION6,
     worker: true,
     extensions: ["drc"],
     mimeTypes: ["application/octet-stream"],
@@ -4705,7 +5348,7 @@
   }
 
   // ../schema/src/lib/utils/assert.ts
-  function assert5(condition, message) {
+  function assert6(condition, message) {
     if (!condition) {
       throw new Error(message || "loader assertion failed.");
     }
@@ -4714,7 +5357,7 @@
   // ../schema/src/lib/schema/impl/schema.ts
   var Schema = class {
     constructor(fields, metadata) {
-      assert5(Array.isArray(fields));
+      assert6(Array.isArray(fields));
       checkNames(fields);
       this.fields = fields;
       this.metadata = metadata || new Map();
@@ -5636,12 +6279,12 @@
   }
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION6 = true ? "3.1.6" : "latest";
+  var VERSION7 = true ? "3.2.0-alpha.1" : "beta";
 
   // ../textures/src/lib/parsers/basis-module-loader.ts
-  var VERSION7 = true ? "3.1.6" : "latest";
-  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 VERSION8 = true ? "3.2.0-alpha.1" : "beta";
+  var BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION8}/dist/libs/basis_encoder.wasm`;
+  var BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION8}/dist/libs/basis_encoder.js`;
   var loadBasisTranscoderPromise;
   async function loadBasisTrascoderModule(options) {
     const modules = options.modules || {};
@@ -6120,7 +6763,7 @@
     const basisFile = new BasisFile(new Uint8Array(data));
     try {
       if (!basisFile.startTranscoding()) {
-        return null;
+        throw new Error("Failed to start basis transcoding");
       }
       const imageCount = basisFile.getNumImages();
       const images = [];
@@ -6146,22 +6789,22 @@
     const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
     const decodedData = new Uint8Array(decodedSize);
     if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
-      return null;
+      throw new Error("failed to start Basis transcoding");
     }
     return {
       width,
       height,
       data: decodedData,
       compressed,
-      hasAlpha,
-      format
+      format,
+      hasAlpha
     };
   }
   function parseKTX2File(KTX2File, data, options) {
     const ktx2File = new KTX2File(new Uint8Array(data));
     try {
       if (!ktx2File.startTranscoding()) {
-        return null;
+        throw new Error("failed to start KTX2 transcoding");
       }
       const levelsCount = ktx2File.getLevels();
       const levels = [];
@@ -6169,7 +6812,7 @@
         levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
         break;
       }
-      return levels;
+      return [levels];
     } finally {
       ktx2File.close();
       ktx2File.delete();
@@ -6181,14 +6824,14 @@
     const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0, 0, basisFormat);
     const decodedData = new Uint8Array(decodedSize);
     if (!ktx2File.transcodeImage(decodedData, levelIndex, 0, 0, basisFormat, 0, -1, -1)) {
-      return null;
+      throw new Error("Failed to transcode KTX2 image");
     }
     return {
       width,
       height,
       data: decodedData,
       compressed,
-      alphaFlag,
+      hasAlpha: alphaFlag,
       format
     };
   }
@@ -6230,7 +6873,7 @@
     name: "Basis",
     id: "basis",
     module: "textures",
-    version: VERSION6,
+    version: VERSION7,
     worker: true,
     extensions: ["basis", "ktx2"],
     mimeTypes: ["application/octet-stream", "image/ktx2"],
@@ -6543,7 +7186,7 @@
     name: "Texture Containers",
     id: "compressed-texture",
     module: "textures",
-    version: VERSION6,
+    version: VERSION7,
     worker: true,
     extensions: [
       "ktx",
@@ -6574,7 +7217,7 @@
           containerFormat: "ktx2",
           module: "encoder"
         };
-        return await parseBasis(arrayBuffer, options);
+        return (await parseBasis(arrayBuffer, options))[0];
       }
       return parseCompressedTexture(arrayBuffer);
     }
@@ -6605,7 +7248,7 @@
   }
 
   // ../../node_modules/@luma.gl/constants/dist/esm/index.js
-  var esm_default2 = {
+  var esm_default3 = {
     DEPTH_BUFFER_BIT: 256,
     STENCIL_BUFFER_BIT: 1024,
     COLOR_BUFFER_BIT: 16384,
@@ -7240,11 +7883,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_default3.UNSIGNED_BYTE,
+    UInt16: esm_default3.UNSIGNED_INT,
+    Float32: esm_default3.FLOAT,
+    UInt32: esm_default3.UNSIGNED_INT,
+    UInt64: esm_default3.DOUBLE
   };
   function sizeOf(dataType) {
     switch (dataType) {
@@ -7308,7 +7951,10 @@
             tile.content.texture = await parse(arrayBuffer2, loader, options2);
           }
         } else if (loader === CompressedTextureLoader || loader === BasisLoader) {
-          const texture = await load(arrayBuffer2, loader, tile.textureLoaderOptions);
+          let texture = await load(arrayBuffer2, loader, tile.textureLoaderOptions);
+          if (loader === BasisLoader) {
+            texture = texture[0];
+          }
           tile.content.texture = {
             compressed: true,
             mipmaps: false,
@@ -7460,38 +8106,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 };
@@ -7642,13 +8288,13 @@
   }
 
   // src/i3s-content-loader.ts
-  var VERSION8 = true ? "3.1.6" : "latest";
+  var VERSION9 = true ? "3.2.0-alpha.1" : "beta";
   var I3SContentLoader = {
     name: "I3S Content (Indexed Scene Layers)",
     id: "i3s-content",
     module: "i3s",
     worker: true,
-    version: VERSION8,
+    version: VERSION9,
     mimeTypes: ["application/octet-stream"],
     parse: parse3,
     extensions: ["bin"],