@loaders.gl/pointclouds 5.0.0-beta.7 → 5.0.0-beta.8

package/dist/dist.dev.js

@@ -8041,8 +8041,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);
@@ -8288,9 +8288,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);
         }
@@ -8418,8 +8418,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);
@@ -8453,9 +8453,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);
@@ -8827,16 +8827,16 @@ return true;`);
       throw new Error(`Unrecognized Message type: { name: ${MessageHeader[type]}, type: ${type} }`);
     });
   }
-  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());
@@ -8853,11 +8853,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);
@@ -9182,10 +9182,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;
         }
@@ -9262,8 +9262,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;
@@ -16242,6 +16242,18 @@ return true;`);
     }
   });
 
+  // ../../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 ?? [];
@@ -16345,27 +16357,43 @@ return true;`);
     }
   });
 
+  // ../../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();
     }
   });
 
@@ -16419,15 +16447,23 @@ return true;`);
     }
   });
 
+  // ../../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();
     }
   });
 
@@ -16474,6 +16510,734 @@ return true;`);
     }
   });
 
+  // ../../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) {
+    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);
+  }
+  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?.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 VERSION2;
+  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();
+      VERSION2 = 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(string, length = 8) {
+    const padLength = Math.max(length - string.length, 0);
+    return `${" ".repeat(padLength)}${string}`;
+  }
+  var init_formatters = __esm({
+    "../../node_modules/probe.gl/dist/log/utils/formatters.js"() {
+    }
+  });
+
+  // ../../node_modules/probe.gl/dist/log/utils/color.js
+  function getColor(color) {
+    if (typeof color !== "string") {
+      return color;
+    }
+    color = color.toUpperCase();
+    return COLOR[color] || COLOR.WHITE;
+  }
+  function addColor(string, color, background) {
+    if (!isBrowser && 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;
+  }
+  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 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);
+        }
+      }
+    }
+  }
+  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() {
+          let timestamp;
+          if (isBrowser() && window_.performance) {
+            timestamp = window_?.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 performance = window_?.performance;
+          const usedJSHeapSize = performance?.memory?.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 = VERSION2;
+          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 = VERSION2;
+    }
+  });
+
+  // ../../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" });
+    }
+  });
+
+  // ../core/src/loader-utils/lib/log-utils/log.ts
+  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;
+  }
+  function ignoreMessage() {
+  }
+  var VERSION3, version, log2, NullLog, nullLog;
+  var init_log2 = __esm({
+    "../core/src/loader-utils/lib/log-utils/log.ts"() {
+      "use strict";
+      init_log();
+      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      version = VERSION3[0] >= "0" && VERSION3[0] <= "9" ? `v${VERSION3}` : "";
+      log2 = 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/binary-utils/array-buffer-utils.ts
   function concatenateArrayBuffers(...sources) {
     return concatenateArrayBuffersFromArray(sources);
@@ -17020,14 +17784,14 @@ return true;`);
   }
   function createPointDecompressor(stream, metadata, outputMode, selection) {
     const extraByteCount = getExtraByteCount(metadata);
-    for (const version of [
+    for (const version2 of [
       metadata.point10ItemVersion,
       metadata.gpsTime11ItemVersion,
       metadata.rgb12ItemVersion,
       metadata.byteItemVersion
     ]) {
-      if (version !== void 0 && version !== 1 && version !== 2) {
-        throw new Error(`Unsupported legacy LASzip item version ${version}`);
+      if (version2 !== void 0 && version2 !== 1 && version2 !== 2) {
+        throw new Error(`Unsupported legacy LASzip item version ${version2}`);
       }
     }
     switch (metadata.pointDataRecordFormat) {
@@ -21726,7 +22490,7 @@ return true;`);
       metadata.gpsTime11ItemVersion,
       metadata.rgb12ItemVersion,
       metadata.byteItemVersion
-    ].some((version) => version !== void 0 && version !== 2)) {
+    ].some((version2) => version2 !== void 0 && version2 !== 2)) {
       throw new Error("TypeScript LAZ encoder only supports legacy item version 2");
     }
     if (!Number.isInteger(metadata.pointCount) || metadata.pointCount < 0) {
@@ -23056,6 +23820,7 @@ return true;`);
   var init_loader_utils = __esm({
     "../core/src/loader-utils/index.ts"() {
       "use strict";
+      init_log2();
       init_binary_chunk_reader();
       init_text_iterators();
       init_async_iteration();
@@ -23113,9 +23878,9 @@ return true;`);
     }
     const view = new DataView(record.data.buffer, record.data.byteOffset, record.data.byteLength);
     if (view.byteLength < 4) throw new Error("LASLoader: truncated LASzip compatibility VLR");
-    const version = view.getUint16(2, true);
-    if (version !== 3 && version !== 4 || view.byteLength !== (version === 3 ? 156 : 174)) {
-      throw new Error(`LASLoader: unsupported LASzip compatibility VLR version ${version} or length`);
+    const version2 = view.getUint16(2, true);
+    if (version2 !== 3 && version2 !== 4 || view.byteLength !== (version2 === 3 ? 156 : 174)) {
+      throw new Error(`LASLoader: unsupported LASzip compatibility VLR version ${version2} or length`);
     }
     const offsets = /* @__PURE__ */ new Map();
     let byteOffset = 0;
@@ -23145,7 +23910,7 @@ return true;`);
       throw new Error("LASLoader: compatibility waveform color points require NIR");
     return {
       pointDataRecordFormat,
-      version: version === 3 ? "1.4" : "1.5",
+      version: version2 === 3 ? "1.4" : "1.5",
       scanAngleByteOffset,
       returnsByteOffset,
       classificationByteOffset,
@@ -24117,8 +24882,8 @@ return true;`);
   }
   function parseLASMetadata(arrayBuffer, header) {
     const dataView = new DataView(arrayBuffer);
-    const version = header.versionAsString || "1.0";
-    const versionParts = version.split(".").map(Number);
+    const version2 = header.versionAsString || "1.0";
+    const versionParts = version2.split(".").map(Number);
     const isAtLeast14 = versionParts[0] > 1 || versionParts[0] === 1 && versionParts[1] >= 4;
     const vlrs = parseLASVariableLengthRecords(dataView, header);
     const evlrOffset = isAtLeast14 ? readUint64(dataView, 235) : 0;
@@ -25279,10 +26044,10 @@ return true;`);
       chunkTableBytes.byteOffset,
       chunkTableBytes.byteLength
     );
-    const version = dataView.getUint32(0, true);
+    const version2 = dataView.getUint32(0, true);
     const chunkCount = dataView.getUint32(4, true);
-    if (version !== 0) {
-      throw new Error(`LASLoader: unsupported LAZ chunk table version ${version}`);
+    if (version2 !== 0) {
+      throw new Error(`LASLoader: unsupported LAZ chunk table version ${version2}`);
     }
     if (chunkCount === 0) {
       if (header.pointsCount !== 0) {
@@ -26695,18 +27460,18 @@ return true;`);
     const { PCDLoaderWithParser: PCDLoaderWithParser2 } = await Promise.resolve().then(() => (init_pcd_loader2(), pcd_loader_exports));
     return PCDLoaderWithParser2;
   }
-  var VERSION3, PCDLoader, PCDWorkerLoader;
+  var VERSION5, PCDLoader, PCDWorkerLoader;
   var init_pcd_loader_types = __esm({
     "src/pcd/pcd-loader-types.ts"() {
       "use strict";
       init_pcd_format();
       init_arrow_worker_transport();
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       PCDLoader = {
         ...PCDFormat,
         dataType: null,
         batchType: null,
-        version: VERSION3,
+        version: VERSION5,
         worker: true,
         /** Enables the stateful input/output batch protocol on the built-in worker. */
         workerInBatches: true,
@@ -28590,7 +29355,7 @@ return true;`);
           currentElement?.properties.push(property);
           break;
         default:
-          console.log("unhandled", lineType, lineValues);
+          log2.log(0, "unhandled", lineType, lineValues)();
       }
       return false;
     });
@@ -28713,6 +29478,7 @@ return true;`);
     "src/ply/lib/parse-ply-in-batches.ts"() {
       "use strict";
       init_loader_utils();
+      init_loader_utils();
       init_normalize_ply();
       init_parse_ply();
       init_parse_ply_arrow();
@@ -28850,19 +29616,19 @@ return true;`);
     const { PLYLoaderWithParser: PLYLoaderWithParser2 } = await Promise.resolve().then(() => (init_ply_loader2(), ply_loader_exports));
     return PLYLoaderWithParser2;
   }
-  var VERSION5, PLYLoader, PLYWorkerLoader;
+  var VERSION7, PLYLoader, PLYWorkerLoader;
   var init_ply_loader_types = __esm({
     "src/ply/ply-loader-types.ts"() {
       "use strict";
       init_ply_format();
       init_arrow_worker_transport();
-      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       PLYLoader = {
         dataType: null,
         batchType: null,
         ...PLYFormat,
         // shapes: ['mesh', 'gltf', 'columnar-table'],
-        version: VERSION5,
+        version: VERSION7,
         worker: true,
         /** Enables the stateful input/output batch protocol on the built-in worker. */
         workerInBatches: true,
@@ -28911,7 +29677,7 @@ return true;`);
   init_loader_utils();
   init_schema_utils();
   init_las_format();
-  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var LAS_HEADER_LENGTH = 227;
   var LAS_1_4_HEADER_LENGTH = 375;
   var LAS_1_5_HEADER_LENGTH = 393;
@@ -28937,7 +29703,7 @@ return true;`);
     ...LASFormat,
     dataType: null,
     batchType: null,
-    version: VERSION2,
+    version: VERSION4,
     extensions: ["las", "laz"],
     options: {
       las: {}
@@ -29003,17 +29769,17 @@ return true;`);
       );
     }
     validateExtraBytesVLR(extraByteFields);
-    const version = options.las?.version || (pointDataRecordFormat >= 6 ? "1.4" : "1.2");
-    const headerLength = version === "1.5" ? LAS_1_5_HEADER_LENGTH : version === "1.4" ? LAS_1_4_HEADER_LENGTH : LAS_HEADER_LENGTH;
-    validateLASVersionOptions(version, pointDataRecordFormat, options);
+    const version2 = options.las?.version || (pointDataRecordFormat >= 6 ? "1.4" : "1.2");
+    const headerLength = version2 === "1.5" ? LAS_1_5_HEADER_LENGTH : version2 === "1.4" ? LAS_1_4_HEADER_LENGTH : LAS_HEADER_LENGTH;
+    validateLASVersionOptions(version2, pointDataRecordFormat, options);
     const gpsTimeRange = getGpsTimeRange(gpsTimeAttribute, vertexCount);
-    if (version === "1.5" && options.las?.timeOffset && !gpsTimeAttribute) {
+    if (version2 === "1.5" && options.las?.timeOffset && !gpsTimeAttribute) {
       throw new Error("LASWriter: LAS 1.5 timeOffset requires a GPS time attribute");
     }
     if (format === "laz") {
-      validateLAZOptions(version, pointDataRecordFormat, options.las?.chunkSize);
+      validateLAZOptions(version2, pointDataRecordFormat, options.las?.chunkSize);
     }
-    validatePointDataRecordVersion(version, pointDataRecordFormat);
+    validatePointDataRecordVersion(version2, pointDataRecordFormat);
     const rawPointData = new Uint8Array(vertexCount * pointDataRecordLength);
     const pointDataView = new DataView(rawPointData.buffer);
     for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
@@ -29072,7 +29838,7 @@ return true;`);
       boundingBox,
       scale,
       offset,
-      version,
+      version: version2,
       headerLength,
       pointDataRecordFormat,
       pointDataRecordLength,
@@ -29106,7 +29872,7 @@ return true;`);
     bytes.set(rawPointData, pointDataOffset);
     return arrayBuffer;
   }
-  function validatePointDataRecordVersion(version, pointDataRecordFormat) {
+  function validatePointDataRecordVersion(version2, pointDataRecordFormat) {
     const minimumVersionByPointFormat = {
       0: "1.0",
       1: "1.1",
@@ -29114,24 +29880,24 @@ return true;`);
       3: "1.2"
     };
     const minimumVersion = minimumVersionByPointFormat[pointDataRecordFormat];
-    if (minimumVersion && version < minimumVersion) {
+    if (minimumVersion && version2 < minimumVersion) {
       throw new Error(
-        `LASWriter: point data record format ${pointDataRecordFormat} requires LAS ${minimumVersion} or newer; received ${version}`
+        `LASWriter: point data record format ${pointDataRecordFormat} requires LAS ${minimumVersion} or newer; received ${version2}`
       );
     }
-    if (pointDataRecordFormat >= 4 && pointDataRecordFormat <= 5 && !["1.3", "1.4", "1.5"].includes(version)) {
+    if (pointDataRecordFormat >= 4 && pointDataRecordFormat <= 5 && !["1.3", "1.4", "1.5"].includes(version2)) {
       throw new Error(
-        `LASWriter: point data record format ${pointDataRecordFormat} requires LAS 1.3; received ${version}`
+        `LASWriter: point data record format ${pointDataRecordFormat} requires LAS 1.3; received ${version2}`
       );
     }
-    if (pointDataRecordFormat >= 6 && !["1.4", "1.5"].includes(version)) {
+    if (pointDataRecordFormat >= 6 && !["1.4", "1.5"].includes(version2)) {
       throw new Error(
-        `LASWriter: point data record format ${pointDataRecordFormat} requires LAS 1.4; received ${version}`
+        `LASWriter: point data record format ${pointDataRecordFormat} requires LAS 1.4; received ${version2}`
       );
     }
   }
-  function validateLASVersionOptions(version, pointDataRecordFormat, options) {
-    if (version === "1.5") {
+  function validateLASVersionOptions(version2, pointDataRecordFormat, options) {
+    if (version2 === "1.5") {
       if (pointDataRecordFormat < 6 || pointDataRecordFormat > 10) {
         throw new Error("LASWriter: LAS 1.5 output requires point data record format 6-10");
       }
@@ -29334,22 +30100,22 @@ return true;`);
       );
     }
   }
-  function validateLAZOptions(version, pointDataRecordFormat, chunkSize) {
-    if (pointDataRecordFormat === 1 && !["1.1", "1.2", "1.3", "1.4", "1.5"].includes(version)) {
-      throw new Error(`LASWriter: LAZ PDRF 1 output requires LAS 1.1 or newer; received ${version}`);
+  function validateLAZOptions(version2, pointDataRecordFormat, chunkSize) {
+    if (pointDataRecordFormat === 1 && !["1.1", "1.2", "1.3", "1.4", "1.5"].includes(version2)) {
+      throw new Error(`LASWriter: LAZ PDRF 1 output requires LAS 1.1 or newer; received ${version2}`);
     }
-    if (pointDataRecordFormat >= 2 && pointDataRecordFormat <= 3 && !["1.2", "1.3", "1.4", "1.5"].includes(version)) {
+    if (pointDataRecordFormat >= 2 && pointDataRecordFormat <= 3 && !["1.2", "1.3", "1.4", "1.5"].includes(version2)) {
       throw new Error(
-        `LASWriter: LAZ PDRF ${pointDataRecordFormat} output requires LAS 1.2 or newer; received ${version}`
+        `LASWriter: LAZ PDRF ${pointDataRecordFormat} output requires LAS 1.2 or newer; received ${version2}`
       );
     }
-    if (pointDataRecordFormat >= 4 && pointDataRecordFormat <= 5 && !["1.3", "1.4", "1.5"].includes(version)) {
+    if (pointDataRecordFormat >= 4 && pointDataRecordFormat <= 5 && !["1.3", "1.4", "1.5"].includes(version2)) {
       throw new Error(
-        `LASWriter: LAZ PDRF ${pointDataRecordFormat} requires LAS 1.3 or newer; received ${version}`
+        `LASWriter: LAZ PDRF ${pointDataRecordFormat} requires LAS 1.3 or newer; received ${version2}`
       );
     }
-    if (pointDataRecordFormat >= 6 && !["1.4", "1.5"].includes(version)) {
-      throw new Error(`LASWriter: LAZ output requires LAS 1.4; received ${version}`);
+    if (pointDataRecordFormat >= 6 && !["1.4", "1.5"].includes(version2)) {
+      throw new Error(`LASWriter: LAZ output requires LAS 1.4; received ${version2}`);
     }
     if (![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10].includes(pointDataRecordFormat)) {
       throw new Error(
@@ -29940,12 +30706,12 @@ return true;`);
   // src/pcd/pcd-writer.ts
   init_schema_utils();
   init_pcd_format();
-  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var PCDWriter = {
     ...PCDFormat,
     dataType: null,
     batchType: null,
-    version: VERSION4,
+    version: VERSION6,
     options: {
       pcd: {}
     },
@@ -30050,12 +30816,12 @@ return true;`);
   // src/ply/ply-writer.ts
   init_schema_utils();
   init_ply_format();
-  var VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var PLYWriter = {
     ...PLYFormat,
     dataType: null,
     batchType: null,
-    version: VERSION6,
+    version: VERSION8,
     options: {
       ply: {}
     },