@loaders.gl/pointclouds 5.0.0-beta.2 → 5.0.0-beta.4

package/dist/las-worker.js

@@ -1,13 +1,49 @@
 "use strict";
 (() => {
   var __defProp = Object.defineProperty;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __esm = (fn, res, err) => function __init() {
+    if (err) throw err[0];
+    try {
+      return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+    } catch (e) {
+      throw err = [e], e;
+    }
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
+  // ../core/src/worker-utils/lib/node/worker_threads-browser.ts
+  var worker_threads_browser_exports = {};
+  __export(worker_threads_browser_exports, {
+    NodeWorker: () => NodeWorker,
+    parentPort: () => parentPort2
+  });
+  var NodeWorker, parentPort2;
+  var init_worker_threads_browser = __esm({
+    "../core/src/worker-utils/lib/node/worker_threads-browser.ts"() {
+      "use strict";
+      NodeWorker = class {
+        /** Restores the native worker constructor when this browser shim is embedded in a Node bundle. */
+        constructor(...arguments_) {
+          const runtimeProcess = globalThis.process;
+          const WorkerConstructor = runtimeProcess?.getBuiltinModule?.("node:worker_threads").Worker;
+          if (WorkerConstructor) {
+            return new WorkerConstructor(...arguments_);
+          }
+        }
+        /** No-op browser fallback matching the native Worker API. */
+        terminate() {
+        }
+      };
+      parentPort2 = null;
+    }
+  });
+
   // ../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js
-  var parentPort = null;
+  var parentPort = globalThis.process?.getBuiltinModule?.("node:worker_threads")?.parentPort ?? null;
 
   // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js
   function getTransferList(object, recursive = true, transfers) {
@@ -22,6 +58,9 @@
       else if (ArrayBuffer.isView(value)) {
         if (isTransferable(value.buffer))
           transfersSet.add(value.buffer);
+      } else if (recursive && typeof MessageChannel !== "undefined" && value instanceof MessageChannel) {
+        visit(value.port1);
+        visit(value.port2);
       } else if (recursive && value instanceof Map) {
         for (const [key, item] of value) {
           visit(key);
@@ -73,16 +112,16 @@
      */
     static set onmessage(onMessage) {
       async function handleMessage(message) {
-        const parentPort2 = await getParentPort();
-        const { type, payload } = parentPort2 ? message : message.data;
+        const parentPort3 = await getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
         onMessage(type, payload);
       }
-      getParentPort().then((parentPort2) => {
-        if (parentPort2) {
-          parentPort2.on("message", (message) => {
+      getParentPort().then((parentPort3) => {
+        if (parentPort3) {
+          parentPort3.on("message", (message) => {
             handleMessage(message);
           });
-          parentPort2.on("exit", () => console.debug("Node worker closing"));
+          parentPort3.on("exit", () => console.debug("Node worker closing"));
         } else {
           globalThis.onmessage = handleMessage;
         }
@@ -100,9 +139,9 @@
         };
         onMessageWrapperMap.set(onMessage, onMessageWrapper);
       }
-      const parentPort2 = await getParentPort();
-      if (parentPort2) {
-        parentPort2.on("message", onMessageWrapper);
+      const parentPort3 = await getParentPort();
+      if (parentPort3) {
+        parentPort3.on("message", onMessageWrapper);
       } else {
         globalThis.addEventListener("message", onMessageWrapper);
       }
@@ -113,9 +152,9 @@
       if (!onMessageWrapper) {
         return;
       }
-      const parentPort2 = await getParentPort();
-      if (parentPort2) {
-        parentPort2.off("message", onMessageWrapper);
+      const parentPort3 = await getParentPort();
+      if (parentPort3) {
+        parentPort3.off("message", onMessageWrapper);
       } else {
         globalThis.removeEventListener("message", onMessageWrapper);
       }
@@ -125,12 +164,12 @@
      * @param type
      * @param payload
      */
-    static async postMessage(type, payload) {
+    static async postMessage(type, payload, copy = false) {
       const data = { source: "loaders.gl", type, payload };
-      const transferList = getTransferList(payload);
-      const parentPort2 = await getParentPort();
-      if (parentPort2) {
-        parentPort2.postMessage(data, transferList);
+      const transferList = copy ? [] : getTransferList(payload);
+      const parentPort3 = await getParentPort();
+      if (parentPort3) {
+        parentPort3.postMessage(data, transferList);
       } else {
         globalThis.postMessage(data, transferList);
       }
@@ -250,12 +289,19 @@
     }
   };
 
+  // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/validate-output-ownership.js
+  function validateOutputOwnership(ownership) {
+    if (ownership !== void 0 && ownership !== "copy" && ownership !== "transfer") {
+      throw new Error("Invalid worker output ownership");
+    }
+  }
+
   // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/create-worker.js
   var requestId = 0;
   var activeController = null;
   var activeInputBatches = null;
   var activeOutputAcknowledgements = null;
-  async function createWorker(process, processInBatches) {
+  async function createWorker(process2, processInBatches, preload) {
     if (!await WorkerBody.inWorkerThread()) {
       return;
     }
@@ -296,23 +342,26 @@
         }
         switch (type) {
           case "preload":
+            await preload?.();
             WorkerBody.postMessage("done", {});
             break;
           case "process":
             throwIfAborted();
-            if (!process) {
+            validateOutputOwnership(payload.options?.["outputOwnership"]);
+            if (!process2) {
               throw new Error("Worker does not support atomic processing");
             }
-            const result = await process(payload.input, payload.options || {}, jobContext, payload.context || {});
+            const result = await process2(payload.input, payload.options || {}, jobContext, payload.context || {});
             throwIfAborted();
             reporter?.finish();
             await WorkerBody.postMessage("done", {
               result,
               executionMs: performance.now() - startedAt
-            });
+            }, payload.options?.["outputOwnership"] === "copy");
             break;
           case "process-in-batches":
             throwIfAborted();
+            validateOutputOwnership(payload.options?.["outputOwnership"]);
             if (!processInBatches) {
               throw new Error("Worker does not support batched processing");
             }
@@ -324,7 +373,7 @@
               const resultIterator = processInBatches(createDemandDrivenIterator(inputBatches), payload.options || {}, jobContext, payload.context || {});
               for await (const batch of resultIterator) {
                 throwIfAborted();
-                await WorkerBody.postMessage("output-batch", { result: batch });
+                await WorkerBody.postMessage("output-batch", { result: batch }, payload.options?.["outputOwnership"] === "copy");
                 await outputAcknowledgements.next();
               }
               throwIfAborted();
@@ -422,14 +471,14 @@
     });
   }
   function createProgressReporter() {
-    let pending;
+    let pending2;
     let finished = false;
     let scheduled = false;
     const flush = () => {
       scheduled = false;
-      if (pending) {
-        WorkerBody.postMessage("progress", { progress: pending });
-        pending = void 0;
+      if (pending2) {
+        WorkerBody.postMessage("progress", { progress: pending2 });
+        pending2 = void 0;
       }
     };
     return {
@@ -437,9 +486,9 @@
       report(progress) {
         if (finished)
           return;
-        if (pending && pending.phase !== progress.phase)
+        if (pending2 && pending2.phase !== progress.phase)
           flush();
-        pending = { ...progress };
+        pending2 = { ...progress };
         if (!scheduled) {
           scheduled = true;
           setTimeout(flush, 0);
@@ -448,7 +497,7 @@
       /** Flushes final progress and suppresses reports from stale callbacks. */
       finish(discard = false) {
         if (discard)
-          pending = void 0;
+          pending2 = void 0;
         flush();
         finished = true;
       }
@@ -460,9 +509,276 @@
   var path = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
   var moduleUrl = path ? `file://${path.startsWith("/") ? "" : "/"}${encodeURI(path).replace(/#/g, "%23").replace(/\?/g, "%3F")}` : import_meta.url;
 
+  // ../../node_modules/@math.gl/core/dist/tasks/task-preload.js
+  var pending = /* @__PURE__ */ new WeakMap();
+  var loaded = /* @__PURE__ */ new WeakSet();
+  function preloadTaskCode(task, signal) {
+    if (!task.preload)
+      return Promise.resolve();
+    let promise = pending.get(task);
+    if (!promise) {
+      promise = Promise.resolve().then(() => task.preload()).then(() => {
+        loaded.add(task);
+      });
+      pending.set(task, promise);
+      void promise.catch(() => pending.delete(task));
+    }
+    return withSignal(promise, signal);
+  }
+  function withSignal(operation, signal) {
+    if (!signal)
+      return operation;
+    return new Promise((resolve, reject) => {
+      const abort = () => {
+        signal.removeEventListener("abort", abort);
+        reject(signal.reason);
+      };
+      signal.addEventListener("abort", abort, { once: true });
+      if (signal.aborted)
+        abort();
+      operation.then((value) => {
+        signal.removeEventListener("abort", abort);
+        resolve(value);
+      }, (error) => {
+        signal.removeEventListener("abort", abort);
+        reject(error);
+      });
+    });
+  }
+
+  // ../../node_modules/@math.gl/core/dist/tasks/task-runtime.js
+  function assertPayload(value) {
+    if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype) {
+      throw new TypeError("Task payloads must be plain objects with named fields");
+    }
+  }
+  function taskContext(state, context = {}) {
+    const signal = context.signal ?? new AbortController().signal;
+    return {
+      state,
+      signal,
+      throwIfAborted: () => {
+        signal.throwIfAborted();
+        context.throwIfAborted?.();
+      },
+      reportProgress: (progress) => context.reportProgress?.({
+        ...progress,
+        phase: progress.phase ?? "process",
+        unit: progress.unit ?? "items"
+      })
+    };
+  }
+  var TaskRuntime = class {
+    constructor(task) {
+      this.task = task;
+      this.initialized = false;
+    }
+    async initialize(input, context = {}) {
+      if (this.initialized)
+        throw new Error("Task is already initialized");
+      assertPayload(input);
+      await preloadTaskCode(this.task, context.signal);
+      context.signal?.throwIfAborted();
+      this.state = await this.task.initialize?.(input, taskContext(void 0, context));
+      this.initialized = true;
+      return {};
+    }
+    async destroy() {
+      if (this.initialized) {
+        this.initialized = false;
+        const state = this.state;
+        this.state = void 0;
+        if (this.task.initialize)
+          await this.task.destroy?.(state);
+      }
+      return {};
+    }
+    async process(input, options, context = {}) {
+      if (!this.initialized)
+        throw new Error("Task is not initialized");
+      if (!this.task.process)
+        throw new Error("Task has no atomic processor");
+      assertPayload(input);
+      const result = await this.task.process(input, options, taskContext(this.state, context));
+      assertPayload(result);
+      return result;
+    }
+    async *stream(inputs, options, context = {}) {
+      if (!this.initialized)
+        throw new Error("Task is not initialized");
+      if (!this.task.processInBatches)
+        throw new Error("Task has no streaming processor");
+      for await (const output of this.task.processInBatches(inputs, options, taskContext(this.state, context))) {
+        assertPayload(output);
+        yield output;
+      }
+    }
+  };
+  async function initializeTaskWorker(task) {
+    if (!await WorkerBody.inWorkerThread())
+      throw new Error("initializeTaskWorker must run inside a worker");
+    if (installed)
+      throw new Error("A task is already installed in this worker");
+    installed = true;
+    const runtime = new TaskRuntime(task);
+    let streamOptions = {};
+    return createWorker(async (request, _options, context) => {
+      switch (request.operation) {
+        case "initialize":
+          return runtime.initialize(request.input, context);
+        case "destroy":
+          return runtime.destroy();
+        case "stream-options":
+          streamOptions = request.options;
+          return {};
+        case "process":
+          return runtime.process(request.input, request.options, context);
+        default:
+          throw new Error("Unknown task operation");
+      }
+    }, async function* (inputs, _options, context) {
+      async function* batches() {
+        for await (const input of inputs) {
+          assertPayload(input);
+          yield input;
+        }
+      }
+      try {
+        yield* runtime.stream(batches(), streamOptions, context);
+      } finally {
+        streamOptions = {};
+      }
+    }, () => preloadTaskCode(task));
+  }
+  var installed = false;
+
+  // ../core/src/worker-utils/lib/worker-api/task-runtime.ts
+  function normalizeTaskProgress(progress) {
+    return { ...progress, phase: progress.phase ?? "process", unit: progress.unit ?? "items" };
+  }
+  async function isWorkerThread() {
+    if (typeof self !== "undefined" && typeof document === "undefined" && typeof self.postMessage === "function")
+      return true;
+    if (typeof process !== "undefined" && process.versions?.node) {
+      const { isMainThread } = await Promise.resolve().then(() => (init_worker_threads_browser(), worker_threads_browser_exports));
+      return !isMainThread;
+    }
+    return false;
+  }
+  var initializeTaskWorker2 = initializeTaskWorker;
+
+  // ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
+  function getTransferList2(object, recursive = true, transfers) {
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
+    if (!object) {
+    } else if (isTransferable2(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable2(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList2(object[key], recursive, transfersSet);
+      }
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
+  }
+  function isTransferable2(object) {
+    if (!object) {
+      return false;
+    }
+    if (object instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
+    }
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
+    }
+    return false;
+  }
+
+  // ../core/src/worker-utils/lib/worker-api/create-worker.ts
+  async function createWorker2(process2, processInBatches) {
+    if (!await isWorkerThread()) return;
+    await initializeTaskWorker2(createWorkerTask(process2, processInBatches));
+  }
+  function createWorkerTask(process2, processInBatches) {
+    return {
+      id: "loaders.gl",
+      initialize: (state) => state,
+      destroy: (state) => state.port?.close(),
+      process: async ({ value }, options, context) => {
+        if (!process2) throw new Error("Worker does not support atomic processing");
+        return { value: await process2(value, options, createContext(context), context.state.context) };
+      },
+      ...processInBatches ? {
+        processInBatches: async function* (inputs, options, context) {
+          async function* values() {
+            for await (const input of inputs) yield input.value;
+          }
+          for await (const value of processInBatches(
+            values(),
+            options,
+            createContext(context),
+            context.state.context
+          )) {
+            yield { value };
+          }
+        }
+      } : {}
+    };
+  }
+  function createContext(context) {
+    let requestIdentifier = 0;
+    const port = context.state.port;
+    return {
+      signal: context.signal,
+      throwIfAborted: () => context.throwIfAborted(),
+      reportProgress: (progress) => context.reportProgress(normalizeTaskProgress(progress)),
+      process: port ? (input, options = {}, jobContext = {}) => {
+        context.throwIfAborted();
+        const identifier = ++requestIdentifier;
+        return new Promise((resolve, reject) => {
+          const onMessage = (event) => {
+            if (event.data.identifier !== identifier) return;
+            cleanup();
+            if (event.data.error) {
+              const error = new Error(event.data.error.message);
+              error.name = event.data.error.name;
+              reject(error);
+            } else resolve(event.data.value);
+          };
+          const onAbort = () => {
+            cleanup();
+            reject(context.signal.reason);
+          };
+          const cleanup = () => {
+            port.removeEventListener("message", onMessage);
+            context.signal.removeEventListener("abort", onAbort);
+          };
+          port.addEventListener("message", onMessage);
+          context.signal.addEventListener("abort", onAbort, { once: true });
+          port.start();
+          try {
+            const request = { identifier, input, options, context: jobContext };
+            port.postMessage(request, getTransferList2(request));
+          } catch (error) {
+            cleanup();
+            reject(error);
+          }
+        });
+      } : void 0
+    };
+  }
+
   // ../core/src/loader-utils/lib/worker-loader-utils/create-loader-worker.ts
   async function createLoaderWorker(loader, selectLoader = () => loader) {
-    await createWorker(
+    await createWorker2(
       (input, options, workerContext, loaderContext) => processLoaderWorkerData(
         selectLoader(options || {}),
         input,
@@ -12567,11 +12883,11 @@ return true;`);
       this._offsets = new OffsetsBufferBuilder(opts.type);
     }
     setValue(index, value) {
-      const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
-      const current = pending.get(index);
+      const pending2 = this._pending || (this._pending = /* @__PURE__ */ new Map());
+      const current = pending2.get(index);
       current && (this._pendingLength -= current.length);
       this._pendingLength += value instanceof MapRow ? value[kKeys].length : value.length;
-      pending.set(index, value);
+      pending2.set(index, value);
     }
     setValid(index, isValid) {
       if (!super.setValid(index, isValid)) {
@@ -12594,12 +12910,12 @@ return true;`);
       return super.finish();
     }
     _flush() {
-      const pending = this._pending;
+      const pending2 = this._pending;
       const pendingLength = this._pendingLength;
       this._pendingLength = 0;
       this._pending = void 0;
-      if (pending && pending.size > 0) {
-        this._flushPending(pending, pendingLength);
+      if (pending2 && pending2.size > 0) {
+        this._flushPending(pending2, pendingLength);
       }
       return this;
     }
@@ -15009,11 +15325,11 @@ return true;`);
     setValue(index, value) {
       return super.setValue(index, toUint8Array2(value));
     }
-    _flushPending(pending, pendingLength) {
+    _flushPending(pending2, pendingLength) {
       const offsets = this._offsets;
       const data = this._values.reserve(pendingLength).buffer;
       let offset = 0;
-      for (const [index, value] of pending) {
+      for (const [index, value] of pending2) {
         if (value === void 0) {
           offsets.set(index, 0);
         } else {
@@ -15042,11 +15358,11 @@ return true;`);
     setValue(index, value) {
       return super.setValue(index, toUint8Array2(value));
     }
-    _flushPending(pending, pendingLength) {
+    _flushPending(pending2, pendingLength) {
       const offsets = this._offsets;
       const data = this._values.reserve(pendingLength).buffer;
       let offset = 0;
-      for (const [index, value] of pending) {
+      for (const [index, value] of pending2) {
         if (value === void 0) {
           offsets.set(index, BigInt(0));
         } else {
@@ -15277,10 +15593,10 @@ return true;`);
       this.type = new List2(new Field2(name, child.type, true));
       return this.numChildren - 1;
     }
-    _flushPending(pending) {
+    _flushPending(pending2) {
       const offsets = this._offsets;
       const [child] = this.children;
-      for (const [index, value] of pending) {
+      for (const [index, value] of pending2) {
         if (typeof value === "undefined") {
           offsets.set(index, 0);
         } else {
@@ -15309,10 +15625,10 @@ return true;`);
       this.type = new LargeList2(new Field2(name, child.type, true));
       return this.numChildren - 1;
     }
-    _flushPending(pending) {
+    _flushPending(pending2) {
       const offsets = this._offsets;
       const [child] = this.children;
-      for (const [index, value] of pending) {
+      for (const [index, value] of pending2) {
         if (typeof value === "undefined") {
           offsets.set(index, BigInt(0));
         } else {
@@ -15334,11 +15650,11 @@ return true;`);
     }
     setValue(index, value) {
       const row = value instanceof Map ? value : new Map(Object.entries(value));
-      const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
-      const current = pending.get(index);
+      const pending2 = this._pending || (this._pending = /* @__PURE__ */ new Map());
+      const current = pending2.get(index);
       current && (this._pendingLength -= current.size);
       this._pendingLength += row.size;
-      pending.set(index, row);
+      pending2.set(index, row);
     }
     addChild(child, name = `${this.numChildren}`) {
       if (this.numChildren > 0) {
@@ -15348,10 +15664,10 @@ return true;`);
       this.type = new Map_(new Field2(name, child.type, true), this.type.keysSorted);
       return this.numChildren - 1;
     }
-    _flushPending(pending) {
+    _flushPending(pending2) {
       const offsets = this._offsets;
       const [child] = this.children;
-      for (const [index, value] of pending) {
+      for (const [index, value] of pending2) {
         if (value === void 0) {
           offsets.set(index, 0);
         } else {
@@ -15514,7 +15830,7 @@ return true;`);
       return super.setValue(index, encodeUtf8(value));
     }
     // @ts-ignore
-    _flushPending(pending, pendingLength) {
+    _flushPending(pending2, pendingLength) {
     }
   };
   Utf8Builder.prototype._flushPending = BinaryBuilder.prototype._flushPending;
@@ -15536,7 +15852,7 @@ return true;`);
       return super.setValue(index, encodeUtf8(value));
     }
     // @ts-ignore
-    _flushPending(pending, pendingLength) {
+    _flushPending(pending2, pendingLength) {
     }
   };
   LargeUtf8Builder.prototype._flushPending = LargeBinaryBuilder.prototype._flushPending;
@@ -17734,8 +18050,8 @@ return true;`);
       return new JSONVectorLoader(body, header.nodes, header.buffers, this.dictionaries, this.schema.metadataVersion, header.variadicBufferCounts).visitMany(types);
     }
   };
-  function shouldAutoDestroy(self, options) {
-    return options && typeof options["autoDestroy"] === "boolean" ? options["autoDestroy"] : self["autoDestroy"];
+  function shouldAutoDestroy(self2, options) {
+    return options && typeof options["autoDestroy"] === "boolean" ? options["autoDestroy"] : self2["autoDestroy"];
   }
   function* readAllSync(source) {
     const reader = RecordBatchReader.from(source);
@@ -19949,7 +20265,7 @@ return true;`);
   };
 
   // src/las/las-loader-shared.ts
-  var VERSION = true ? "5.0.0-beta.2" : "latest";
+  var VERSION = true ? "5.0.0-beta.4" : "latest";
   var DEFAULT_LAS_SHAPE = "arrow-table";
   function getLASShape(options) {
     return options?.las?.shape || DEFAULT_LAS_SHAPE;
@@ -20349,7 +20665,12 @@ return true;`);
     return attributes;
   }
   function readLASString(bytes, offset, length) {
-    return new TextDecoder().decode(bytes.subarray(offset, offset + length)).replace(/\0+$/, "").trim();
+    const decoded = new TextDecoder().decode(bytes.subarray(offset, offset + length));
+    let end = decoded.length;
+    while (end > 0 && decoded[end - 1] === "\0") {
+      end--;
+    }
+    return decoded.slice(0, end).trim();
   }
   function sanitizeExtraBytesName(name) {
     return name.trim().replace(/[^A-Za-z0-9_]+/g, "_");
@@ -20595,7 +20916,7 @@ return true;`);
   async function* parseLASInBatches(arrayBufferIterator, options = {}) {
     const batchSize = getBatchSize(options);
     const inputIterator = toAsyncIterator(arrayBufferIterator);
-    let pending = new Uint8Array(0);
+    let pending2 = new Uint8Array(0);
     let absoluteOffset = 0;
     let header = null;
     let sourcePointIndex = 0;
@@ -20606,9 +20927,9 @@ return true;`);
         break;
       }
       const chunk = next.value;
-      pending = concatenateUint8Arrays2(pending, toUint8Array3(chunk));
+      pending2 = concatenateUint8Arrays2(pending2, toUint8Array3(chunk));
       if (!header) {
-        header = tryParseHeader(pending, absoluteOffset);
+        header = tryParseHeader(pending2, absoluteOffset);
         if (header) {
           header.totalToRead = header.pointsCount;
         }
@@ -20617,11 +20938,11 @@ return true;`);
         continue;
       }
       if (header.isCompressed) {
-        yield* parseLAZInBatches(pending, inputIterator, header, options);
+        yield* parseLAZInBatches(pending2, inputIterator, header, options);
         return;
       }
       for (const batch of readAvailablePointBatches(
-        pending,
+        pending2,
         absoluteOffset,
         header,
         sourcePointIndex,
@@ -20630,7 +20951,7 @@ return true;`);
       )) {
         sourcePointIndex = batch.sourcePointIndex;
         totalRead = batch.totalRead;
-        pending = batch.pending;
+        pending2 = batch.pending;
         absoluteOffset = batch.absoluteOffset;
         yield parseLASArrowTableBatch(batch.arrayBuffer, batch.header, options);
       }
@@ -20814,11 +21135,11 @@ return true;`);
     );
   }
   async function* parseLAZInBatches(initialPending, inputIterator, header, options) {
-    const { pending, laszip } = await readLASZipVLRFromInput(initialPending, inputIterator, header);
+    const { pending: pending2, laszip } = await readLASZipVLRFromInput(initialPending, inputIterator, header);
     validateTypeScriptLAZSupport(header, laszip);
     if (!laszip.variableChunks && header.pointsFormatId <= 5) {
       yield* parsePendingFixedLegacyLAZFileInArrowBatches(
-        pending,
+        pending2,
         inputIterator,
         header,
         laszip,
@@ -20827,11 +21148,11 @@ return true;`);
       return;
     }
     if (!laszip.variableChunks && header.pointsFormatId >= 6 && header.pointsFormatId <= 10) {
-      yield* parsePendingLAZFileInArrowBatches(pending, inputIterator, header, laszip, options);
+      yield* parsePendingLAZFileInArrowBatches(pending2, inputIterator, header, laszip, options);
       return;
     }
     for await (const batch of decodeLAZFileWithParsedVLRInBatches(
-      pending,
+      pending2,
       inputIterator,
       header,
       laszip,
@@ -22032,10 +22353,10 @@ return true;`);
     }
   }
   async function readLASZipVLRFromInput(initialPending, inputIterator, header) {
-    let pending = initialPending;
+    let pending2 = initialPending;
     while (true) {
       try {
-        return { pending, laszip: parseLASZipVLR(pending, header) };
+        return { pending: pending2, laszip: parseLASZipVLR(pending2, header) };
       } catch (error) {
         if (!(error instanceof NeedsMoreData)) {
           throw error;
@@ -22045,7 +22366,7 @@ return true;`);
       if (next.done) {
         throw new NeedsMoreData("LASLoader: incomplete LASzip VLR");
       }
-      pending = concatenateUint8Arrays2(pending, toUint8Array3(next.value));
+      pending2 = concatenateUint8Arrays2(pending2, toUint8Array3(next.value));
     }
   }
   async function collectRemainingInputBytes(initialPending, inputIterator) {
@@ -22969,10 +23290,10 @@ return true;`);
       [maximum[0], maximum[1], maximum[2]]
     ];
   }
-  function* readAvailablePointBatches(pending, absoluteOffset, header, sourcePointIndex, totalRead, batchSize) {
+  function* readAvailablePointBatches(pending2, absoluteOffset, header, sourcePointIndex, totalRead, batchSize) {
     while (sourcePointIndex < header.pointsCount && totalRead < header.totalToRead) {
       const batch = readAvailableContiguousPointBatch(
-        pending,
+        pending2,
         absoluteOffset,
         header,
         sourcePointIndex,
@@ -22982,25 +23303,25 @@ return true;`);
       if (!batch) {
         return;
       }
-      pending = batch.pending;
+      pending2 = batch.pending;
       absoluteOffset = batch.absoluteOffset;
       sourcePointIndex = batch.sourcePointIndex;
       totalRead = batch.totalRead;
       yield batch;
     }
   }
-  function readAvailableContiguousPointBatch(pending, absoluteOffset, header, sourcePointIndex, totalRead, batchSize) {
+  function readAvailableContiguousPointBatch(pending2, absoluteOffset, header, sourcePointIndex, totalRead, batchSize) {
     const pointRecordLength = header.pointsStructSize;
     const pointAbsoluteOffset = header.pointsOffset + sourcePointIndex * pointRecordLength;
     const pointPendingOffset = pointAbsoluteOffset - absoluteOffset;
     if (pointPendingOffset < 0) {
       throw new Error("LASLoader: invalid streaming point offset");
     }
-    if (pointPendingOffset + pointRecordLength > pending.byteLength) {
+    if (pointPendingOffset + pointRecordLength > pending2.byteLength) {
       return null;
     }
     const availablePointCount = Math.floor(
-      (pending.byteLength - pointPendingOffset) / pointRecordLength
+      (pending2.byteLength - pointPendingOffset) / pointRecordLength
     );
     const batchPointCount = Math.min(
       batchSize,
@@ -23015,38 +23336,38 @@ return true;`);
     totalRead += batchPointCount;
     const batchHeader = {
       ...header,
-      pointsOffset: pending.byteOffset + pointPendingOffset,
+      pointsOffset: pending2.byteOffset + pointPendingOffset,
       pointsCount: batchPointCount,
       totalRead
     };
     const nextPointOffset = header.pointsOffset + sourcePointIndex * pointRecordLength;
     const discardByteCount = Math.max(
       0,
-      Math.min(pending.byteLength, nextPointOffset - absoluteOffset)
+      Math.min(pending2.byteLength, nextPointOffset - absoluteOffset)
     );
     return {
-      arrayBuffer: pending.buffer,
+      arrayBuffer: pending2.buffer,
       header: batchHeader,
-      pending: pending.subarray(discardByteCount),
+      pending: pending2.subarray(discardByteCount),
       absoluteOffset: absoluteOffset + discardByteCount,
       sourcePointIndex,
       totalRead
     };
   }
-  function tryParseHeader(pending, absoluteOffset) {
-    if (absoluteOffset !== 0 || pending.byteLength < 227) {
+  function tryParseHeader(pending2, absoluteOffset) {
+    if (absoluteOffset !== 0 || pending2.byteLength < 227) {
       return null;
     }
-    const dataView = new DataView(pending.buffer, pending.byteOffset, pending.byteLength);
+    const dataView = new DataView(pending2.buffer, pending2.byteOffset, pending2.byteLength);
     if (dataView.getUint32(0, true) !== LASF_SIGNATURE) {
       throw new Error("LASLoader: invalid LAS header");
     }
     const headerLength = dataView.getUint32(96, true);
-    if (pending.byteLength < Math.max(headerLength, 255)) {
+    if (pending2.byteLength < Math.max(headerLength, 255)) {
       return null;
     }
     const header = parseLASHeader(
-      pending.buffer.slice(pending.byteOffset, pending.byteOffset + pending.byteLength)
+      pending2.buffer.slice(pending2.byteOffset, pending2.byteOffset + pending2.byteLength)
     );
     return header;
   }