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

package/dist/draco-worker-node.js

@@ -7617,7 +7617,7 @@ var init_initialize_wasm_module = __esm({
 
 // ../core/src/worker-utils/lib/env-utils/version.ts
 function getVersion() {
-  const version2 = false ? NPM_TAG : "5.0.0-beta.2";
+  const version2 = false ? NPM_TAG : "5.0.0-beta.4";
   globalThis._loadersgl_ = globalThis._loadersgl_ || {};
   globalThis._loadersgl_.version ||= version2;
   return version2;
@@ -7688,6 +7688,9 @@ function getTransferList(object2, recursive = true, transfers) {
     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);
@@ -7755,16 +7758,16 @@ var init_worker_body = __esm({
        */
       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;
           }
@@ -7782,9 +7785,9 @@ var init_worker_body = __esm({
           };
           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);
         }
@@ -7795,9 +7798,9 @@ var init_worker_body = __esm({
         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);
         }
@@ -7807,12 +7810,12 @@ var init_worker_body = __esm({
        * @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);
         }
@@ -7937,8 +7940,19 @@ var init_shared_state = __esm({
   }
 });
 
+// ../../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");
+  }
+}
+var init_validate_output_ownership = __esm({
+  "../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/validate-output-ownership.js"() {
+  }
+});
+
 // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/create-worker.js
-async function createWorker(process2, processInBatches) {
+async function createWorker(process2, processInBatches, preload2) {
   if (!await WorkerBody.inWorkerThread()) {
     return;
   }
@@ -7946,7 +7960,7 @@ async function createWorker(process2, processInBatches) {
     process: processOnMainThread
   };
   WorkerBody.onmessage = async (type, payload) => {
-    var _a5;
+    var _a5, _b2, _c2, _d2, _e2;
     if (type === "cancel") {
       activeController == null ? void 0 : activeController.abort();
       activeInputBatches == null ? void 0 : activeInputBatches.close();
@@ -7980,10 +7994,12 @@ async function createWorker(process2, processInBatches) {
       }
       switch (type) {
         case "preload":
+          await (preload2 == null ? void 0 : preload2());
           WorkerBody.postMessage("done", {});
           break;
         case "process":
           throwIfAborted();
+          validateOutputOwnership((_b2 = payload.options) == null ? void 0 : _b2["outputOwnership"]);
           if (!process2) {
             throw new Error("Worker does not support atomic processing");
           }
@@ -7993,10 +8009,11 @@ async function createWorker(process2, processInBatches) {
           await WorkerBody.postMessage("done", {
             result,
             executionMs: performance.now() - startedAt
-          });
+          }, ((_c2 = payload.options) == null ? void 0 : _c2["outputOwnership"]) === "copy");
           break;
         case "process-in-batches":
           throwIfAborted();
+          validateOutputOwnership((_d2 = payload.options) == null ? void 0 : _d2["outputOwnership"]);
           if (!processInBatches) {
             throw new Error("Worker does not support batched processing");
           }
@@ -8008,7 +8025,7 @@ async function createWorker(process2, processInBatches) {
             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 }, ((_e2 = payload.options) == null ? void 0 : _e2["outputOwnership"]) === "copy");
               await outputAcknowledgements.next();
             }
             throwIfAborted();
@@ -8106,14 +8123,14 @@ function processOnMainThread(arrayBuffer2, options = {}, jobContext = {}) {
   });
 }
 function createProgressReporter() {
-  let pending;
+  let pending2;
   let finished2 = 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 {
@@ -8121,9 +8138,9 @@ function createProgressReporter() {
     report(progress) {
       if (finished2)
         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);
@@ -8132,7 +8149,7 @@ function createProgressReporter() {
     /** Flushes final progress and suppresses reports from stale callbacks. */
     finish(discard = false) {
       if (discard)
-        pending = void 0;
+        pending2 = void 0;
       flush();
       finished2 = true;
     }
@@ -8144,6 +8161,7 @@ var init_create_worker = __esm({
     init_shared_state();
     init_async_queue();
     init_worker_body();
+    init_validate_output_ownership();
     requestId = 0;
     activeController = null;
     activeInputBatches = null;
@@ -8155,6 +8173,7 @@ var init_create_worker = __esm({
 var import_meta3, path3, moduleUrl;
 var init_worker_utils = __esm({
   "../../node_modules/@math.gl/core/dist/worker-utils/index.js"() {
+    init_worker_body();
     init_create_worker();
     import_meta3 = {};
     path3 = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
@@ -8162,18 +8181,360 @@ var init_worker_utils = __esm({
   }
 });
 
+// ../../node_modules/@math.gl/core/dist/tasks/task-preload.js
+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);
+    });
+  });
+}
+var pending, loaded;
+var init_task_preload = __esm({
+  "../../node_modules/@math.gl/core/dist/tasks/task-preload.js"() {
+    pending = /* @__PURE__ */ new WeakMap();
+    loaded = /* @__PURE__ */ new WeakSet();
+  }
+});
+
+// ../../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: () => {
+      var _a5;
+      signal.throwIfAborted();
+      (_a5 = context.throwIfAborted) == null ? void 0 : _a5.call(context);
+    },
+    reportProgress: (progress) => {
+      var _a5;
+      return (_a5 = context.reportProgress) == null ? void 0 : _a5.call(context, {
+        ...progress,
+        phase: progress.phase ?? "process",
+        unit: progress.unit ?? "items"
+      });
+    }
+  };
+}
+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 TaskRuntime, installed;
+var init_task_runtime = __esm({
+  "../../node_modules/@math.gl/core/dist/tasks/task-runtime.js"() {
+    init_worker_utils();
+    init_task_preload();
+    TaskRuntime = class {
+      constructor(task) {
+        this.task = task;
+        this.initialized = false;
+      }
+      async initialize(input, context = {}) {
+        var _a5, _b2, _c2;
+        if (this.initialized)
+          throw new Error("Task is already initialized");
+        assertPayload(input);
+        await preloadTaskCode(this.task, context.signal);
+        (_a5 = context.signal) == null ? void 0 : _a5.throwIfAborted();
+        this.state = await ((_c2 = (_b2 = this.task).initialize) == null ? void 0 : _c2.call(_b2, input, taskContext(void 0, context)));
+        this.initialized = true;
+        return {};
+      }
+      async destroy() {
+        var _a5, _b2;
+        if (this.initialized) {
+          this.initialized = false;
+          const state = this.state;
+          this.state = void 0;
+          if (this.task.initialize)
+            await ((_b2 = (_a5 = this.task).destroy) == null ? void 0 : _b2.call(_a5, 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;
+        }
+      }
+    };
+    installed = false;
+  }
+});
+
 // ../../node_modules/@math.gl/core/dist/tasks/index.js
 var init_tasks = __esm({
   "../../node_modules/@math.gl/core/dist/tasks/index.js"() {
-    init_worker_utils();
+    init_task_runtime();
+  }
+});
+
+// ../core/src/worker-utils/lib/node/worker_threads.ts
+var worker_threads_exports = {};
+__export(worker_threads_exports, {
+  BroadcastChannel: () => import_worker_threads3.BroadcastChannel,
+  MessageChannel: () => import_worker_threads3.MessageChannel,
+  MessagePort: () => import_worker_threads3.MessagePort,
+  NodeWorker: () => NodeWorker,
+  SHARE_ENV: () => import_worker_threads3.SHARE_ENV,
+  Worker: () => import_worker_threads3.Worker,
+  getEnvironmentData: () => import_worker_threads3.getEnvironmentData,
+  isInternalThread: () => isInternalThread2,
+  isMainThread: () => import_worker_threads3.isMainThread,
+  isMarkedAsUntransferable: () => import_worker_threads3.isMarkedAsUntransferable,
+  locks: () => locks2,
+  markAsUncloneable: () => import_worker_threads3.markAsUncloneable,
+  markAsUntransferable: () => import_worker_threads3.markAsUntransferable,
+  moveMessagePortToContext: () => import_worker_threads3.moveMessagePortToContext,
+  parentPort: () => parentPort2,
+  postMessageToThread: () => import_worker_threads3.postMessageToThread,
+  receiveMessageOnPort: () => import_worker_threads3.receiveMessageOnPort,
+  resourceLimits: () => import_worker_threads3.resourceLimits,
+  setEnvironmentData: () => import_worker_threads3.setEnvironmentData,
+  structuredClone: () => structuredClone3,
+  threadId: () => import_worker_threads3.threadId,
+  threadName: () => threadName2,
+  workerData: () => import_worker_threads3.workerData
+});
+var WorkerThreads, import_worker_threads3, parentPort2, NodeWorker, isInternalThread2, threadName2, locks2, structuredClone3;
+var init_worker_threads2 = __esm({
+  "../core/src/worker-utils/lib/node/worker_threads.ts"() {
+    "use strict";
+    WorkerThreads = __toESM(require("worker_threads"), 1);
+    import_worker_threads3 = require("worker_threads");
+    parentPort2 = WorkerThreads == null ? void 0 : WorkerThreads.parentPort;
+    NodeWorker = WorkerThreads.Worker;
+    isInternalThread2 = WorkerThreads.isInternalThread;
+    threadName2 = WorkerThreads.threadName;
+    locks2 = WorkerThreads.locks;
+    structuredClone3 = WorkerThreads.structuredClone;
+  }
+});
+
+// ../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() {
+  var _a5;
+  if (typeof self !== "undefined" && typeof document === "undefined" && typeof self.postMessage === "function")
+    return true;
+  if (typeof process !== "undefined" && ((_a5 = process.versions) == null ? void 0 : _a5.node)) {
+    const { isMainThread: isMainThread2 } = await Promise.resolve().then(() => (init_worker_threads2(), worker_threads_exports));
+    return !isMainThread2;
+  }
+  return false;
+}
+var initializeTaskWorker2;
+var init_task_runtime2 = __esm({
+  "../core/src/worker-utils/lib/worker-api/task-runtime.ts"() {
+    "use strict";
+    init_tasks();
+    initializeTaskWorker2 = initializeTaskWorker;
+  }
+});
+
+// ../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts
+function getTransferList2(object2, recursive = true, transfers) {
+  const transfersSet = transfers || /* @__PURE__ */ new Set();
+  if (!object2) {
+  } else if (isTransferable2(object2)) {
+    transfersSet.add(object2);
+  } else if (isTransferable2(object2.buffer)) {
+    transfersSet.add(object2.buffer);
+  } else if (ArrayBuffer.isView(object2)) {
+  } else if (recursive && typeof object2 === "object") {
+    for (const key in object2) {
+      getTransferList2(object2[key], recursive, transfersSet);
+    }
+  }
+  return transfers === void 0 ? Array.from(transfersSet) : [];
+}
+function isTransferable2(object2) {
+  if (!object2) {
+    return false;
+  }
+  if (object2 instanceof ArrayBuffer) {
+    return true;
+  }
+  if (typeof MessagePort !== "undefined" && object2 instanceof MessagePort) {
+    return true;
+  }
+  if (typeof ImageBitmap !== "undefined" && object2 instanceof ImageBitmap) {
+    return true;
+  }
+  if (typeof OffscreenCanvas !== "undefined" && object2 instanceof OffscreenCanvas) {
+    return true;
+  }
+  return false;
+}
+var init_get_transfer_list2 = __esm({
+  "../core/src/worker-utils/lib/worker-utils/get-transfer-list.ts"() {
+    "use strict";
   }
 });
 
 // ../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) => {
+      var _a5;
+      return (_a5 = state.port) == null ? void 0 : _a5.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
+  };
+}
 var init_create_worker2 = __esm({
   "../core/src/worker-utils/lib/worker-api/create-worker.ts"() {
     "use strict";
-    init_tasks();
+    init_task_runtime2();
+    init_get_transfer_list2();
   }
 });
 
@@ -8352,7 +8713,7 @@ var init_worker_utils2 = __esm({
 
 // ../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,
@@ -16394,11 +16755,11 @@ var init_builder = __esm({
         this._offsets = new OffsetsBufferBuilder(opts.type);
       }
       setValue(index2, value) {
-        const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
-        const current = pending.get(index2);
+        const pending2 = this._pending || (this._pending = /* @__PURE__ */ new Map());
+        const current = pending2.get(index2);
         current && (this._pendingLength -= current.length);
         this._pendingLength += value instanceof MapRow ? value[kKeys].length : value.length;
-        pending.set(index2, value);
+        pending2.set(index2, value);
       }
       setValid(index2, isValid) {
         if (!super.setValid(index2, isValid)) {
@@ -16421,12 +16782,12 @@ var init_builder = __esm({
         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;
       }
@@ -19012,11 +19373,11 @@ var init_binary2 = __esm({
       setValue(index2, value) {
         return super.setValue(index2, toUint8Array2(value));
       }
-      _flushPending(pending, pendingLength) {
+      _flushPending(pending2, pendingLength) {
         const offsets = this._offsets;
         const data = this._values.reserve(pendingLength).buffer;
         let offset = 0;
-        for (const [index2, value] of pending) {
+        for (const [index2, value] of pending2) {
           if (value === void 0) {
             offsets.set(index2, 0);
           } else {
@@ -19053,11 +19414,11 @@ var init_largebinary = __esm({
       setValue(index2, value) {
         return super.setValue(index2, toUint8Array2(value));
       }
-      _flushPending(pending, pendingLength) {
+      _flushPending(pending2, pendingLength) {
         const offsets = this._offsets;
         const data = this._values.reserve(pendingLength).buffer;
         let offset = 0;
-        for (const [index2, value] of pending) {
+        for (const [index2, value] of pending2) {
           if (value === void 0) {
             offsets.set(index2, BigInt(0));
           } else {
@@ -19368,10 +19729,10 @@ var init_list2 = __esm({
         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 [index2, value] of pending) {
+        for (const [index2, value] of pending2) {
           if (typeof value === "undefined") {
             offsets.set(index2, 0);
           } else {
@@ -19410,10 +19771,10 @@ var init_largelist = __esm({
         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 [index2, value] of pending) {
+        for (const [index2, value] of pending2) {
           if (typeof value === "undefined") {
             offsets.set(index2, BigInt(0));
           } else {
@@ -19443,11 +19804,11 @@ var init_map3 = __esm({
       }
       setValue(index2, 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(index2);
+        const pending2 = this._pending || (this._pending = /* @__PURE__ */ new Map());
+        const current = pending2.get(index2);
         current && (this._pendingLength -= current.size);
         this._pendingLength += row.size;
-        pending.set(index2, row);
+        pending2.set(index2, row);
       }
       addChild(child, name = `${this.numChildren}`) {
         if (this.numChildren > 0) {
@@ -19457,10 +19818,10 @@ var init_map3 = __esm({
         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 [index2, value] of pending) {
+        for (const [index2, value] of pending2) {
           if (value === void 0) {
             offsets.set(index2, 0);
           } else {
@@ -19669,7 +20030,7 @@ var init_utf83 = __esm({
         return super.setValue(index2, encodeUtf8(value));
       }
       // @ts-ignore
-      _flushPending(pending, pendingLength) {
+      _flushPending(pending2, pendingLength) {
       }
     };
     Utf8Builder.prototype._flushPending = BinaryBuilder.prototype._flushPending;
@@ -19700,7 +20061,7 @@ var init_largeutf8 = __esm({
         return super.setValue(index2, encodeUtf8(value));
       }
       // @ts-ignore
-      _flushPending(pending, pendingLength) {
+      _flushPending(pending2, pendingLength) {
       }
     };
     LargeUtf8Builder.prototype._flushPending = LargeBinaryBuilder.prototype._flushPending;
@@ -25851,7 +26212,7 @@ var VERSION2;
 var init_version2 = __esm({
   "src/draco/lib/utils/version.ts"() {
     "use strict";
-    VERSION2 = true ? "5.0.0-beta.2" : "latest";
+    VERSION2 = true ? "5.0.0-beta.4" : "latest";
   }
 });