@loaders.gl/scene 5.0.0-beta.6 → 5.0.0-beta.8

package/dist/draco-worker-node.js

@@ -41,6 +41,691 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../../node_modules/probe.gl/dist/env/lib/globals.js
+var window_, document_, process_, console_, navigator_;
+var init_globals = __esm({
+  "../../node_modules/probe.gl/dist/env/lib/globals.js"() {
+    window_ = globalThis;
+    document_ = globalThis.document || {};
+    process_ = globalThis.process || {};
+    console_ = globalThis.console;
+    navigator_ = globalThis.navigator || {};
+  }
+});
+
+// ../../node_modules/probe.gl/dist/env/lib/is-electron.js
+function isElectron(mockUserAgent) {
+  var _a5, _b2;
+  if (typeof window !== "undefined" && ((_a5 = window.process) == null ? void 0 : _a5.type) === "renderer") {
+    return true;
+  }
+  if (typeof process !== "undefined" && Boolean((_b2 = process.versions) == null ? void 0 : _b2["electron"])) {
+    return true;
+  }
+  const realUserAgent = typeof navigator !== "undefined" && navigator.userAgent;
+  const userAgent = mockUserAgent || realUserAgent;
+  return Boolean(userAgent && userAgent.indexOf("Electron") >= 0);
+}
+var init_is_electron = __esm({
+  "../../node_modules/probe.gl/dist/env/lib/is-electron.js"() {
+  }
+});
+
+// ../../node_modules/probe.gl/dist/env/lib/is-browser.js
+function isBrowser() {
+  const isNode = (
+    // @ts-expect-error
+    typeof process === "object" && String(process) === "[object process]" && !(process == null ? void 0 : process.browser)
+  );
+  return !isNode || isElectron();
+}
+var init_is_browser = __esm({
+  "../../node_modules/probe.gl/dist/env/lib/is-browser.js"() {
+    init_is_electron();
+  }
+});
+
+// ../../node_modules/probe.gl/dist/env/lib/get-browser.js
+var init_get_browser = __esm({
+  "../../node_modules/probe.gl/dist/env/lib/get-browser.js"() {
+    init_is_browser();
+    init_is_electron();
+    init_globals();
+  }
+});
+
+// ../../node_modules/probe.gl/dist/env/utils/assert.js
+var init_assert = __esm({
+  "../../node_modules/probe.gl/dist/env/utils/assert.js"() {
+  }
+});
+
+// ../../node_modules/probe.gl/dist/env/index.js
+var VERSION;
+var init_env = __esm({
+  "../../node_modules/probe.gl/dist/env/index.js"() {
+    init_globals();
+    init_is_browser();
+    init_get_browser();
+    init_is_electron();
+    init_assert();
+    VERSION = true ? "5.0.0" : "untranspiled source";
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/utils/assert.js
+function assert2(condition, message) {
+  if (!condition) {
+    throw new Error(message || "Assertion failed");
+  }
+}
+var init_assert2 = __esm({
+  "../../node_modules/probe.gl/dist/log/utils/assert.js"() {
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/loggers/log-utils.js
+function normalizeLogLevel(logLevel) {
+  if (!logLevel) {
+    return 0;
+  }
+  let resolvedLevel;
+  switch (typeof logLevel) {
+    case "number":
+      resolvedLevel = logLevel;
+      break;
+    case "object":
+      resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+      break;
+    default:
+      return 0;
+  }
+  assert2(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+  return resolvedLevel;
+}
+function normalizeArguments(opts) {
+  const { logLevel, message } = opts;
+  opts.logLevel = normalizeLogLevel(logLevel);
+  const args = opts.args ? Array.from(opts.args) : [];
+  while (args.length && args.shift() !== message) {
+  }
+  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;
+  assert2(messageType === "string" || messageType === "object");
+  return Object.assign(opts, { args }, opts.opts);
+}
+var init_log_utils = __esm({
+  "../../node_modules/probe.gl/dist/log/loggers/log-utils.js"() {
+    init_assert2();
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/loggers/base-log.js
+var noop, BaseLog;
+var init_base_log = __esm({
+  "../../node_modules/probe.gl/dist/log/loggers/base-log.js"() {
+    init_log_utils();
+    noop = () => {
+    };
+    BaseLog = class {
+      constructor({ level = 0 } = {}) {
+        this.userData = {};
+        this._onceCache = /* @__PURE__ */ new Set();
+        this._level = level;
+      }
+      set level(newLevel) {
+        this.setLevel(newLevel);
+      }
+      get level() {
+        return this.getLevel();
+      }
+      setLevel(level) {
+        this._level = level;
+        return this;
+      }
+      getLevel() {
+        return this._level;
+      }
+      // Unconditional logging
+      warn(message, ...args) {
+        return this._log("warn", 0, message, args, { once: true });
+      }
+      error(message, ...args) {
+        return this._log("error", 0, message, args);
+      }
+      // Conditional logging
+      log(logLevel, message, ...args) {
+        return this._log("log", logLevel, message, args);
+      }
+      info(logLevel, message, ...args) {
+        return this._log("info", logLevel, message, args);
+      }
+      once(logLevel, message, ...args) {
+        return this._log("once", logLevel, message, args, { once: true });
+      }
+      _log(type, logLevel, message, args, options = {}) {
+        const normalized = normalizeArguments({
+          logLevel,
+          message,
+          args: this._buildArgs(logLevel, message, args),
+          opts: options
+        });
+        return this._createLogFunction(type, normalized, options);
+      }
+      _buildArgs(logLevel, message, args) {
+        return [logLevel, message, ...args];
+      }
+      _createLogFunction(type, normalized, options) {
+        if (!this._shouldLog(normalized.logLevel)) {
+          return noop;
+        }
+        const tag = this._getOnceTag(options.tag ?? normalized.tag ?? normalized.message);
+        if ((options.once || normalized.once) && tag !== void 0) {
+          if (this._onceCache.has(tag)) {
+            return noop;
+          }
+          this._onceCache.add(tag);
+        }
+        return this._emit(type, normalized);
+      }
+      _shouldLog(logLevel) {
+        return this.getLevel() >= normalizeLogLevel(logLevel);
+      }
+      _getOnceTag(tag) {
+        if (tag === void 0) {
+          return void 0;
+        }
+        try {
+          return typeof tag === "string" ? tag : String(tag);
+        } catch {
+          return void 0;
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/utils/local-storage.js
+function getStorage(type) {
+  try {
+    const storage = window[type];
+    const x = "__storage_test__";
+    storage.setItem(x, x);
+    storage.removeItem(x);
+    return storage;
+  } catch (e) {
+    return null;
+  }
+}
+var LocalStorage;
+var init_local_storage = __esm({
+  "../../node_modules/probe.gl/dist/log/utils/local-storage.js"() {
+    LocalStorage = class {
+      constructor(id, defaultConfig, type = "sessionStorage") {
+        this.storage = getStorage(type);
+        this.id = id;
+        this.config = defaultConfig;
+        this._loadConfiguration();
+      }
+      getConfiguration() {
+        return this.config;
+      }
+      setConfiguration(configuration) {
+        Object.assign(this.config, configuration);
+        if (this.storage) {
+          const serialized = JSON.stringify(this.config);
+          this.storage.setItem(this.id, serialized);
+        }
+      }
+      // Get config from persistent store, if available
+      _loadConfiguration() {
+        let configuration = {};
+        if (this.storage) {
+          const serializedConfiguration = this.storage.getItem(this.id);
+          configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
+        }
+        Object.assign(this.config, configuration);
+        return this;
+      }
+    };
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/utils/formatters.js
+function formatTime(ms) {
+  let formatted;
+  if (ms < 10) {
+    formatted = `${ms.toFixed(2)}ms`;
+  } else if (ms < 100) {
+    formatted = `${ms.toFixed(1)}ms`;
+  } else if (ms < 1e3) {
+    formatted = `${ms.toFixed(0)}ms`;
+  } else {
+    formatted = `${(ms / 1e3).toFixed(2)}s`;
+  }
+  return formatted;
+}
+function leftPad(string2, length = 8) {
+  const padLength = Math.max(length - string2.length, 0);
+  return `${" ".repeat(padLength)}${string2}`;
+}
+var init_formatters = __esm({
+  "../../node_modules/probe.gl/dist/log/utils/formatters.js"() {
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/utils/color.js
+function getColor(color2) {
+  if (typeof color2 !== "string") {
+    return color2;
+  }
+  color2 = color2.toUpperCase();
+  return COLOR[color2] || COLOR.WHITE;
+}
+function addColor(string2, color2, background) {
+  if (!isBrowser && typeof string2 === "string") {
+    if (color2) {
+      const colorCode = getColor(color2);
+      string2 = `\x1B[${colorCode}m${string2}\x1B[39m`;
+    }
+    if (background) {
+      const colorCode = getColor(background);
+      string2 = `\x1B[${colorCode + BACKGROUND_INCREMENT}m${string2}\x1B[49m`;
+    }
+  }
+  return string2;
+}
+var COLOR, BACKGROUND_INCREMENT;
+var init_color = __esm({
+  "../../node_modules/probe.gl/dist/log/utils/color.js"() {
+    init_env();
+    (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 = {}));
+    BACKGROUND_INCREMENT = 10;
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/utils/autobind.js
+function autobind(obj, predefined = ["constructor"]) {
+  const proto = Object.getPrototypeOf(obj);
+  const propNames = Object.getOwnPropertyNames(proto);
+  const object2 = obj;
+  for (const key of propNames) {
+    const value = object2[key];
+    if (typeof value === "function") {
+      if (!predefined.find((name) => key === name)) {
+        object2[key] = value.bind(obj);
+      }
+    }
+  }
+}
+var init_autobind = __esm({
+  "../../node_modules/probe.gl/dist/log/utils/autobind.js"() {
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/probe.js
+var Probe, probe;
+var init_probe = __esm({
+  "../../node_modules/probe.gl/dist/log/probe.js"() {
+    init_env();
+    Probe = class {
+      getHighResolutionTimer() {
+        var _a5, _b2, _c2, _d2, _e2;
+        let timestamp;
+        if (isBrowser() && window_.performance) {
+          timestamp = (_c2 = (_b2 = (_a5 = window_) == null ? void 0 : _a5.performance) == null ? void 0 : _b2.now) == null ? void 0 : _c2.call(_b2);
+        } else if ("hrtime" in process_) {
+          const timeParts = (_e2 = (_d2 = process_) == null ? void 0 : _d2.hrtime) == null ? void 0 : _e2.call(_d2);
+          timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+        } else {
+          timestamp = Date.now();
+        }
+        return timestamp;
+      }
+      getMemoryUsageMB() {
+        var _a5, _b2;
+        const performance2 = (_a5 = window_) == null ? void 0 : _a5.performance;
+        const usedJSHeapSize = (_b2 = performance2 == null ? void 0 : performance2.memory) == null ? void 0 : _b2.usedJSHeapSize;
+        if (usedJSHeapSize === void 0 || usedJSHeapSize === null) {
+          return null;
+        }
+        return Math.trunc(usedJSHeapSize / 1024 / 1024);
+      }
+    };
+    probe = new Probe();
+    globalThis.Probe = Probe;
+    globalThis.probe = probe;
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/loggers/probe-log.js
+function decorateMessage(id, message, opts) {
+  if (typeof message === "string") {
+    const time = opts.time ? leftPad(formatTime(opts.total)) : "";
+    message = opts.time ? `${id}: ${time}  ${message}` : `${id}: ${message}`;
+    message = addColor(message, opts.color, opts.background);
+  }
+  return message;
+}
+function getTableHeader(table) {
+  for (const key in table) {
+    for (const title in table[key]) {
+      return title || "untitled";
+    }
+  }
+  return "empty";
+}
+var originalConsole, DEFAULT_LOG_CONFIGURATION, ProbeLog;
+var init_probe_log = __esm({
+  "../../node_modules/probe.gl/dist/log/loggers/probe-log.js"() {
+    init_env();
+    init_base_log();
+    init_local_storage();
+    init_formatters();
+    init_color();
+    init_autobind();
+    init_assert2();
+    init_probe();
+    init_log_utils();
+    init_log_utils();
+    originalConsole = {
+      debug: isBrowser() ? console.debug || console.log : console.log,
+      log: console.log,
+      info: console.info,
+      warn: console.warn,
+      error: console.error
+    };
+    DEFAULT_LOG_CONFIGURATION = {
+      enabled: true,
+      level: 0
+    };
+    ProbeLog = class extends BaseLog {
+      constructor({ id } = { id: "" }) {
+        super({ level: 0 });
+        this.VERSION = VERSION;
+        this._startTs = probe.getHighResolutionTimer();
+        this._deltaTs = probe.getHighResolutionTimer();
+        this.userData = {};
+        this.LOG_THROTTLE_TIMEOUT = 0;
+        this.id = id;
+        this.userData = {};
+        this._storage = new LocalStorage(`__probe-${this.id}__`, { [this.id]: DEFAULT_LOG_CONFIGURATION });
+        this.timeStamp(`${this.id} started`);
+        autobind(this);
+        Object.seal(this);
+      }
+      isEnabled() {
+        return this._getConfiguration().enabled;
+      }
+      getLevel() {
+        return this._getConfiguration().level;
+      }
+      /** @return milliseconds, with fractions */
+      getTotal() {
+        return Number((probe.getHighResolutionTimer() - this._startTs).toPrecision(10));
+      }
+      /** @return milliseconds, with fractions */
+      getDelta() {
+        return Number((probe.getHighResolutionTimer() - this._deltaTs).toPrecision(10));
+      }
+      /** @deprecated use logLevel */
+      set priority(newPriority) {
+        this.level = newPriority;
+      }
+      /** @deprecated use logLevel */
+      get priority() {
+        return this.level;
+      }
+      /** @deprecated use logLevel */
+      getPriority() {
+        return this.level;
+      }
+      // Configure
+      enable(enabled = true) {
+        this._updateConfiguration({ enabled });
+        return this;
+      }
+      setLevel(level) {
+        this._updateConfiguration({ level });
+        return this;
+      }
+      /** return the current status of the setting */
+      get(setting) {
+        return this._getConfiguration()[setting];
+      }
+      // update the status of the setting
+      set(setting, value) {
+        this._updateConfiguration({ [setting]: value });
+      }
+      /** Logs the current settings as a table */
+      settings() {
+        if (console.table) {
+          console.table(this._storage.config);
+        } else {
+          console.log(this._storage.config);
+        }
+      }
+      // Unconditional logging
+      assert(condition, message) {
+        if (!condition) {
+          throw new Error(message || "Assertion failed");
+        }
+      }
+      warn(message, ...args) {
+        return this._log("warn", 0, message, args, {
+          method: originalConsole.warn,
+          once: true
+        });
+      }
+      error(message, ...args) {
+        return this._log("error", 0, message, args, {
+          method: originalConsole.error
+        });
+      }
+      /** Print a deprecation warning */
+      deprecated(oldUsage, newUsage) {
+        return this.warn(`\`${oldUsage}\` is deprecated and will be removed in a later version. Use \`${newUsage}\` instead`);
+      }
+      /** Print a removal warning */
+      removed(oldUsage, newUsage) {
+        return this.error(`\`${oldUsage}\` has been removed. Use \`${newUsage}\` instead`);
+      }
+      probe(logLevel, message, ...args) {
+        const memoryUsageMB = probe.getMemoryUsageMB();
+        if (memoryUsageMB !== null) {
+          const memoryUsagePrefix = `${memoryUsageMB}MB `;
+          if (typeof message === "function") {
+            message = () => `${memoryUsagePrefix}${message()}`;
+          } else if (typeof message === "string") {
+            message = `${memoryUsagePrefix}${message}`;
+          }
+        }
+        return this._log("log", logLevel, message, args, {
+          method: originalConsole.log,
+          time: true,
+          once: true
+        });
+      }
+      log(logLevel, message, ...args) {
+        return this._log("log", logLevel, message, args, {
+          method: originalConsole.debug
+        });
+      }
+      info(logLevel, message, ...args) {
+        return this._log("info", logLevel, message, args, { method: console.info });
+      }
+      once(logLevel, message, ...args) {
+        return this._log("once", logLevel, message, args, {
+          method: originalConsole.debug || originalConsole.info,
+          once: true
+        });
+      }
+      /** Logs an object as a table */
+      table(logLevel, table, columns) {
+        if (table) {
+          return this._log("table", logLevel, table, columns && [columns] || [], {
+            method: console.table || noop,
+            tag: getTableHeader(table)
+          });
+        }
+        return noop;
+      }
+      time(logLevel, message) {
+        return this._log("time", logLevel, message, [], {
+          method: console.time ? console.time : console.info
+        });
+      }
+      timeEnd(logLevel, message) {
+        return this._log("time", logLevel, message, [], {
+          method: console.timeEnd ? console.timeEnd : console.info
+        });
+      }
+      timeStamp(logLevel, message) {
+        return this._log("time", logLevel, message, [], {
+          method: console.timeStamp || noop
+        });
+      }
+      group(logLevel, message, opts = { collapsed: false }) {
+        const method = (opts.collapsed ? console.groupCollapsed : console.group) || console.info;
+        return this._log("group", logLevel, message, [], { method });
+      }
+      groupCollapsed(logLevel, message, opts = {}) {
+        return this.group(logLevel, message, Object.assign({}, opts, { collapsed: true }));
+      }
+      groupEnd(logLevel) {
+        return this._log("groupEnd", logLevel, "", [], {
+          method: console.groupEnd || noop
+        });
+      }
+      // EXPERIMENTAL
+      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() && super._shouldLog(logLevel);
+      }
+      _emit(_type, normalized) {
+        const method = normalized.method;
+        assert2(method);
+        normalized.total = this.getTotal();
+        normalized.delta = this.getDelta();
+        this._deltaTs = probe.getHighResolutionTimer();
+        const message = decorateMessage(this.id, normalized.message, normalized);
+        return method.bind(console, message, ...normalized.args);
+      }
+      _getConfiguration() {
+        if (!this._storage.config[this.id]) {
+          this._updateConfiguration(DEFAULT_LOG_CONFIGURATION);
+        }
+        return this._storage.config[this.id];
+      }
+      _updateConfiguration(configuration) {
+        const currentConfiguration = this._storage.config[this.id] || {
+          ...DEFAULT_LOG_CONFIGURATION
+        };
+        this._storage.setConfiguration({
+          [this.id]: { ...currentConfiguration, ...configuration }
+        });
+      }
+    };
+    ProbeLog.VERSION = VERSION;
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/loggers/console-log.js
+var init_console_log = __esm({
+  "../../node_modules/probe.gl/dist/log/loggers/console-log.js"() {
+    init_base_log();
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/loggers/memory-log.js
+var init_memory_log = __esm({
+  "../../node_modules/probe.gl/dist/log/loggers/memory-log.js"() {
+    init_base_log();
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/deprecated/hi-res-timestamp.js
+var init_hi_res_timestamp = __esm({
+  "../../node_modules/probe.gl/dist/log/deprecated/hi-res-timestamp.js"() {
+    init_probe();
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/init.js
+var init_init = __esm({
+  "../../node_modules/probe.gl/dist/log/init.js"() {
+    init_probe();
+    if (!globalThis.probe) {
+      globalThis.probe = probe;
+    }
+  }
+});
+
+// ../../node_modules/probe.gl/dist/log/index.js
+var log;
+var init_log = __esm({
+  "../../node_modules/probe.gl/dist/log/index.js"() {
+    init_probe_log();
+    init_probe();
+    init_probe_log();
+    init_console_log();
+    init_base_log();
+    init_memory_log();
+    init_color();
+    init_color();
+    init_formatters();
+    init_autobind();
+    init_local_storage();
+    init_hi_res_timestamp();
+    init_init();
+    log = new ProbeLog({ id: "@probe.gl/log" });
+  }
+});
+
 // ../../node_modules/sharp/dist/is.mjs
 var defined, object, plainObject, fn, bool, buffer, typedArray, arrayBuffer, string, number, integer, inRange2, inArray, invalidParameterError, nativeError, is_default;
 var init_is = __esm({
@@ -421,33 +1106,33 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var version2 = async () => {
-      let version3 = null;
+    var version3 = async () => {
+      let version4 = null;
       if (isLinux()) {
-        version3 = await versionFromFilesystem();
-        if (!version3) {
-          version3 = versionFromReport();
+        version4 = await versionFromFilesystem();
+        if (!version4) {
+          version4 = versionFromReport();
         }
-        if (!version3) {
+        if (!version4) {
           const out = await safeCommand();
-          version3 = versionFromCommand(out);
+          version4 = versionFromCommand(out);
         }
       }
-      return version3;
+      return version4;
     };
     var versionSync2 = () => {
-      let version3 = null;
+      let version4 = null;
       if (isLinux()) {
-        version3 = versionFromFilesystemSync();
-        if (!version3) {
-          version3 = versionFromReport();
+        version4 = versionFromFilesystemSync();
+        if (!version4) {
+          version4 = versionFromReport();
         }
-        if (!version3) {
+        if (!version4) {
           const out = safeCommandSync();
-          version3 = versionFromCommand(out);
+          version4 = versionFromCommand(out);
         }
       }
-      return version3;
+      return version4;
     };
     module2.exports = {
       GLIBC,
@@ -456,7 +1141,7 @@ var require_detect_libc = __commonJS({
       familySync: familySync2,
       isNonGlibcLinux,
       isNonGlibcLinuxSync,
-      version: version2,
+      version: version3,
       versionSync: versionSync2
     };
   }
@@ -658,31 +1343,31 @@ var require_semver = __commonJS({
       return true;
     };
     var SemVer = class _SemVer {
-      constructor(version2, options) {
+      constructor(version3, options) {
         options = parseOptions(options);
-        if (version2 instanceof _SemVer) {
-          if (version2.loose === !!options.loose && version2.includePrerelease === !!options.includePrerelease) {
-            return version2;
+        if (version3 instanceof _SemVer) {
+          if (version3.loose === !!options.loose && version3.includePrerelease === !!options.includePrerelease) {
+            return version3;
           } else {
-            version2 = version2.version;
+            version3 = version3.version;
           }
-        } else if (typeof version2 !== "string") {
-          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version2}".`);
+        } else if (typeof version3 !== "string") {
+          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version3}".`);
         }
-        if (version2.length > MAX_LENGTH) {
+        if (version3.length > MAX_LENGTH) {
           throw new TypeError(
             `version is longer than ${MAX_LENGTH} characters`
           );
         }
-        debug("SemVer", version2, options);
+        debug("SemVer", version3, options);
         this.options = options;
         this.loose = !!options.loose;
         this.includePrerelease = !!options.includePrerelease;
-        const m = version2.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+        const m = version3.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
         if (!m) {
-          throw new TypeError(`Invalid Version: ${version2}`);
+          throw new TypeError(`Invalid Version: ${version3}`);
         }
-        this.raw = version2;
+        this.raw = version3;
         this.major = +m[1];
         this.minor = +m[2];
         this.patch = +m[3];
@@ -933,12 +1618,12 @@ var require_parse = __commonJS({
   "../../node_modules/semver/functions/parse.js"(exports2, module2) {
     "use strict";
     var SemVer = require_semver();
-    var parse2 = (version2, options, throwErrors = false) => {
-      if (version2 instanceof SemVer) {
-        return version2;
+    var parse2 = (version3, options, throwErrors = false) => {
+      if (version3 instanceof SemVer) {
+        return version3;
       }
       try {
-        return new SemVer(version2, options);
+        return new SemVer(version3, options);
       } catch (er) {
         if (!throwErrors) {
           return null;
@@ -955,8 +1640,8 @@ var require_valid = __commonJS({
   "../../node_modules/semver/functions/valid.js"(exports2, module2) {
     "use strict";
     var parse2 = require_parse();
-    var valid = (version2, options) => {
-      const v = parse2(version2, options);
+    var valid = (version3, options) => {
+      const v = parse2(version3, options);
       return v ? v.version : null;
     };
     module2.exports = valid;
@@ -968,8 +1653,8 @@ var require_clean = __commonJS({
   "../../node_modules/semver/functions/clean.js"(exports2, module2) {
     "use strict";
     var parse2 = require_parse();
-    var clean = (version2, options) => {
-      const s = parse2(version2.trim().replace(/^[=v]+/, ""), options);
+    var clean = (version3, options) => {
+      const s = parse2(version3.trim().replace(/^[=v]+/, ""), options);
       return s ? s.version : null;
     };
     module2.exports = clean;
@@ -981,7 +1666,7 @@ var require_inc = __commonJS({
   "../../node_modules/semver/functions/inc.js"(exports2, module2) {
     "use strict";
     var SemVer = require_semver();
-    var inc = (version2, release, options, identifier, identifierBase) => {
+    var inc = (version3, release, options, identifier, identifierBase) => {
       if (typeof options === "string") {
         identifierBase = identifier;
         identifier = options;
@@ -989,7 +1674,7 @@ var require_inc = __commonJS({
       }
       try {
         return new SemVer(
-          version2 instanceof SemVer ? version2.version : version2,
+          version3 instanceof SemVer ? version3.version : version3,
           options
         ).inc(release, identifier, identifierBase).version;
       } catch (er) {
@@ -1005,9 +1690,9 @@ var require_diff = __commonJS({
   "../../node_modules/semver/functions/diff.js"(exports2, module2) {
     "use strict";
     var parse2 = require_parse();
-    var diff = (version1, version2) => {
+    var diff = (version1, version22) => {
       const v1 = parse2(version1, null, true);
-      const v2 = parse2(version2, null, true);
+      const v2 = parse2(version22, null, true);
       const comparison = v1.compare(v2);
       if (comparison === 0) {
         return null;
@@ -1079,8 +1764,8 @@ var require_prerelease = __commonJS({
   "../../node_modules/semver/functions/prerelease.js"(exports2, module2) {
     "use strict";
     var parse2 = require_parse();
-    var prerelease = (version2, options) => {
-      const parsed = parse2(version2, options);
+    var prerelease = (version3, options) => {
+      const parsed = parse2(version3, options);
       return parsed && parsed.prerelease.length ? parsed.prerelease : null;
     };
     module2.exports = prerelease;
@@ -1268,24 +1953,24 @@ var require_coerce = __commonJS({
     var SemVer = require_semver();
     var parse2 = require_parse();
     var { safeRe: re, t } = require_re();
-    var coerce = (version2, options) => {
-      if (version2 instanceof SemVer) {
-        return version2;
+    var coerce = (version3, options) => {
+      if (version3 instanceof SemVer) {
+        return version3;
       }
-      if (typeof version2 === "number") {
-        version2 = String(version2);
+      if (typeof version3 === "number") {
+        version3 = String(version3);
       }
-      if (typeof version2 !== "string") {
+      if (typeof version3 !== "string") {
         return null;
       }
       options = options || {};
       let match = null;
       if (!options.rtl) {
-        match = version2.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+        match = version3.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
       } else {
         const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
         let next;
-        while ((next = coerceRtlRegex.exec(version2)) && (!match || match.index + match[0].length !== version2.length)) {
+        while ((next = coerceRtlRegex.exec(version3)) && (!match || match.index + match[0].length !== version3.length)) {
           if (!match || next.index + next[0].length !== match.index + match[0].length) {
             match = next;
           }
@@ -1314,32 +1999,32 @@ var require_truncate = __commonJS({
     var parse2 = require_parse();
     var constants = require_constants();
     var SemVer = require_semver();
-    var truncate = (version2, truncation, options) => {
+    var truncate = (version3, truncation, options) => {
       if (!constants.RELEASE_TYPES.includes(truncation)) {
         return null;
       }
-      const clonedVersion = cloneInputVersion(version2, options);
+      const clonedVersion = cloneInputVersion(version3, options);
       return clonedVersion && doTruncation(clonedVersion, truncation);
     };
-    var cloneInputVersion = (version2, options) => {
-      const versionStringToParse = version2 instanceof SemVer ? version2.version : version2;
+    var cloneInputVersion = (version3, options) => {
+      const versionStringToParse = version3 instanceof SemVer ? version3.version : version3;
       return parse2(versionStringToParse, options);
     };
-    var doTruncation = (version2, truncation) => {
+    var doTruncation = (version3, truncation) => {
       if (isPrerelease(truncation)) {
-        return version2.version;
+        return version3.version;
       }
-      version2.prerelease = [];
+      version3.prerelease = [];
       switch (truncation) {
         case "major":
-          version2.minor = 0;
-          version2.patch = 0;
+          version3.minor = 0;
+          version3.patch = 0;
           break;
         case "minor":
-          version2.patch = 0;
+          version3.patch = 0;
           break;
       }
-      return version2.format();
+      return version3.format();
     };
     var isPrerelease = (type) => {
       return type.startsWith("pre");
@@ -1511,19 +2196,19 @@ var require_range = __commonJS({
         });
       }
       // if ANY of the sets match ALL of its comparators, then pass
-      test(version2) {
-        if (!version2) {
+      test(version3) {
+        if (!version3) {
           return false;
         }
-        if (typeof version2 === "string") {
+        if (typeof version3 === "string") {
           try {
-            version2 = new SemVer(version2, this.options);
+            version3 = new SemVer(version3, this.options);
           } catch (er) {
             return false;
           }
         }
         for (let i = 0; i < this.set.length; i++) {
-          if (testSet(this.set[i], version2, this.options)) {
+          if (testSet(this.set[i], version3, this.options)) {
             return true;
           }
         }
@@ -1745,13 +2430,13 @@ var require_range = __commonJS({
       }
       return `${from} ${to}`.trim();
     };
-    var testSet = (set, version2, options) => {
+    var testSet = (set, version3, options) => {
       for (let i = 0; i < set.length; i++) {
-        if (!set[i].test(version2)) {
+        if (!set[i].test(version3)) {
           return false;
         }
       }
-      if (version2.prerelease.length && !options.includePrerelease) {
+      if (version3.prerelease.length && !options.includePrerelease) {
         for (let i = 0; i < set.length; i++) {
           debug(set[i].semver);
           if (set[i].semver === Comparator.ANY) {
@@ -1759,7 +2444,7 @@ var require_range = __commonJS({
           }
           if (set[i].semver.prerelease.length > 0) {
             const allowed = set[i].semver;
-            if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) {
+            if (allowed.major === version3.major && allowed.minor === version3.minor && allowed.patch === version3.patch) {
               return true;
             }
           }
@@ -1820,19 +2505,19 @@ var require_comparator = __commonJS({
       toString() {
         return this.value;
       }
-      test(version2) {
-        debug("Comparator.test", version2, this.options.loose);
-        if (this.semver === ANY || version2 === ANY) {
+      test(version3) {
+        debug("Comparator.test", version3, this.options.loose);
+        if (this.semver === ANY || version3 === ANY) {
           return true;
         }
-        if (typeof version2 === "string") {
+        if (typeof version3 === "string") {
           try {
-            version2 = new SemVer(version2, this.options);
+            version3 = new SemVer(version3, this.options);
           } catch (er) {
             return false;
           }
         }
-        return cmp(version2, this.operator, this.semver, this.options);
+        return cmp(version3, this.operator, this.semver, this.options);
       }
       intersects(comp, options) {
         if (!(comp instanceof _Comparator)) {
@@ -1889,13 +2574,13 @@ var require_satisfies = __commonJS({
   "../../node_modules/semver/functions/satisfies.js"(exports2, module2) {
     "use strict";
     var Range = require_range();
-    var satisfies = (version2, range, options) => {
+    var satisfies = (version3, range, options) => {
       try {
         range = new Range(range, options);
       } catch (er) {
         return false;
       }
-      return range.test(version2);
+      return range.test(version3);
     };
     module2.exports = satisfies;
   }
@@ -2057,8 +2742,8 @@ var require_outside = __commonJS({
     var lt = require_lt();
     var lte = require_lte();
     var gte = require_gte();
-    var outside = (version2, range, hilo, options) => {
-      version2 = new SemVer(version2, options);
+    var outside = (version3, range, hilo, options) => {
+      version3 = new SemVer(version3, options);
       range = new Range(range, options);
       let gtfn, ltefn, ltfn, comp, ecomp;
       switch (hilo) {
@@ -2079,7 +2764,7 @@ var require_outside = __commonJS({
         default:
           throw new TypeError('Must provide a hilo val of "<" or ">"');
       }
-      if (satisfies(version2, range, options)) {
+      if (satisfies(version3, range, options)) {
         return false;
       }
       for (let i = 0; i < range.set.length; ++i) {
@@ -2101,9 +2786,9 @@ var require_outside = __commonJS({
         if (high.operator === comp || high.operator === ecomp) {
           return false;
         }
-        if ((!low.operator || low.operator === comp) && ltefn(version2, low.semver)) {
+        if ((!low.operator || low.operator === comp) && ltefn(version3, low.semver)) {
           return false;
-        } else if (low.operator === ecomp && ltfn(version2, low.semver)) {
+        } else if (low.operator === ecomp && ltfn(version3, low.semver)) {
           return false;
         }
       }
@@ -2118,7 +2803,7 @@ var require_gtr = __commonJS({
   "../../node_modules/semver/ranges/gtr.js"(exports2, module2) {
     "use strict";
     var outside = require_outside();
-    var gtr = (version2, range, options) => outside(version2, range, ">", options);
+    var gtr = (version3, range, options) => outside(version3, range, ">", options);
     module2.exports = gtr;
   }
 });
@@ -2128,7 +2813,7 @@ var require_ltr = __commonJS({
   "../../node_modules/semver/ranges/ltr.js"(exports2, module2) {
     "use strict";
     var outside = require_outside();
-    var ltr = (version2, range, options) => outside(version2, range, "<", options);
+    var ltr = (version3, range, options) => outside(version3, range, "<", options);
     module2.exports = ltr;
   }
 });
@@ -2158,12 +2843,12 @@ var require_simplify = __commonJS({
       let first = null;
       let prev = null;
       const v = versions3.sort((a, b) => compare(a, b, options));
-      for (const version2 of v) {
-        const included = satisfies(version2, range, options);
+      for (const version3 of v) {
+        const included = satisfies(version3, range, options);
         if (included) {
-          prev = version2;
+          prev = version3;
           if (!first) {
-            first = version2;
+            first = version3;
           }
         } else {
           if (prev) {
@@ -2691,7 +3376,7 @@ var init_package = __esm({
 });
 
 // ../../node_modules/sharp/dist/libvips.mjs
-var import_node_child_process, import_node_crypto, import_semver, import_detect_libc, minimumLibvipsVersionLabelled, minimumLibvipsVersion, prebuiltPlatforms, spawnSyncOptions, log, runtimeLibc, runtimePlatformArch, buildPlatformArch, buildSharpLibvipsIncludeDir, buildSharpLibvipsCPlusPlusDir, buildSharpLibvipsLibDir, isUnsupportedNodeRuntime, isEmscripten, isRosetta, sha512, yarnLocator, spawnRebuild, globalLibvipsVersion, getBrewPkgConfigPath, getPkgConfigPath, pkgConfigPath, skipSearch, useGlobalLibvips, libvips_default;
+var import_node_child_process, import_node_crypto, import_semver, import_detect_libc, minimumLibvipsVersionLabelled, minimumLibvipsVersion, prebuiltPlatforms, spawnSyncOptions, log2, runtimeLibc, runtimePlatformArch, buildPlatformArch, buildSharpLibvipsIncludeDir, buildSharpLibvipsCPlusPlusDir, buildSharpLibvipsLibDir, isUnsupportedNodeRuntime, isEmscripten, isRosetta, sha512, yarnLocator, spawnRebuild, globalLibvipsVersion, getBrewPkgConfigPath, getPkgConfigPath, pkgConfigPath, skipSearch, useGlobalLibvips, libvips_default;
 var init_libvips = __esm({
   "../../node_modules/sharp/dist/libvips.mjs"() {
     import_node_child_process = require("node:child_process");
@@ -2723,7 +3408,7 @@ var init_libvips = __esm({
       encoding: "utf8",
       shell: true
     };
-    log = (item) => {
+    log2 = (item) => {
       if (item instanceof Error) {
         console.error(`sharp: Installation error: ${item.message}`);
       } else {
@@ -2877,7 +3562,7 @@ var init_libvips = __esm({
       buildSharpLibvipsLibDir,
       isUnsupportedNodeRuntime,
       runtimePlatformArch,
-      log,
+      log: log2,
       yarnLocator,
       spawnRebuild,
       globalLibvipsVersion,
@@ -7580,6 +8265,57 @@ var init_dist = __esm({
   }
 });
 
+// ../core/src/loader-utils/lib/log-utils/log.ts
+function createLog() {
+  const log4 = new ProbeLog({ id: "loaders.gl" });
+  globalThis.loaders ||= {};
+  globalThis.loaders.log = log4;
+  globalThis.loaders.version = version2;
+  globalThis.probe ||= {};
+  globalThis.probe.loaders = log4;
+  return log4;
+}
+function ignoreMessage() {
+}
+function getLoaderLog(options) {
+  var _a5;
+  const logger = ((_a5 = options == null ? void 0 : options.core) == null ? void 0 : _a5.log) !== void 0 ? options.core.log : options == null ? void 0 : options.log;
+  return logger === null ? nullLog : logger || log3;
+}
+var VERSION2, version2, log3, NullLog, nullLog;
+var init_log2 = __esm({
+  "../core/src/loader-utils/lib/log-utils/log.ts"() {
+    "use strict";
+    init_log();
+    VERSION2 = true ? "5.0.0-beta.8" : "latest";
+    version2 = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : "";
+    log3 = createLog();
+    NullLog = class {
+      /** Discards debug messages. */
+      log() {
+        return ignoreMessage;
+      }
+      /** Discards informational messages. */
+      info() {
+        return ignoreMessage;
+      }
+      /** Discards messages marked to be emitted once. */
+      once() {
+        return ignoreMessage;
+      }
+      /** Discards warnings. */
+      warn() {
+        return ignoreMessage;
+      }
+      /** Discards errors. */
+      error() {
+        return ignoreMessage;
+      }
+    };
+    nullLog = new NullLog();
+  }
+});
+
 // ../core/src/loader-utils/lib/module-utils/initialize-wasm-module.ts
 function initializeWasmModule(initialize, extractExports) {
   return new Promise((resolve, reject) => {
@@ -7617,34 +8353,34 @@ var init_initialize_wasm_module = __esm({
 
 // ../core/src/worker-utils/lib/env-utils/version.ts
 function getVersion() {
-  const version2 = false ? NPM_TAG : "5.0.0-beta.6";
+  const version3 = false ? NPM_TAG : "5.0.0-beta.8";
   globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-  globalThis._loadersgl_.version ||= version2;
-  return version2;
+  globalThis._loadersgl_.version ||= version3;
+  return version3;
 }
-var VERSION;
+var VERSION3;
 var init_version = __esm({
   "../core/src/worker-utils/lib/env-utils/version.ts"() {
     "use strict";
-    VERSION = getVersion();
+    VERSION3 = getVersion();
   }
 });
 
 // ../core/src/worker-utils/lib/env-utils/assert.ts
-function assert(condition, message) {
+function assert3(condition, message) {
   if (!condition) {
     throw new Error(message || "loaders.gl assertion failed.");
   }
 }
-var init_assert = __esm({
+var init_assert3 = __esm({
   "../core/src/worker-utils/lib/env-utils/assert.ts"() {
     "use strict";
   }
 });
 
 // ../core/src/worker-utils/lib/env-utils/globals.ts
-var globals, self_, window_, global_, document_, isBrowser2, isWorker, isMobile, matches, nodeVersion2;
-var init_globals = __esm({
+var globals, self_, window_2, global_2, document_2, isBrowser3, isWorker, isMobile2, matches, nodeVersion2;
+var init_globals2 = __esm({
   "../core/src/worker-utils/lib/env-utils/globals.ts"() {
     "use strict";
     globals = {
@@ -7654,13 +8390,13 @@ var init_globals = __esm({
       document: typeof document !== "undefined" && document
     };
     self_ = globals.self || globals.window || globals.global || {};
-    window_ = globals.window || globals.self || globals.global || {};
-    global_ = globals.global || globals.self || globals.window || {};
-    document_ = globals.document || {};
-    isBrowser2 = // @ts-ignore process.browser
+    window_2 = globals.window || globals.self || globals.global || {};
+    global_2 = globals.global || globals.self || globals.window || {};
+    document_2 = globals.document || {};
+    isBrowser3 = // @ts-ignore process.browser
     typeof process !== "object" || String(process) !== "[object process]" || process.browser;
     isWorker = typeof importScripts === "function";
-    isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+    isMobile2 = typeof window !== "undefined" && typeof window.orientation !== "undefined";
     matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
     nodeVersion2 = matches && parseFloat(matches[1]) || 0;
   }
@@ -8839,15 +9575,15 @@ function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
   if (!options.useLocalLibraries && library.startsWith("http")) {
     return library;
   }
-  if (!isBrowser2) {
+  if (!isBrowser3) {
     return `modules/${moduleName}/dist/libs/${libraryName}`;
   }
   if (options.CDN) {
     if (typeof options.CDN !== "string") {
       throw new Error("loadLibrary: options.CDN must be a string or null");
     }
-    assert(options.CDN.startsWith("http"));
-    return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
+    assert3(options.CDN.startsWith("http"));
+    return `${options.CDN}/${moduleName}@${VERSION3}/dist/libs/${libraryName}`;
   }
   if (isWorker) {
     return libraryName.endsWith(".mjs") ? `./libs/${libraryName}` : `../src/libs/${libraryName}`;
@@ -8858,7 +9594,7 @@ async function loadLibraryFromFile(libraryUrl, moduleLibraryUrl) {
   if (libraryUrl.endsWith("wasm")) {
     return await loadAsArrayBuffer(libraryUrl);
   }
-  if (!isBrowser2) {
+  if (!isBrowser3) {
     const { requireFromFile: requireFromFile2 } = globalThis.loaders || {};
     try {
       const result = await (requireFromFile2 == null ? void 0 : requireFromFile2(libraryUrl));
@@ -8873,7 +9609,7 @@ async function loadLibraryFromFile(libraryUrl, moduleLibraryUrl) {
         } catch {
         }
       }
-      console.error(error);
+      log3.error(String(error))();
       return null;
     }
   }
@@ -8910,7 +9646,7 @@ function loadLibraryFromString(scriptSource, id) {
 }
 async function loadAsArrayBuffer(url) {
   const { readFileAsArrayBuffer: readFileAsArrayBuffer2 } = globalThis.loaders || {};
-  if (isBrowser2 || !readFileAsArrayBuffer2 || url.startsWith("http")) {
+  if (isBrowser3 || !readFileAsArrayBuffer2 || url.startsWith("http")) {
     const response = await fetch(url);
     return await response.arrayBuffer();
   }
@@ -8925,7 +9661,7 @@ async function loadAsArrayBuffer(url) {
 }
 async function loadAsText(url) {
   const { readFileAsText: readFileAsText2 } = globalThis.loaders || {};
-  if (isBrowser2 || !readFileAsText2 || url.startsWith("http")) {
+  if (isBrowser3 || !readFileAsText2 || url.startsWith("http")) {
     const response = await fetch(url);
     return await response.text();
   }
@@ -8942,8 +9678,9 @@ var loadLibraryPromises;
 var init_library_utils = __esm({
   "../core/src/worker-utils/lib/library-utils/library-utils.ts"() {
     "use strict";
-    init_globals();
-    init_assert();
+    init_log2();
+    init_globals2();
+    init_assert3();
     init_version();
     loadLibraryPromises = {};
   }
@@ -8953,7 +9690,7 @@ var init_library_utils = __esm({
 var init_worker_utils2 = __esm({
   "../core/src/worker-utils/index.ts"() {
     "use strict";
-    init_globals();
+    init_globals2();
     init_create_worker2();
     init_library_utils();
   }
@@ -9233,6 +9970,7 @@ var init_dist3 = __esm({
 var init_loader_utils = __esm({
   "../core/src/loader-utils/index.ts"() {
     "use strict";
+    init_log2();
     init_initialize_wasm_module();
     init_create_loader_worker();
   }
@@ -17155,8 +17893,8 @@ var init_footer = __esm({
       static startFooter(builder) {
         builder.startObject(5);
       }
-      static addVersion(builder, version2) {
-        builder.addFieldInt16(0, version2, MetadataVersion.V1);
+      static addVersion(builder, version3) {
+        builder.addFieldInt16(0, version3, MetadataVersion.V1);
       }
       static addSchema(builder, schemaOffset) {
         builder.addFieldOffset(1, schemaOffset, 0);
@@ -17402,9 +18140,9 @@ var init_file = __esm({
       get numDictionaries() {
         return this._dictionaryBatches.length;
       }
-      constructor(schema, version2 = MetadataVersion.V5, recordBatches, dictionaryBatches) {
+      constructor(schema, version3 = MetadataVersion.V5, recordBatches, dictionaryBatches) {
         this.schema = schema;
-        this.version = version2;
+        this.version = version3;
         recordBatches && (this._recordBatches = recordBatches);
         dictionaryBatches && (this._dictionaryBatches = dictionaryBatches);
       }
@@ -17532,8 +18270,8 @@ var init_message = __esm({
       static startMessage(builder) {
         builder.startObject(5);
       }
-      static addVersion(builder, version2) {
-        builder.addFieldInt16(0, version2, MetadataVersion.V1);
+      static addVersion(builder, version3) {
+        builder.addFieldInt16(0, version3, MetadataVersion.V1);
       }
       static addHeaderType(builder, headerType) {
         builder.addFieldInt8(1, headerType, MessageHeader.NONE);
@@ -17567,9 +18305,9 @@ var init_message = __esm({
       static finishSizePrefixedMessageBuffer(builder, offset) {
         builder.finish(offset, void 0, true);
       }
-      static createMessage(builder, version2, headerType, headerOffset, bodyLength, customMetadataOffset) {
+      static createMessage(builder, version3, headerType, headerOffset, bodyLength, customMetadataOffset) {
         _Message.startMessage(builder);
-        _Message.addVersion(builder, version2);
+        _Message.addVersion(builder, version3);
         _Message.addHeaderType(builder, headerType);
         _Message.addHeader(builder, headerOffset);
         _Message.addBodyLength(builder, bodyLength);
@@ -17941,16 +18679,16 @@ function decodeMessageHeader(message, type) {
     throw new Error(`Unrecognized Message type: { name: ${MessageHeader[type]}, type: ${type} }`);
   });
 }
-function decodeSchema(_schema, dictionaries = /* @__PURE__ */ new Map(), version2 = MetadataVersion.V5) {
+function decodeSchema(_schema, dictionaries = /* @__PURE__ */ new Map(), version3 = MetadataVersion.V5) {
   const fields = decodeSchemaFields(_schema, dictionaries);
-  return new Schema2(fields, decodeCustomMetadata(_schema), dictionaries, version2);
+  return new Schema2(fields, decodeCustomMetadata(_schema), dictionaries, version3);
 }
-function decodeRecordBatch(batch, version2 = MetadataVersion.V5) {
-  const recordBatch = new RecordBatch2(batch.length(), decodeFieldNodes(batch), decodeBuffers(batch, version2), decodeBodyCompression(batch.compression()), decodeVariadicBufferCounts(batch));
+function decodeRecordBatch(batch, version3 = MetadataVersion.V5) {
+  const recordBatch = new RecordBatch2(batch.length(), decodeFieldNodes(batch), decodeBuffers(batch, version3), decodeBodyCompression(batch.compression()), decodeVariadicBufferCounts(batch));
   return recordBatch;
 }
-function decodeDictionaryBatch(batch, version2 = MetadataVersion.V5) {
-  return new DictionaryBatch2(RecordBatch2.decode(batch.data(), version2), batch.id(), batch.isDelta());
+function decodeDictionaryBatch(batch, version3 = MetadataVersion.V5) {
+  return new DictionaryBatch2(RecordBatch2.decode(batch.data(), version3), batch.id(), batch.isDelta());
 }
 function decodeBufferRegion(b) {
   return new BufferRegion(b.offset(), b.length());
@@ -17967,11 +18705,11 @@ function decodeFieldNodes(batch) {
   }
   return nodes;
 }
-function decodeBuffers(batch, version2) {
+function decodeBuffers(batch, version3) {
   const bufferRegions = [];
   for (let b, i = -1, j = -1, n = batch.buffersLength(); ++i < n; ) {
     if (b = batch.buffers(i)) {
-      if (version2 < MetadataVersion.V4) {
+      if (version3 < MetadataVersion.V4) {
         b.bb_pos += 8 * (i + 1);
       }
       bufferRegions[++j] = BufferRegion.decode(b);
@@ -18296,10 +19034,10 @@ var init_message2 = __esm({
         buf = new ByteBuffer4(toUint8Array2(buf));
         const _message = Message.getRootAsMessage(buf);
         const bodyLength = _message.bodyLength();
-        const version2 = _message.version();
+        const version3 = _message.version();
         const headerType = _message.headerType();
         const metadata2 = decodeMessageCustomMetadata(_message);
-        const message = new _Message(bodyLength, version2, headerType, void 0, metadata2);
+        const message = new _Message(bodyLength, version3, headerType, void 0, metadata2);
         message._createHeader = decodeMessageHeader(_message, headerType);
         return message;
       }
@@ -18376,8 +19114,8 @@ var init_message2 = __esm({
       isDictionaryBatch() {
         return this.headerType === MessageHeader.DictionaryBatch;
       }
-      constructor(bodyLength, version2, headerType, header, metadata2) {
-        this._version = version2;
+      constructor(bodyLength, version3, headerType, header, metadata2) {
+        this._version = version3;
         this._headerType = headerType;
         this.body = new Uint8Array(0);
         this._compression = header === null || header === void 0 ? void 0 : header.compression;
@@ -25506,6 +26244,7 @@ var DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP, DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP, UINT16
 var init_draco_parser = __esm({
   "src/draco/lib/draco-parser.ts"() {
     "use strict";
+    init_loader_utils();
     init_schema_utils();
     init_get_draco_schema();
     DRACO_TO_GLTF_ATTRIBUTE_NAME_MAP = {
@@ -25530,15 +26269,17 @@ var init_draco_parser = __esm({
     UINT16_INDEX_ITEM_SIZE = 2;
     UINT32_INDEX_ITEM_SIZE = 4;
     DracoParser = class {
-      draco;
-      decoder;
-      metadataQuerier;
       // draco - the draco decoder, either import `draco3d` or load dynamically
-      constructor(draco) {
+      constructor(draco, logger = getLoaderLog()) {
+        this.logger = logger;
         this.draco = draco;
         this.decoder = new this.draco.Decoder();
         this.metadataQuerier = new this.draco.MetadataQuerier();
       }
+      logger;
+      draco;
+      decoder;
+      metadataQuerier;
       /**
        * Destroy draco resources
        */
@@ -25801,7 +26542,7 @@ var init_draco_parser = __esm({
       _getAttributeValues(dracoGeometry, attribute) {
         const TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];
         if (!TypedArrayCtor) {
-          console.warn(`DRACO: Unsupported attribute type ${attribute.data_type}`);
+          this.logger.warn(`DRACO: Unsupported attribute type ${attribute.data_type}`)();
           return null;
         }
         const numComponents = attribute.num_components;
@@ -25996,7 +26737,7 @@ async function parseDraco(arrayBuffer2, options, loadDecoderModule, context) {
   reportProgress == null ? void 0 : reportProgress({ phase: "decode", completed: 0, total: 1, unit: "tasks" });
   const { draco } = await loadDecoderModule();
   (_a5 = (options == null ? void 0 : options.signal) || (context == null ? void 0 : context.signal)) == null ? void 0 : _a5.throwIfAborted();
-  const dracoParser = new DracoParser(draco);
+  const dracoParser = new DracoParser(draco, getLoaderLog(options));
   try {
     const mesh = dracoParser.parseSync(arrayBuffer2, options == null ? void 0 : options.draco);
     reportProgress == null ? void 0 : reportProgress({ phase: "decode", completed: 1, total: 1, unit: "tasks" });
@@ -26011,6 +26752,7 @@ async function parseDraco(arrayBuffer2, options, loadDecoderModule, context) {
 var init_parse_draco = __esm({
   "src/draco/lib/parse-draco.ts"() {
     "use strict";
+    init_loader_utils();
     init_schema_utils();
     init_draco_parser();
   }
@@ -26019,7 +26761,7 @@ var init_parse_draco = __esm({
 // src/draco/lib/draco-library-loader.ts
 async function loadLibrary2(libraryUrl, moduleName = null, options = {}, libraryName = null, moduleLibraryName = null) {
   var _a5;
-  if (isBrowser2 && options.useLocalLibraries && !options.CDN && libraryName && ((_a5 = options.modules) == null ? void 0 : _a5[libraryName]) === void 0) {
+  if (isBrowser3 && options.useLocalLibraries && !options.CDN && libraryName && ((_a5 = options.modules) == null ? void 0 : _a5[libraryName]) === void 0) {
     const directory = isWorker ? "./libs" : `modules/${moduleName}/dist/libs`;
     options = {
       ...options,
@@ -26148,7 +26890,7 @@ async function loadDracoDecoderInternal(options, type, profile) {
         "draco_decoder.mjs"
       );
     } catch (error) {
-      if (isBrowser2 || options.useLocalLibraries) {
+      if (isBrowser3 || options.useLocalLibraries) {
         throw error;
       }
       decoderLibrary2 = await loadLibrary2(
@@ -26167,7 +26909,7 @@ async function loadDracoDecoderInternal(options, type, profile) {
   try {
     [decoderLibrary, wasmBinary] = await loadDecoderWasmAssets(options, profile);
   } catch (error) {
-    if (isBrowser2 || options.useLocalLibraries) {
+    if (isBrowser3 || options.useLocalLibraries) {
       throw error;
     }
     [decoderLibrary, wasmBinary] = await loadDecoderWasmAssets(
@@ -26260,6 +27002,18 @@ var init_draco_module_loader = __esm({
   }
 });
 
+// ../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-helpers.js
+var init_indexed_arrow_helpers = __esm({
+  "../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-helpers.js"() {
+  }
+});
+
+// ../../node_modules/@math.gl/arrow/dist/arrow/arrow-schema-utils.js
+var init_arrow_schema_utils = __esm({
+  "../../node_modules/@math.gl/arrow/dist/arrow/arrow-schema-utils.js"() {
+  }
+});
+
 // ../../node_modules/@math.gl/arrow/dist/arrow/arrow-data.js
 function getArrowVariadicBuffers(data) {
   return data.variadicBuffers ?? [];
@@ -26363,27 +27117,43 @@ var init_split_arrow_buffers = __esm({
   }
 });
 
+// ../../node_modules/@math.gl/arrow/dist/arrow/take-arrow-rows.js
+var init_take_arrow_rows = __esm({
+  "../../node_modules/@math.gl/arrow/dist/arrow/take-arrow-rows.js"() {
+    init_arrow_data();
+    init_split_arrow_buffers();
+  }
+});
+
 // ../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-vector.js
 var init_indexed_arrow_vector = __esm({
   "../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-vector.js"() {
+    init_indexed_arrow_helpers();
   }
 });
 
 // ../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-table.js
 var init_indexed_arrow_table = __esm({
   "../../node_modules/@math.gl/arrow/dist/arrow/indexed-arrow-table.js"() {
+    init_indexed_arrow_helpers();
+    init_arrow_schema_utils();
+    init_take_arrow_rows();
+    init_indexed_arrow_vector();
   }
 });
 
 // ../../node_modules/@math.gl/arrow/dist/arrow/mapped-arrow-table.js
 var init_mapped_arrow_table = __esm({
   "../../node_modules/@math.gl/arrow/dist/arrow/mapped-arrow-table.js"() {
+    init_indexed_arrow_helpers();
+    init_indexed_arrow_table();
   }
 });
 
 // ../../node_modules/@math.gl/arrow/dist/arrow/rename-arrow-columns.js
 var init_rename_arrow_columns = __esm({
   "../../node_modules/@math.gl/arrow/dist/arrow/rename-arrow-columns.js"() {
+    init_arrow_schema_utils();
   }
 });
 
@@ -26438,15 +27208,23 @@ var init_arrow_table_transport = __esm({
   }
 });
 
+// ../../node_modules/@math.gl/arrow/dist/arrow/arrow-column-utils.js
+var init_arrow_column_utils = __esm({
+  "../../node_modules/@math.gl/arrow/dist/arrow/arrow-column-utils.js"() {
+  }
+});
+
 // ../../node_modules/@math.gl/arrow/dist/arrow/index.js
 var init_arrow = __esm({
   "../../node_modules/@math.gl/arrow/dist/arrow/index.js"() {
     init_indexed_arrow_table();
     init_indexed_arrow_vector();
     init_mapped_arrow_table();
+    init_arrow_schema_utils();
     init_rename_arrow_columns();
     init_split_arrow_buffers();
     init_arrow_table_transport();
+    init_arrow_column_utils();
   }
 });
 
@@ -26496,11 +27274,11 @@ var init_arrow_worker_transport = __esm({
 });
 
 // src/draco/lib/utils/version.ts
-var VERSION2;
+var VERSION4;
 var init_version2 = __esm({
   "src/draco/lib/utils/version.ts"() {
     "use strict";
-    VERSION2 = true ? "5.0.0-beta.6" : "latest";
+    VERSION4 = true ? "5.0.0-beta.8" : "latest";
   }
 });
 
@@ -26695,7 +27473,7 @@ var init_draco_loader_types = __esm({
       batchType: null,
       ...DracoFormat,
       // shapes: ['mesh'],
-      version: VERSION2,
+      version: VERSION4,
       worker: true,
       /** Node test workers live with the Draco implementation. */
       workerSourceNode: "draco/workers/draco-worker-node.ts",
@@ -26709,8 +27487,11 @@ var init_draco_loader_types = __esm({
   }
 });
 
+// ../core/src/polyfills/index.ts
+init_log();
+
 // ../core/src/polyfills/utils/is-browser.ts
-var isBrowser = (
+var isBrowser2 = (
   // @ts-ignore process.browser
   typeof process !== "object" || String(process) !== "[object process]" || process.browser
 );
@@ -28829,10 +29610,10 @@ var nodeVersion = parseInt(import_node_process.versions.node.split(".")[0]);
 var Blob = globalThis.Blob;
 var File = globalThis.File;
 installFilePolyfills();
-if (isBrowser) {
-  console.error(
+if (isBrowser2) {
+  log.error(
     "loaders.gl: The @loaders.gl/core/polyfills should only be used in Node.js environments"
-  );
+  )();
 }
 globalThis.loaders = globalThis.loaders || {};
 globalThis.loaders.makeNodeStream = makeNodeStream;