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

package/dist/draco-writer-worker-node.cjs

@@ -421,33 +421,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 +456,7 @@ var require_detect_libc = __commonJS({
       familySync: familySync2,
       isNonGlibcLinux,
       isNonGlibcLinuxSync,
-      version: version2,
+      version: version3,
       versionSync: versionSync2
     };
   }
@@ -658,31 +658,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 +933,12 @@ var require_parse = __commonJS({
   "../../node_modules/semver/functions/parse.js"(exports2, module2) {
     "use strict";
     var SemVer = require_semver();
-    var parse = (version2, options, throwErrors = false) => {
-      if (version2 instanceof SemVer) {
-        return version2;
+    var parse = (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 +955,8 @@ var require_valid = __commonJS({
   "../../node_modules/semver/functions/valid.js"(exports2, module2) {
     "use strict";
     var parse = require_parse();
-    var valid = (version2, options) => {
-      const v = parse(version2, options);
+    var valid = (version3, options) => {
+      const v = parse(version3, options);
       return v ? v.version : null;
     };
     module2.exports = valid;
@@ -968,8 +968,8 @@ var require_clean = __commonJS({
   "../../node_modules/semver/functions/clean.js"(exports2, module2) {
     "use strict";
     var parse = require_parse();
-    var clean = (version2, options) => {
-      const s = parse(version2.trim().replace(/^[=v]+/, ""), options);
+    var clean = (version3, options) => {
+      const s = parse(version3.trim().replace(/^[=v]+/, ""), options);
       return s ? s.version : null;
     };
     module2.exports = clean;
@@ -981,7 +981,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 +989,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 +1005,9 @@ var require_diff = __commonJS({
   "../../node_modules/semver/functions/diff.js"(exports2, module2) {
     "use strict";
     var parse = require_parse();
-    var diff = (version1, version2) => {
+    var diff = (version1, version22) => {
       const v1 = parse(version1, null, true);
-      const v2 = parse(version2, null, true);
+      const v2 = parse(version22, null, true);
       const comparison = v1.compare(v2);
       if (comparison === 0) {
         return null;
@@ -1079,8 +1079,8 @@ var require_prerelease = __commonJS({
   "../../node_modules/semver/functions/prerelease.js"(exports2, module2) {
     "use strict";
     var parse = require_parse();
-    var prerelease = (version2, options) => {
-      const parsed = parse(version2, options);
+    var prerelease = (version3, options) => {
+      const parsed = parse(version3, options);
       return parsed && parsed.prerelease.length ? parsed.prerelease : null;
     };
     module2.exports = prerelease;
@@ -1268,24 +1268,24 @@ var require_coerce = __commonJS({
     var SemVer = require_semver();
     var parse = 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 +1314,32 @@ var require_truncate = __commonJS({
     var parse = 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 parse(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 +1511,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 +1745,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 +1759,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 +1820,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 +1889,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 +2057,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 +2079,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 +2101,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 +2118,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 +2128,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 +2158,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 +2691,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 +2723,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 +2877,7 @@ var init_libvips = __esm({
       buildSharpLibvipsLibDir,
       isUnsupportedNodeRuntime,
       runtimePlatformArch,
-      log,
+      log: log2,
       yarnLocator,
       spawnRebuild,
       globalLibvipsVersion,
@@ -8471,8 +8471,556 @@ var require_flatbuffers = __commonJS({
   }
 });
 
+// ../../node_modules/probe.gl/dist/env/lib/globals.js
+var window_ = globalThis;
+var document_ = globalThis.document || {};
+var process_ = globalThis.process || {};
+var console_ = globalThis.console;
+var 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);
+}
+
+// ../../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();
+}
+
+// ../../node_modules/probe.gl/dist/env/index.js
+var 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");
+  }
+}
+
+// ../../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);
+}
+
+// ../../node_modules/probe.gl/dist/log/loggers/base-log.js
+var noop = () => {
+};
+var 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 = 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}`;
+}
+
+// ../../node_modules/probe.gl/dist/log/utils/color.js
+var COLOR;
+(function(COLOR2) {
+  COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
+  COLOR2[COLOR2["RED"] = 31] = "RED";
+  COLOR2[COLOR2["GREEN"] = 32] = "GREEN";
+  COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW";
+  COLOR2[COLOR2["BLUE"] = 34] = "BLUE";
+  COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA";
+  COLOR2[COLOR2["CYAN"] = 36] = "CYAN";
+  COLOR2[COLOR2["WHITE"] = 37] = "WHITE";
+  COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+  COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+  COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+  COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+  COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+  COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+  COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+  COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+})(COLOR || (COLOR = {}));
+var BACKGROUND_INCREMENT = 10;
+function getColor(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;
+}
+
+// ../../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);
+      }
+    }
+  }
+}
+
+// ../../node_modules/probe.gl/dist/log/probe.js
+var 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);
+  }
+};
+var probe = new Probe();
+globalThis.Probe = Probe;
+globalThis.probe = probe;
+
+// ../../node_modules/probe.gl/dist/log/loggers/probe-log.js
+var originalConsole = {
+  debug: isBrowser() ? console.debug || console.log : console.log,
+  log: console.log,
+  info: console.info,
+  warn: console.warn,
+  error: console.error
+};
+var DEFAULT_LOG_CONFIGURATION = {
+  enabled: true,
+  level: 0
+};
+var 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;
+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";
+}
+
+// ../../node_modules/probe.gl/dist/log/init.js
+if (!globalThis.probe) {
+  globalThis.probe = probe;
+}
+
+// ../../node_modules/probe.gl/dist/log/index.js
+var log = new ProbeLog({ id: "@probe.gl/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
 );
@@ -10591,10 +11139,10 @@ var nodeVersion = parseInt(import_node_process.versions.node.split(".")[0]);
 var Blob2 = 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;
@@ -10644,15 +11192,15 @@ var NPM_TAG = "beta";
 
 // ../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 = getVersion();
+var VERSION2 = 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.");
   }
@@ -10666,15 +11214,15 @@ var globals = {
   document: typeof document !== "undefined" && document
 };
 var self_ = globals.self || globals.window || globals.global || {};
-var window_ = globals.window || globals.self || globals.global || {};
-var global_ = globals.global || globals.self || globals.window || {};
-var document_ = globals.document || {};
-var isBrowser2 = (
+var window_2 = globals.window || globals.self || globals.global || {};
+var global_2 = globals.global || globals.self || globals.window || {};
+var document_2 = globals.document || {};
+var isBrowser3 = (
   // @ts-ignore process.browser
   typeof process !== "object" || String(process) !== "[object process]" || process.browser
 );
 var isWorker = typeof importScripts === "function";
-var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+var isMobile2 = typeof window !== "undefined" && typeof window.orientation !== "undefined";
 var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
 var nodeVersion2 = matches && parseFloat(matches[1]) || 0;
 
@@ -10683,12 +11231,12 @@ var NPM_TAG2 = "latest";
 
 // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/version.js
 function getVersion2() {
-  return false ? NPM_TAG2 : "5.0.0-beta.6";
+  return false ? NPM_TAG2 : "5.0.0-beta.8";
 }
-var VERSION2 = getVersion2();
+var VERSION3 = getVersion2();
 
 // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/env-utils/assert.js
-function assert2(condition, message) {
+function assert4(condition, message) {
   if (!condition) {
     throw new Error(message || "loaders.gl assertion failed.");
   }
@@ -10702,14 +11250,14 @@ var globals2 = {
   document: typeof document !== "undefined" && document
 };
 var self_2 = globals2.self || globals2.window || globals2.global || {};
-var window_2 = globals2.window || globals2.self || globals2.global || {};
-var global_2 = globals2.global || globals2.self || globals2.window || {};
-var document_2 = globals2.document || {};
-var isBrowser3 = (
+var window_3 = globals2.window || globals2.self || globals2.global || {};
+var global_3 = globals2.global || globals2.self || globals2.window || {};
+var document_3 = globals2.document || {};
+var isBrowser4 = (
   // @ts-ignore process.browser
   typeof process !== "object" || String(process) !== "[object process]" || process.browser
 );
-var isMobile2 = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+var isMobile3 = typeof window !== "undefined" && typeof window.orientation !== "undefined";
 var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
 var nodeVersion3 = matches2 && parseFloat(matches2[1]) || 0;
 
@@ -10842,7 +11390,7 @@ var NodeWorker = import_worker_threads.Worker;
 var workerURLCache = /* @__PURE__ */ new Map();
 function getLoadableWorkerURL(props) {
   var _a5, _b2, _c2;
-  assert2(props.source && !props.url || !props.source && props.url);
+  assert4(props.source && !props.url || !props.source && props.url);
   if (props.url && props.workerType === "module") {
     const baseUrl = ((_a5 = globalThis.document) == null ? void 0 : _a5.baseURI) ?? ((_b2 = globalThis.location) == null ? void 0 : _b2.href);
     if (!baseUrl)
@@ -10865,7 +11413,7 @@ function getLoadableWorkerURL(props) {
       workerURLCache.set(props.source, workerURL);
     }
   }
-  assert2(workerURL);
+  assert4(workerURL);
   return workerURL;
 }
 function getLoadableWorkerURLFromURL(url) {
@@ -10978,14 +11526,14 @@ var NOOP = () => {
 var WorkerThread = class {
   /** Checks if workers are supported on this platform */
   static isSupported() {
-    return typeof Worker !== "undefined" && isBrowser3 || typeof NodeWorker !== "undefined" && !isBrowser3;
+    return typeof Worker !== "undefined" && isBrowser4 || typeof NodeWorker !== "undefined" && !isBrowser4;
   }
   constructor(props) {
     this.terminated = false;
     this.createdAt = performance.now();
     this._loadableURL = "";
     const { name, source, url, getUrl, loadWorker } = props;
-    assert2(source || url || getUrl || loadWorker);
+    assert4(source || url || getUrl || loadWorker);
     this.name = name;
     this.source = source;
     this.url = url;
@@ -10995,7 +11543,7 @@ var WorkerThread = class {
     this.onMessage = NOOP;
     this.onError = (error) => console.log(error);
     const startedAt = performance.now();
-    this.worker = isBrowser3 ? this._createBrowserWorker() : this._createNodeWorker();
+    this.worker = isBrowser4 ? this._createBrowserWorker() : this._createNodeWorker();
     this.creationTimeMs = performance.now() - startedAt;
   }
   /**
@@ -11014,13 +11562,13 @@ var WorkerThread = class {
   }
   /** Keeps this worker from preventing Node.js process exit while idle. */
   unref() {
-    if (!isBrowser3 && typeof this.worker.unref === "function") {
+    if (!isBrowser4 && typeof this.worker.unref === "function") {
       this.worker.unref();
     }
   }
   /** Keeps this worker alive while it is actively processing a job. */
   ref() {
-    if (!isBrowser3 && typeof this.worker.ref === "function") {
+    if (!isBrowser4 && typeof this.worker.ref === "function") {
       this.worker.ref();
     }
   }
@@ -11680,7 +12228,7 @@ var WorkerPool = class {
     return null;
   }
   _getMaxConcurrency() {
-    return isMobile2 ? this.maxMobileConcurrency : this.maxConcurrency;
+    return isMobile3 ? this.maxMobileConcurrency : this.maxConcurrency;
   }
 };
 
@@ -11962,16 +12510,16 @@ var AsyncQueue = class {
 // ../../node_modules/@math.gl/tasks/dist/worker-utils/lib/worker-api/get-worker-url.js
 var warnedWorkerVersionFallbacks = /* @__PURE__ */ new Set();
 function getWorkerName(worker) {
-  const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
+  const warning = worker.version !== VERSION3 ? ` (worker-utils@${VERSION3})` : "";
   return `${worker.name}@${worker.version}${warning}`;
 }
 function getCustomWorkerURL(worker, options = {}) {
   var _a5, _b2;
-  const workerFile = isBrowser3 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  const workerFile = isBrowser4 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
   let url = getConfiguredWorkerURL(worker, options);
   const workerType = options._workerType || ((_a5 = options == null ? void 0 : options.core) == null ? void 0 : _a5._workerType);
   if (!url && workerType === "test") {
-    if (isBrowser3) {
+    if (isBrowser4) {
       url = `modules/${worker.module}/dist/${workerFile}`;
     } else {
       const workerSourceDirectory = worker.module === "tasks" && ((_b2 = worker.workerNode) == null ? void 0 : _b2.startsWith("worker-utils/")) ? "worker-utils/workers" : "workers";
@@ -11989,16 +12537,16 @@ function getWorkerURL(worker, options = {}) {
   const customWorkerUrl = getCustomWorkerURL(worker, options);
   const descriptorWorkerUrl = typeof worker.worker === "string" ? worker.worker : null;
   const url = customWorkerUrl || descriptorWorkerUrl || getDefaultWorkerURL(worker, true);
-  assert2(url);
+  assert4(url);
   return url;
 }
 function getDefaultWorkerURL(worker, warn = false) {
-  const workerFile = isBrowser3 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
-  let version2 = worker.version;
-  if (version2 === "latest") {
-    version2 = NPM_TAG2;
+  const workerFile = isBrowser4 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  let version3 = worker.version;
+  if (version3 === "latest") {
+    version3 = NPM_TAG2;
   }
-  const versionTag = version2 ? `@${version2}` : "";
+  const versionTag = version3 ? `@${version3}` : "";
   const packageName = worker.packageName || `@loaders.gl/${worker.module}`;
   const url = `https://unpkg.com/${packageName}${versionTag}/dist/${workerFile}`;
   if (warn) {
@@ -12026,7 +12574,7 @@ function getWorkerCapabilities() {
     sharedMemory: false,
     crossOriginIsolated: isolated
   };
-  if (isBrowser3 && isolated !== true) {
+  if (isBrowser4 && isolated !== true) {
     capabilities.sharedMemoryUnavailableReason = "cross-origin-isolation";
   } else if (typeof SharedArrayBuffer === "undefined" || typeof Atomics === "undefined" || typeof structuredClone !== "function") {
     capabilities.sharedMemoryUnavailableReason = "unsupported";
@@ -12366,7 +12914,7 @@ function getWorkerPoolTarget(worker, options, name) {
   if (customWorkerUrl) {
     return { name, url: customWorkerUrl, workerType: options.workerType };
   }
-  if (isBrowser3 && worker.loadWorker) {
+  if (isBrowser4 && worker.loadWorker) {
     return {
       name,
       workerType: options.workerType,
@@ -14018,15 +14566,54 @@ function assertNoTransferAlias(input, options, ownership) {
   }
 }
 
+// ../core/src/loader-utils/lib/log-utils/log.ts
+var VERSION4 = true ? "5.0.0-beta.8" : "latest";
+var version2 = VERSION4[0] >= "0" && VERSION4[0] <= "9" ? `v${VERSION4}` : "";
+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;
+}
+var log3 = createLog();
+var 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;
+  }
+};
+function ignoreMessage() {
+}
+var nullLog = new NullLog();
+
 // ../core/src/worker-utils/lib/worker-api/get-worker-url.ts
 var warnedWorkerVersionFallbacks2 = /* @__PURE__ */ new Set();
 function getCustomWorkerURL2(worker, options = {}) {
   var _a5, _b2;
-  const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  const workerFile = isBrowser3 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
   let url = getConfiguredWorkerURL2(worker, options);
   const workerType = options._workerType || ((_a5 = options == null ? void 0 : options.core) == null ? void 0 : _a5._workerType);
   if (!url && workerType === "test") {
-    if (isBrowser2) {
+    if (isBrowser3) {
       url = `modules/${worker.module}/dist/${workerFile}`;
     } else {
       const workerSourceDirectory = worker.module === "core" && ((_b2 = worker.workerNode) == null ? void 0 : _b2.startsWith("worker-utils/")) ? "worker-utils/workers" : "workers";
@@ -14044,16 +14631,16 @@ function getWorkerURL2(worker, options = {}) {
   const customWorkerUrl = getCustomWorkerURL2(worker, options);
   const descriptorWorkerUrl = typeof worker.worker === "string" ? worker.worker : null;
   const url = customWorkerUrl || descriptorWorkerUrl || getDefaultWorkerURL2(worker, true);
-  assert(url);
+  assert3(url);
   return url;
 }
 function getDefaultWorkerURL2(worker, warn = false) {
-  const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
-  let version2 = worker.version;
-  if (version2 === "latest") {
-    version2 = NPM_TAG;
+  const workerFile = isBrowser3 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  let version3 = worker.version;
+  if (version3 === "latest") {
+    version3 = NPM_TAG;
   }
-  const versionTag = version2 ? `@${version2}` : "";
+  const versionTag = version3 ? `@${version3}` : "";
   const url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
   if (warn) {
     warnIfUsingNpmTagFallback2(worker, url);
@@ -14069,9 +14656,9 @@ function warnIfUsingNpmTagFallback2(worker, url) {
     return;
   }
   warnedWorkerVersionFallbacks2.add(workerId);
-  console.warn(
+  log3.warn(
     `loaders.gl: ${worker.name} loader worker version is "latest" because __VERSION__ was not injected. Fetching ${url} from CDN.`
-  );
+  )();
 }
 
 // ../core/src/worker-utils/lib/worker-api/task-runtime.ts
@@ -14146,7 +14733,7 @@ var runners = /* @__PURE__ */ new WeakMap();
 var activeRunners = /* @__PURE__ */ new Set();
 var moduleWorkerUrls = /* @__PURE__ */ new Map();
 function canProcessOnWorker2(worker, options = {}) {
-  const supported = isBrowser2 ? typeof Worker !== "undefined" : Boolean(options._nodeWorkers);
+  const supported = isBrowser3 ? typeof Worker !== "undefined" : Boolean(options._nodeWorkers);
   return Boolean(
     supported && options.worker && (worker.worker || worker.loadWorker || getConfiguredWorkerURL2(worker, options))
   );
@@ -14175,7 +14762,7 @@ function getTask(worker, options) {
     throw new Error(
       "Inline legacy worker source is unsupported; use a TaskRunner worker URL or factory"
     );
-  const create = !getCustomWorkerURL2(worker, options) && isBrowser2 ? worker.loadWorker : void 0;
+  const create = !getCustomWorkerURL2(worker, options) && isBrowser3 ? worker.loadWorker : void 0;
   const url = getWorkerURL2(worker, options);
   return {
     id: `${worker.module}:${worker.id}`,
@@ -14210,7 +14797,7 @@ async function openSession(worker, options, context, jobContext) {
   if (!state) {
     state = {
       runner: new TaskRunner({
-        maxConcurrency: isMobile ? options.maxMobileConcurrency ?? 1 : options.maxConcurrency ?? 3
+        maxConcurrency: isMobile2 ? options.maxMobileConcurrency ?? 1 : options.maxConcurrency ?? 3
       }),
       requests: 0
     };
@@ -14473,15 +15060,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}@${VERSION2}/dist/libs/${libraryName}`;
   }
   if (isWorker) {
     return libraryName.endsWith(".mjs") ? `./libs/${libraryName}` : `../src/libs/${libraryName}`;
@@ -14492,7 +15079,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));
@@ -14507,7 +15094,7 @@ async function loadLibraryFromFile(libraryUrl, moduleLibraryUrl) {
         } catch {
         }
       }
-      console.error(error);
+      log3.error(String(error))();
       return null;
     }
   }
@@ -14544,7 +15131,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();
   }
@@ -14559,7 +15146,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();
   }
@@ -14581,10 +15168,10 @@ var globals3 = {
   document: typeof document !== "undefined" && document
 };
 var self_3 = globals3.self || globals3.window || globals3.global || {};
-var window_3 = globals3.window || globals3.self || globals3.global || {};
-var global_3 = globals3.global || globals3.self || globals3.window || {};
-var document_3 = globals3.document || {};
-var isBrowser4 = (
+var window_4 = globals3.window || globals3.self || globals3.global || {};
+var global_4 = globals3.global || globals3.self || globals3.window || {};
+var document_4 = globals3.document || {};
+var isBrowser5 = (
   // @ts-ignore process does not exist on browser
   Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
 );
@@ -14626,7 +15213,7 @@ function canEncodeWithWorker(writer, options) {
   var _a5, _b2;
   const nodeWorkers = (options == null ? void 0 : options._nodeWorkers) ?? ((_a5 = options == null ? void 0 : options.core) == null ? void 0 : _a5._nodeWorkers);
   const useWorkers = (options == null ? void 0 : options.worker) ?? ((_b2 = options == null ? void 0 : options.core) == null ? void 0 : _b2.worker);
-  if (!isBrowser4 && !nodeWorkers) {
+  if (!isBrowser5 && !nodeWorkers) {
     return false;
   }
   return canProcessOnWorker2(
@@ -21413,8 +22000,8 @@ var Footer = class _Footer {
   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);
@@ -21644,9 +22231,9 @@ var Footer_ = class {
   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);
   }
@@ -21769,8 +22356,8 @@ var Message = class _Message {
   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);
@@ -21804,9 +22391,9 @@ var Message = class _Message {
   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);
@@ -22126,10 +22713,10 @@ var Message2 = class _Message {
     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;
   }
@@ -22206,8 +22793,8 @@ var Message2 = class _Message {
   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;
@@ -22331,16 +22918,16 @@ BufferRegion["encode"] = encodeBufferRegion;
 BufferRegion["decode"] = decodeBufferRegion;
 BodyCompression2["encode"] = encodeBodyCompression;
 BodyCompression2["decode"] = decodeBodyCompression;
-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());
@@ -22357,11 +22944,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);
@@ -28475,14 +29062,14 @@ var GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP = {
   COLOR_0: "COLOR",
   TEXCOORD_0: "TEX_COORD"
 };
-var noop = () => {
+var noop2 = () => {
 };
 var DracoBuilder = class {
   draco;
   dracoEncoder;
   dracoMeshBuilder;
   dracoMetadataBuilder;
-  log = noop;
+  log = noop2;
   // draco - the draco decoder, either import `draco3d` or load dynamically
   constructor(draco) {
     this.draco = draco;
@@ -28516,7 +29103,7 @@ var DracoBuilder = class {
   /** Shared implementation for ordinary encoding and report-producing encoding. */
   _encodeSync(mesh, options, trackEncodedProperties) {
     options = applyDracoEncodingPreset(options);
-    this.log = options.log || noop;
+    this.log = options.log || noop2;
     return options.pointcloud ? this._encodePointCloud(mesh, options, trackEncodedProperties) : this._encodeMesh(mesh, options, trackEncodedProperties);
   }
   // PRIVATE
@@ -29108,7 +29695,7 @@ function applyDracoEncodingPreset(options) {
 // 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,
@@ -29185,7 +29772,7 @@ async function loadDracoEncoder(options) {
   try {
     [encoderLibrary, wasmBinary] = await loadEncoderWasmAssets(options);
   } catch (error) {
-    if (isBrowser2 || options.useLocalLibraries) {
+    if (isBrowser3 || options.useLocalLibraries) {
       throw error;
     }
     [encoderLibrary, wasmBinary] = await loadEncoderWasmAssets({
@@ -29265,7 +29852,7 @@ function getLibraryCacheKey2(type, options) {
 }
 
 // src/draco/lib/utils/version.ts
-var VERSION3 = true ? "5.0.0-beta.6" : "latest";
+var VERSION5 = true ? "5.0.0-beta.8" : "latest";
 
 // src/draco/draco-format.ts
 var DracoFormat = {
@@ -29297,7 +29884,7 @@ var DracoWriterWorker = {
   id: "draco-writer",
   name: "Draco compressed geometry writer",
   module: "scene",
-  version: VERSION3,
+  version: VERSION5,
   worker: true,
   workerNode: "draco-writer-worker-node.cjs",
   /** Node test workers live with the Draco implementation. */
@@ -29309,7 +29896,7 @@ var DracoWriterWorker = {
 var DracoWriter = {
   ...DracoFormat,
   name: "DRACO",
-  version: VERSION3,
+  version: VERSION5,
   options: {
     draco: DEFAULT_DRACO_WRITER_OPTIONS
   },