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

package/dist/draco-writer-worker.js

@@ -50,10 +50,10 @@
 
   // ../core/src/worker-utils/lib/env-utils/version.ts
   function getVersion() {
-    const version = false ? NPM_TAG : "5.0.0-beta.6";
+    const version2 = false ? NPM_TAG : "5.0.0-beta.8";
     globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-    globalThis._loadersgl_.version ||= version;
-    return version;
+    globalThis._loadersgl_.version ||= version2;
+    return version2;
   }
   var VERSION = getVersion();
 
@@ -89,7 +89,7 @@
 
   // ../../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();
 
@@ -1401,11 +1401,11 @@
   }
   function getDefaultWorkerURL(worker, warn = false) {
     const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
-    let version = worker.version;
-    if (version === "latest") {
-      version = NPM_TAG2;
+    let version2 = worker.version;
+    if (version2 === "latest") {
+      version2 = NPM_TAG2;
     }
-    const versionTag = version ? `@${version}` : "";
+    const versionTag = version2 ? `@${version2}` : "";
     const packageName = worker.packageName || `@loaders.gl/${worker.module}`;
     const url = `https://unpkg.com/${packageName}${versionTag}/dist/${workerFile}`;
     if (warn) {
@@ -3376,6 +3376,590 @@
     }
   }
 
+  // ../../node_modules/probe.gl/dist/env/lib/globals.js
+  var window_3 = globalThis;
+  var document_3 = 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) {
+    if (typeof window !== "undefined" && window.process?.type === "renderer") {
+      return true;
+    }
+    if (typeof process !== "undefined" && Boolean(process.versions?.["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 isBrowser3() {
+    const isNode = (
+      // @ts-expect-error
+      typeof process === "object" && String(process) === "[object process]" && !process?.browser
+    );
+    return !isNode || isElectron();
+  }
+
+  // ../../node_modules/probe.gl/dist/env/index.js
+  var VERSION3 = true ? "5.0.0" : "untranspiled source";
+
+  // ../../node_modules/probe.gl/dist/log/utils/assert.js
+  function assert4(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;
+    }
+    assert4(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;
+    assert4(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(string, length = 8) {
+    const padLength = Math.max(length - string.length, 0);
+    return `${" ".repeat(padLength)}${string}`;
+  }
+
+  // ../../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(color) {
+    if (typeof color !== "string") {
+      return color;
+    }
+    color = color.toUpperCase();
+    return COLOR[color] || COLOR.WHITE;
+  }
+  function addColor(string, color, background) {
+    if (!isBrowser3 && typeof string === "string") {
+      if (color) {
+        const colorCode = getColor(color);
+        string = `\x1B[${colorCode}m${string}\x1B[39m`;
+      }
+      if (background) {
+        const colorCode = getColor(background);
+        string = `\x1B[${colorCode + BACKGROUND_INCREMENT}m${string}\x1B[49m`;
+      }
+    }
+    return string;
+  }
+
+  // ../../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 object = obj;
+    for (const key of propNames) {
+      const value = object[key];
+      if (typeof value === "function") {
+        if (!predefined.find((name) => key === name)) {
+          object[key] = value.bind(obj);
+        }
+      }
+    }
+  }
+
+  // ../../node_modules/probe.gl/dist/log/probe.js
+  var Probe = class {
+    getHighResolutionTimer() {
+      let timestamp;
+      if (isBrowser3() && window_3.performance) {
+        timestamp = window_3?.performance?.now?.();
+      } else if ("hrtime" in process_) {
+        const timeParts = process_?.hrtime?.();
+        timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+      } else {
+        timestamp = Date.now();
+      }
+      return timestamp;
+    }
+    getMemoryUsageMB() {
+      const performance2 = window_3?.performance;
+      const usedJSHeapSize = performance2?.memory?.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: isBrowser3() ? 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 = VERSION3;
+      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;
+      assert4(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 = VERSION3;
+  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/loader-utils/lib/log-utils/log.ts
+  var VERSION4 = true ? "5.0.0-beta.8" : "latest";
+  var version = VERSION4[0] >= "0" && VERSION4[0] <= "9" ? `v${VERSION4}` : "";
+  function createLog() {
+    const log3 = new ProbeLog({ id: "loaders.gl" });
+    globalThis.loaders ||= {};
+    globalThis.loaders.log = log3;
+    globalThis.loaders.version = version;
+    globalThis.probe ||= {};
+    globalThis.probe.loaders = log3;
+    return log3;
+  }
+  var log2 = 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 = {}) {
@@ -3406,11 +3990,11 @@
   }
   function getDefaultWorkerURL2(worker, warn = false) {
     const workerFile = isBrowser ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
-    let version = worker.version;
-    if (version === "latest") {
-      version = NPM_TAG;
+    let version2 = worker.version;
+    if (version2 === "latest") {
+      version2 = NPM_TAG;
     }
-    const versionTag = version ? `@${version}` : "";
+    const versionTag = version2 ? `@${version2}` : "";
     const url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
     if (warn) {
       warnIfUsingNpmTagFallback2(worker, url);
@@ -3426,9 +4010,9 @@
       return;
     }
     warnedWorkerVersionFallbacks2.add(workerId);
-    console.warn(
+    log2.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
@@ -3846,7 +4430,7 @@
           } catch {
           }
         }
-        console.error(error);
+        log2.error(String(error))();
         return null;
       }
     }
@@ -3920,10 +4504,10 @@
     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 isBrowser3 = (
+  var window_4 = globals3.window || globals3.self || globals3.global || {};
+  var global_4 = globals3.global || globals3.self || globals3.window || {};
+  var document_4 = globals3.document || {};
+  var isBrowser4 = (
     // @ts-ignore process does not exist on browser
     Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
   );
@@ -3964,7 +4548,7 @@
   function canEncodeWithWorker(writer, options) {
     const nodeWorkers = options?._nodeWorkers ?? options?.core?._nodeWorkers;
     const useWorkers = options?.worker ?? options?.core?.worker;
-    if (!isBrowser3 && !nodeWorkers) {
+    if (!isBrowser4 && !nodeWorkers) {
       return false;
     }
     return canProcessOnWorker2(
@@ -11468,8 +12052,8 @@ return true;`);
     static startFooter(builder) {
       builder.startObject(5);
     }
-    static addVersion(builder, version) {
-      builder.addFieldInt16(0, version, MetadataVersion.V1);
+    static addVersion(builder, version2) {
+      builder.addFieldInt16(0, version2, MetadataVersion.V1);
     }
     static addSchema(builder, schemaOffset) {
       builder.addFieldOffset(1, schemaOffset, 0);
@@ -11696,9 +12280,9 @@ return true;`);
     get numDictionaries() {
       return this._dictionaryBatches.length;
     }
-    constructor(schema, version = MetadataVersion.V5, recordBatches, dictionaryBatches) {
+    constructor(schema, version2 = MetadataVersion.V5, recordBatches, dictionaryBatches) {
       this.schema = schema;
-      this.version = version;
+      this.version = version2;
       recordBatches && (this._recordBatches = recordBatches);
       dictionaryBatches && (this._dictionaryBatches = dictionaryBatches);
     }
@@ -11817,8 +12401,8 @@ return true;`);
     static startMessage(builder) {
       builder.startObject(5);
     }
-    static addVersion(builder, version) {
-      builder.addFieldInt16(0, version, MetadataVersion.V1);
+    static addVersion(builder, version2) {
+      builder.addFieldInt16(0, version2, MetadataVersion.V1);
     }
     static addHeaderType(builder, headerType) {
       builder.addFieldInt8(1, headerType, MessageHeader.NONE);
@@ -11852,9 +12436,9 @@ return true;`);
     static finishSizePrefixedMessageBuffer(builder, offset) {
       builder.finish(offset, void 0, true);
     }
-    static createMessage(builder, version, headerType, headerOffset, bodyLength, customMetadataOffset) {
+    static createMessage(builder, version2, headerType, headerOffset, bodyLength, customMetadataOffset) {
       _Message.startMessage(builder);
-      _Message.addVersion(builder, version);
+      _Message.addVersion(builder, version2);
       _Message.addHeaderType(builder, headerType);
       _Message.addHeader(builder, headerOffset);
       _Message.addBodyLength(builder, bodyLength);
@@ -12174,10 +12758,10 @@ return true;`);
       buf = new ByteBuffer3(toUint8Array(buf));
       const _message = Message.getRootAsMessage(buf);
       const bodyLength = _message.bodyLength();
-      const version = _message.version();
+      const version2 = _message.version();
       const headerType = _message.headerType();
       const metadata = decodeMessageCustomMetadata(_message);
-      const message = new _Message(bodyLength, version, headerType, void 0, metadata);
+      const message = new _Message(bodyLength, version2, headerType, void 0, metadata);
       message._createHeader = decodeMessageHeader(_message, headerType);
       return message;
     }
@@ -12254,8 +12838,8 @@ return true;`);
     isDictionaryBatch() {
       return this.headerType === MessageHeader.DictionaryBatch;
     }
-    constructor(bodyLength, version, headerType, header, metadata) {
-      this._version = version;
+    constructor(bodyLength, version2, headerType, header, metadata) {
+      this._version = version2;
       this._headerType = headerType;
       this.body = new Uint8Array(0);
       this._compression = header === null || header === void 0 ? void 0 : header.compression;
@@ -12379,16 +12963,16 @@ return true;`);
   BufferRegion["decode"] = decodeBufferRegion;
   BodyCompression2["encode"] = encodeBodyCompression;
   BodyCompression2["decode"] = decodeBodyCompression;
-  function decodeSchema(_schema, dictionaries = /* @__PURE__ */ new Map(), version = MetadataVersion.V5) {
+  function decodeSchema(_schema, dictionaries = /* @__PURE__ */ new Map(), version2 = MetadataVersion.V5) {
     const fields = decodeSchemaFields(_schema, dictionaries);
-    return new Schema2(fields, decodeCustomMetadata(_schema), dictionaries, version);
+    return new Schema2(fields, decodeCustomMetadata(_schema), dictionaries, version2);
   }
-  function decodeRecordBatch(batch, version = MetadataVersion.V5) {
-    const recordBatch = new RecordBatch2(batch.length(), decodeFieldNodes(batch), decodeBuffers(batch, version), decodeBodyCompression(batch.compression()), decodeVariadicBufferCounts(batch));
+  function decodeRecordBatch(batch, version2 = MetadataVersion.V5) {
+    const recordBatch = new RecordBatch2(batch.length(), decodeFieldNodes(batch), decodeBuffers(batch, version2), decodeBodyCompression(batch.compression()), decodeVariadicBufferCounts(batch));
     return recordBatch;
   }
-  function decodeDictionaryBatch(batch, version = MetadataVersion.V5) {
-    return new DictionaryBatch2(RecordBatch2.decode(batch.data(), version), batch.id(), batch.isDelta());
+  function decodeDictionaryBatch(batch, version2 = MetadataVersion.V5) {
+    return new DictionaryBatch2(RecordBatch2.decode(batch.data(), version2), batch.id(), batch.isDelta());
   }
   function decodeBufferRegion(b) {
     return new BufferRegion(b.offset(), b.length());
@@ -12405,11 +12989,11 @@ return true;`);
     }
     return nodes;
   }
-  function decodeBuffers(batch, version) {
+  function decodeBuffers(batch, version2) {
     const bufferRegions = [];
     for (let b, i = -1, j = -1, n = batch.buffersLength(); ++i < n; ) {
       if (b = batch.buffers(i)) {
-        if (version < MetadataVersion.V4) {
+        if (version2 < MetadataVersion.V4) {
           b.bb_pos += 8 * (i + 1);
         }
         bufferRegions[++j] = BufferRegion.decode(b);
@@ -18245,14 +18829,14 @@ return true;`);
     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;
@@ -18286,7 +18870,7 @@ return true;`);
     /** 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
@@ -19032,7 +19616,7 @@ return true;`);
   }
 
   // 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 = {
@@ -19064,7 +19648,7 @@ return true;`);
     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. */
@@ -19076,7 +19660,7 @@ return true;`);
   var DracoWriter = {
     ...DracoFormat,
     name: "DRACO",
-    version: VERSION3,
+    version: VERSION5,
     options: {
       draco: DEFAULT_DRACO_WRITER_OPTIONS
     },