@loaders.gl/parquet 5.0.0-alpha.2 → 5.0.0-alpha.4

package/dist/parquet-worker.js

@@ -114,9 +114,12 @@ var global=globalThis;
   async function getParentPort() {
     return parentPort;
   }
-  function isKnownMessage(message) {
-    const { type, data } = message;
-    return type === "message" && data && typeof data.source === "string" && data.source.startsWith("loaders.gl");
+  function getWorkerMessageData(message) {
+    if (!message || typeof message !== "object") {
+      return null;
+    }
+    const messageData = "data" in message && message.type === "message" ? message.data : message;
+    return messageData && typeof messageData.source === "string" && messageData.source.startsWith("loaders.gl") ? messageData : null;
   }
   var onMessageWrapperMap, WorkerBody;
   var init_worker_body = __esm({
@@ -154,18 +157,18 @@ var global=globalThis;
         static async addEventListener(onMessage) {
           let onMessageWrapper = onMessageWrapperMap.get(onMessage);
           if (!onMessageWrapper) {
-            onMessageWrapper = async (message) => {
-              if (!isKnownMessage(message)) {
+            onMessageWrapper = (message) => {
+              const messageData = getWorkerMessageData(message);
+              if (!messageData) {
                 return;
               }
-              const parentPort3 = await getParentPort();
-              const { type, payload } = parentPort3 ? message : message.data;
-              onMessage(type, payload);
+              onMessage(messageData.type, messageData.payload);
             };
+            onMessageWrapperMap.set(onMessage, onMessageWrapper);
           }
           const parentPort2 = await getParentPort();
           if (parentPort2) {
-            console.error("not implemented");
+            parentPort2.on("message", onMessageWrapper);
           } else {
             globalThis.addEventListener("message", onMessageWrapper);
           }
@@ -173,9 +176,12 @@ var global=globalThis;
         static async removeEventListener(onMessage) {
           const onMessageWrapper = onMessageWrapperMap.get(onMessage);
           onMessageWrapperMap.delete(onMessage);
+          if (!onMessageWrapper) {
+            return;
+          }
           const parentPort2 = await getParentPort();
           if (parentPort2) {
-            console.error("not implemented");
+            parentPort2.off("message", onMessageWrapper);
           } else {
             globalThis.removeEventListener("message", onMessageWrapper);
           }
@@ -306,24 +312,44 @@ var global=globalThis;
             if (!processInBatches) {
               throw new Error("Worker does not support batched processing");
             }
-            inputBatches = new AsyncQueue();
-            options = payload.options || {};
-            const resultIterator = processInBatches(
-              inputBatches,
-              options,
-              context,
-              payload.context || {}
-            );
-            for await (const batch of resultIterator) {
-              WorkerBody.postMessage("output-batch", { result: batch });
+            const inputBatches = new AsyncQueue();
+            const outputAcknowledgements = new AsyncQueue();
+            activeInputBatches = inputBatches;
+            activeOutputAcknowledgements = outputAcknowledgements;
+            try {
+              const resultIterator = processInBatches(
+                createDemandDrivenIterator(inputBatches),
+                payload.options || {},
+                context,
+                payload.context || {}
+              );
+              for await (const batch of resultIterator) {
+                await WorkerBody.postMessage("output-batch", { result: batch });
+                await outputAcknowledgements.next();
+              }
+              await WorkerBody.postMessage("done", {});
+            } finally {
+              activeInputBatches = null;
+              activeOutputAcknowledgements = null;
             }
-            WorkerBody.postMessage("done", {});
             break;
           case "input-batch":
-            inputBatches.push(payload.input);
+            if (!activeInputBatches) {
+              throw new Error("Worker has no active batched processing session");
+            }
+            activeInputBatches.push(payload.input);
             break;
           case "input-done":
-            inputBatches.close();
+            if (!activeInputBatches) {
+              throw new Error("Worker has no active batched processing session");
+            }
+            activeInputBatches.close();
+            break;
+          case "output-ack":
+            if (!activeOutputAcknowledgements) {
+              throw new Error("Worker has no active batched processing session");
+            }
+            activeOutputAcknowledgements.push(void 0);
             break;
           default:
         }
@@ -333,7 +359,17 @@ var global=globalThis;
       }
     };
   }
-  function processOnMainThread(arrayBuffer, options2 = {}, jobContext = {}) {
+  async function* createDemandDrivenIterator(inputBatches) {
+    while (true) {
+      await WorkerBody.postMessage("input-request", {});
+      const nextBatch = await inputBatches.next();
+      if (nextBatch.done) {
+        return;
+      }
+      yield nextBatch.value;
+    }
+  }
+  function processOnMainThread(arrayBuffer, options = {}, jobContext = {}) {
     return new Promise((resolve, reject) => {
       const id = requestId++;
       const onMessage = (type, payload2) => {
@@ -353,11 +389,11 @@ var global=globalThis;
         }
       };
       WorkerBody.addEventListener(onMessage);
-      const payload = { id, input: arrayBuffer, options: options2, context: jobContext };
+      const payload = { id, input: arrayBuffer, options, context: jobContext };
       WorkerBody.postMessage("process", payload);
     });
   }
-  var requestId, inputBatches, options;
+  var requestId, activeInputBatches, activeOutputAcknowledgements;
   var init_create_worker = __esm({
     "../worker-utils/src/lib/worker-api/create-worker.ts"() {
       "use strict";
@@ -365,6 +401,8 @@ var global=globalThis;
       init_async_queue();
       init_worker_body();
       requestId = 0;
+      activeInputBatches = null;
+      activeOutputAcknowledgements = null;
     }
   });
 
@@ -380,21 +418,22 @@ var global=globalThis;
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
   async function createLoaderWorker(loader) {
     await createWorker(
-      async (input, options2 = {}, workerContext, loaderContext = {}) => {
-        const result = await parseData({
-          loader,
-          arrayBuffer: input,
-          options: options2,
-          context: {
-            ...loaderContext,
-            coreApi: createWorkerCoreApi(),
-            _parse: createParseOnMainThread(workerContext?.process)
-          }
-        });
-        return loader.serializeWorkerResult ? loader.serializeWorkerResult(result, options2, loaderContext) : result;
-      }
+      (input, options, workerContext, loaderContext) => processLoaderWorkerData(loader, input, options, workerContext, loaderContext)
     );
   }
+  async function processLoaderWorkerData(loader, input, options = {}, workerContext, loaderContext = {}) {
+    const result = await parseData({
+      loader,
+      arrayBuffer: input,
+      options,
+      context: {
+        ...loaderContext,
+        coreApi: createWorkerCoreApi(),
+        _parse: createParseOnMainThread(workerContext?.process)
+      }
+    });
+    return loader.serializeWorkerResult ? loader.serializeWorkerResult(result, options, loaderContext) : result;
+  }
   function createWorkerCoreApi() {
     const unavailable = (methodName) => () => {
       throw new Error(`context.coreApi.${methodName} is unavailable inside worker loaders.`);
@@ -410,17 +449,17 @@ var global=globalThis;
     };
   }
   function createParseOnMainThread(processOnMainThread2) {
-    return (arrayBuffer, loaders, options2, context) => {
+    return (arrayBuffer, loaders, options, context) => {
       if (!processOnMainThread2) {
         throw new Error("Worker not set up to parse on main thread");
       }
-      const parseArguments = getMainThreadParseArguments(loaders, options2, context);
+      const parseArguments = getMainThreadParseArguments(loaders, options, context);
       return processOnMainThread2(arrayBuffer, parseArguments.options, parseArguments.context);
     };
   }
-  function getMainThreadParseArguments(loaders, options2, context) {
-    if (options2) {
-      return { options: options2, context: getSerializableLoaderContext(context) };
+  function getMainThreadParseArguments(loaders, options, context) {
+    if (options) {
+      return { options, context: getSerializableLoaderContext(context) };
     }
     if (Array.isArray(loaders) || loaders && isLoaderObject(loaders)) {
       return { options: void 0, context: getSerializableLoaderContext(context) };
@@ -443,7 +482,7 @@ var global=globalThis;
   async function parseData({
     loader,
     arrayBuffer,
-    options: options2,
+    options,
     context
   }) {
     let data;
@@ -458,15 +497,18 @@ var global=globalThis;
     } else {
       throw new Error(`Could not load data with ${loader.name} loader`);
     }
-    options2 = {
-      ...options2,
-      modules: loader && loader.options && loader.options.modules || {},
+    options = {
+      ...options,
+      modules: {
+        ...loader && loader.options && loader.options.modules || {},
+        ...options.modules || {}
+      },
       core: {
-        ...options2.core,
+        ...options.core,
         worker: false
       }
     };
-    return await parser(data, { ...options2 }, context, loader);
+    return await parser(data, { ...options }, context, loader);
   }
   var init_create_loader_worker = __esm({
     "../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts"() {
@@ -572,6 +614,17 @@ var global=globalThis;
     }
   });
 
+  // ../loader-utils/src/lib/scan-utils/table-scan-batch.ts
+  function makeTableScanBatch(table) {
+    return { ...table, batchType: "data", length: table.data.numRows };
+  }
+  var init_table_scan_batch = __esm({
+    "../loader-utils/src/lib/scan-utils/table-scan-batch.ts"() {
+      "use strict";
+      init_process();
+    }
+  });
+
   // ../loader-utils/src/index.ts
   var init_src2 = __esm({
     "../loader-utils/src/index.ts"() {
@@ -581,6 +634,7 @@ var global=globalThis;
       init_create_loader_worker();
       init_async_iteration();
       init_blob_file();
+      init_table_scan_batch();
     }
   });
 
@@ -1292,11 +1346,11 @@ var global=globalThis;
           return pump2(fromNodeStream(stream));
         },
         // @ts-ignore
-        toDOMStream(source, options2) {
+        toDOMStream(source, options) {
           throw new Error(`"toDOMStream" not available in this environment`);
         },
         // @ts-ignore
-        toNodeStream(source, options2) {
+        toNodeStream(source, options) {
           throw new Error(`"toNodeStream" not available in this environment`);
         }
       };
@@ -8170,12 +8224,12 @@ return true;`);
       Builder2 = class {
         /** @nocollapse */
         // @ts-ignore
-        static throughNode(options2) {
+        static throughNode(options) {
           throw new Error(`"throughNode" not available in this environment`);
         }
         /** @nocollapse */
         // @ts-ignore
-        static throughDOM(options2) {
+        static throughDOM(options) {
           throw new Error(`"throughDOM" not available in this environment`);
         }
         /**
@@ -9914,14 +9968,14 @@ return true;`);
         tee() {
           return this._getDOMStream().tee();
         }
-        pipe(writable, options2) {
-          return this._getNodeStream().pipe(writable, options2);
+        pipe(writable, options) {
+          return this._getNodeStream().pipe(writable, options);
         }
-        pipeTo(writable, options2) {
-          return this._getDOMStream().pipeTo(writable, options2);
+        pipeTo(writable, options) {
+          return this._getDOMStream().pipeTo(writable, options);
         }
-        pipeThrough(duplex, options2) {
-          return this._getDOMStream().pipeThrough(duplex, options2);
+        pipeThrough(duplex, options) {
+          return this._getDOMStream().pipeThrough(duplex, options);
         }
         _getDOMStream() {
           return this._DOMStream || (this._DOMStream = this.toDOMStream());
@@ -9968,11 +10022,11 @@ return true;`);
         [Symbol.asyncIterator]() {
           return this;
         }
-        toDOMStream(options2) {
-          return adapters_default.toDOMStream(this._closedPromiseResolve || this._error ? this : this._values, options2);
+        toDOMStream(options) {
+          return adapters_default.toDOMStream(this._closedPromiseResolve || this._error ? this : this._values, options);
         }
-        toNodeStream(options2) {
-          return adapters_default.toNodeStream(this._closedPromiseResolve || this._error ? this : this._values, options2);
+        toNodeStream(options) {
+          return adapters_default.toNodeStream(this._closedPromiseResolve || this._error ? this : this._values, options);
         }
         throw(_) {
           return __awaiter(this, void 0, void 0, function* () {
@@ -11097,8 +11151,8 @@ return true;`);
       init_buffer3();
       init_builder2();
       BoolBuilder = class extends Builder2 {
-        constructor(options2) {
-          super(options2);
+        constructor(options) {
+          super(options);
           this._values = new BitmapBufferBuilder();
         }
         setValue(index, value) {
@@ -11621,11 +11675,11 @@ return true;`);
       init_builder2();
       init_type2();
       UnionBuilder = class extends Builder2 {
-        constructor(options2) {
-          super(options2);
+        constructor(options) {
+          super(options);
           this._typeIds = new DataBufferBuilder(Int8Array, 0, 1);
-          if (typeof options2["valueToChildTypeId"] === "function") {
-            this._valueToChildTypeId = options2["valueToChildTypeId"];
+          if (typeof options["valueToChildTypeId"] === "function") {
+            this._valueToChildTypeId = options["valueToChildTypeId"];
           }
         }
         get typeIdToChildIndex() {
@@ -11664,8 +11718,8 @@ return true;`);
       SparseUnionBuilder = class extends UnionBuilder {
       };
       DenseUnionBuilder = class extends UnionBuilder {
-        constructor(options2) {
-          super(options2);
+        constructor(options) {
+          super(options);
           this._offsets = new DataBufferBuilder(Int32Array);
         }
         /** @ignore */
@@ -12219,12 +12273,12 @@ return true;`);
   });
 
   // ../../node_modules/apache-arrow/factories.mjs
-  function makeBuilder(options2) {
-    const type = options2.type;
-    const builder = new (instance6.getVisitFn(type)())(options2);
+  function makeBuilder(options) {
+    const type = options.type;
+    const builder = new (instance6.getVisitFn(type)())(options);
     if (type.children && type.children.length > 0) {
-      const children = options2["children"] || [];
-      const defaultOptions = { "nullValues": options2["nullValues"] };
+      const children = options["children"] || [];
+      const defaultOptions = { "nullValues": options["nullValues"] };
       const getChildOptions = Array.isArray(children) ? ((_, i) => children[i] || defaultOptions) : (({ name }) => children[name] || defaultOptions);
       for (const [index, field] of type.children.entries()) {
         const { type: type2 } = field;
@@ -12238,8 +12292,8 @@ return true;`);
     if (init instanceof Data || init instanceof Vector || init.type instanceof DataType || ArrayBuffer.isView(init)) {
       return makeVector(init);
     }
-    const options2 = { type: type !== null && type !== void 0 ? type : inferType(init), nullValues: [null] };
-    const chunks = [...builderThroughIterable(options2)(init)];
+    const options = { type: type !== null && type !== void 0 ? type : inferType(init), nullValues: [null] };
+    const chunks = [...builderThroughIterable(options)(init)];
     const vector = chunks.length === 1 ? chunks[0] : chunks.reduce((a, b) => a.concat(b));
     if (DataType.isDictionary(vector.type)) {
       return vector.memoize();
@@ -12322,13 +12376,13 @@ return true;`);
     }
     throw new TypeError("Unable to infer Vector type from input values, explicit type declaration expected.");
   }
-  function builderThroughIterable(options2) {
-    const { ["queueingStrategy"]: queueingStrategy = "count" } = options2;
-    const { ["highWaterMark"]: highWaterMark = queueingStrategy !== "bytes" ? Number.POSITIVE_INFINITY : Math.pow(2, 14) } = options2;
+  function builderThroughIterable(options) {
+    const { ["queueingStrategy"]: queueingStrategy = "count" } = options;
+    const { ["highWaterMark"]: highWaterMark = queueingStrategy !== "bytes" ? Number.POSITIVE_INFINITY : Math.pow(2, 14) } = options;
     const sizeProperty = queueingStrategy !== "bytes" ? "length" : "byteLength";
     return function* (source) {
       let numChunks = 0;
-      const builder = makeBuilder(options2);
+      const builder = makeBuilder(options);
       for (const value of source) {
         if (builder.append(value)[sizeProperty] >= highWaterMark) {
           ++numChunks && (yield builder.toVector());
@@ -12339,15 +12393,15 @@ return true;`);
       }
     };
   }
-  function builderThroughAsyncIterable(options2) {
-    const { ["queueingStrategy"]: queueingStrategy = "count" } = options2;
-    const { ["highWaterMark"]: highWaterMark = queueingStrategy !== "bytes" ? Number.POSITIVE_INFINITY : Math.pow(2, 14) } = options2;
+  function builderThroughAsyncIterable(options) {
+    const { ["queueingStrategy"]: queueingStrategy = "count" } = options;
+    const { ["highWaterMark"]: highWaterMark = queueingStrategy !== "bytes" ? Number.POSITIVE_INFINITY : Math.pow(2, 14) } = options;
     const sizeProperty = queueingStrategy !== "bytes" ? "length" : "byteLength";
     return function(source) {
       return __asyncGenerator(this, arguments, function* () {
         var _a5, e_1, _b2, _c2;
         let numChunks = 0;
-        const builder = makeBuilder(options2);
+        const builder = makeBuilder(options);
         try {
           for (var _d2 = true, source_1 = __asyncValues(source), source_1_1; source_1_1 = yield __await(source_1.next()), _a5 = source_1_1.done, !_a5; _d2 = true) {
             _c2 = source_1_1.value;
@@ -13461,8 +13515,8 @@ return true;`);
   });
 
   // ../../node_modules/apache-arrow/ipc/reader.mjs
-  function shouldAutoDestroy(self2, options2) {
-    return options2 && typeof options2["autoDestroy"] === "boolean" ? options2["autoDestroy"] : self2["autoDestroy"];
+  function shouldAutoDestroy(self2, options) {
+    return options && typeof options["autoDestroy"] === "boolean" ? options["autoDestroy"] : self2["autoDestroy"];
   }
   function* readAllSync(source) {
     const reader = RecordBatchReader.from(source);
@@ -13596,8 +13650,8 @@ return true;`);
           this._nodeStream = void 0;
           return this;
         }
-        open(options2) {
-          const opening = this._impl.open(options2);
+        open(options) {
+          const opening = this._impl.open(options);
           return isPromise(opening) ? opening.then(() => this) : this;
         }
         readRecordBatch(index) {
@@ -13617,7 +13671,7 @@ return true;`);
         }
         /** @nocollapse */
         // @ts-ignore
-        static throughNode(options2) {
+        static throughNode(options) {
           throw new Error(`"throughNode" not available in this environment`);
         }
         /** @nocollapse */
@@ -13838,9 +13892,9 @@ return true;`);
             this.dictionaries = null;
           }
         }
-        open(options2) {
+        open(options) {
           if (!this.closed) {
-            this.autoDestroy = shouldAutoDestroy(this, options2);
+            this.autoDestroy = shouldAutoDestroy(this, options);
             if (!(this.schema || (this.schema = this._reader.readSchema()))) {
               this.cancel();
             }
@@ -13915,10 +13969,10 @@ return true;`);
             }
           });
         }
-        open(options2) {
+        open(options) {
           return __awaiter(this, void 0, void 0, function* () {
             if (!this.closed) {
-              this.autoDestroy = shouldAutoDestroy(this, options2);
+              this.autoDestroy = shouldAutoDestroy(this, options);
               if (!(this.schema || (this.schema = yield this._reader.readSchema()))) {
                 yield this.cancel();
               }
@@ -13998,14 +14052,14 @@ return true;`);
         isFile() {
           return true;
         }
-        open(options2) {
+        open(options) {
           if (!this.closed && !this._footer) {
             this.schema = (this._footer = this._readFooter()).schema;
             for (const block of this._footer.dictionaryBatches()) {
               block && this._readDictionaryBatch(this._dictionaryIndex++);
             }
           }
-          return super.open(options2);
+          return super.open(options);
         }
         readRecordBatch(index) {
           var _a5;
@@ -14082,7 +14136,7 @@ return true;`);
         isAsync() {
           return true;
         }
-        open(options2) {
+        open(options) {
           const _super = Object.create(null, {
             open: { get: () => super.open }
           });
@@ -14093,7 +14147,7 @@ return true;`);
                 block && (yield this._readDictionaryBatch(this._dictionaryIndex++));
               }
             }
-            return yield _super.open.call(this, options2);
+            return yield _super.open.call(this, options);
           });
         }
         readRecordBatch(index) {
@@ -14716,14 +14770,14 @@ return true;`);
       RecordBatchWriter = class extends ReadableInterop {
         /** @nocollapse */
         // @ts-ignore
-        static throughNode(options2) {
+        static throughNode(options) {
           throw new Error(`"throughNode" not available in this environment`);
         }
         /** @nocollapse */
         static throughDOM(writableStrategy, readableStrategy) {
           throw new Error(`"throughDOM" not available in this environment`);
         }
-        constructor(options2) {
+        constructor(options) {
           super();
           this._position = 0;
           this._started = false;
@@ -14734,18 +14788,18 @@ return true;`);
           this._recordBatchBlocks = [];
           this._seenDictionaries = /* @__PURE__ */ new Map();
           this._dictionaryDeltaOffsets = /* @__PURE__ */ new Map();
-          isObject(options2) || (options2 = { autoDestroy: true, writeLegacyIpcFormat: false, compressionType: null });
-          this._autoDestroy = typeof options2.autoDestroy === "boolean" ? options2.autoDestroy : true;
-          this._writeLegacyIpcFormat = typeof options2.writeLegacyIpcFormat === "boolean" ? options2.writeLegacyIpcFormat : false;
-          if (options2.compressionType != null) {
+          isObject(options) || (options = { autoDestroy: true, writeLegacyIpcFormat: false, compressionType: null });
+          this._autoDestroy = typeof options.autoDestroy === "boolean" ? options.autoDestroy : true;
+          this._writeLegacyIpcFormat = typeof options.writeLegacyIpcFormat === "boolean" ? options.writeLegacyIpcFormat : false;
+          if (options.compressionType != null) {
             if (this._writeLegacyIpcFormat) {
               throw new Error("Legacy IPC format does not support columnar compression. Use modern IPC format (writeLegacyIpcFormat=false).");
             }
-            if (Object.values(CompressionType).includes(options2.compressionType)) {
-              this._compression = new BodyCompression2(options2.compressionType);
+            if (Object.values(CompressionType).includes(options.compressionType)) {
+              this._compression = new BodyCompression2(options.compressionType);
             } else {
               const validCompressionTypes = Object.values(CompressionType).filter((v) => typeof v === "string");
-              throw new Error(`Unsupported compressionType: ${options2.compressionType} Available types: ${validCompressionTypes.join(", ")}`);
+              throw new Error(`Unsupported compressionType: ${options.compressionType} Available types: ${validCompressionTypes.join(", ")}`);
             }
           } else {
             this._compression = null;
@@ -14771,11 +14825,11 @@ return true;`);
         [Symbol.asyncIterator]() {
           return this._sink[Symbol.asyncIterator]();
         }
-        toDOMStream(options2) {
-          return this._sink.toDOMStream(options2);
+        toDOMStream(options) {
+          return this._sink.toDOMStream(options);
         }
-        toNodeStream(options2) {
-          return this._sink.toNodeStream(options2);
+        toNodeStream(options) {
+          return this._sink.toNodeStream(options);
         }
         close() {
           return this.reset()._sink.close();
@@ -14983,8 +15037,8 @@ return true;`);
       };
       RecordBatchStreamWriter = class _RecordBatchStreamWriter extends RecordBatchWriter {
         /** @nocollapse */
-        static writeAll(input, options2) {
-          const writer = new _RecordBatchStreamWriter(options2);
+        static writeAll(input, options) {
+          const writer = new _RecordBatchStreamWriter(options);
           if (isPromise(input)) {
             return input.then((x) => writer.writeAll(x));
           } else if (isAsyncIterable(input)) {
@@ -14995,8 +15049,8 @@ return true;`);
       };
       RecordBatchFileWriter = class _RecordBatchFileWriter extends RecordBatchWriter {
         /** @nocollapse */
-        static writeAll(input, options2) {
-          const writer = new _RecordBatchFileWriter(options2);
+        static writeAll(input, options) {
+          const writer = new _RecordBatchFileWriter(options);
           if (isPromise(input)) {
             return input.then((x) => writer.writeAll(x));
           } else if (isAsyncIterable(input)) {
@@ -15004,8 +15058,8 @@ return true;`);
           }
           return writeAll(writer, input);
         }
-        constructor(options2) {
-          super(options2);
+        constructor(options) {
+          super(options);
           this._autoDestroy = true;
           this._writeLegacyIpcFormat = false;
         }
@@ -15100,20 +15154,20 @@ return true;`);
   });
 
   // ../../node_modules/apache-arrow/io/whatwg/iterable.mjs
-  function toDOMStream(source, options2) {
+  function toDOMStream(source, options) {
     if (isAsyncIterable(source)) {
-      return asyncIterableAsReadableDOMStream(source, options2);
+      return asyncIterableAsReadableDOMStream(source, options);
     }
     if (isIterable(source)) {
-      return iterableAsReadableDOMStream(source, options2);
+      return iterableAsReadableDOMStream(source, options);
     }
     throw new Error(`toDOMStream() must be called with an Iterable or AsyncIterable`);
   }
-  function iterableAsReadableDOMStream(source, options2) {
+  function iterableAsReadableDOMStream(source, options) {
     let it = null;
-    const bm = (options2 === null || options2 === void 0 ? void 0 : options2.type) === "bytes" || false;
-    const hwm = (options2 === null || options2 === void 0 ? void 0 : options2.highWaterMark) || Math.pow(2, 24);
-    return new ReadableStream(Object.assign(Object.assign({}, options2), {
+    const bm = (options === null || options === void 0 ? void 0 : options.type) === "bytes" || false;
+    const hwm = (options === null || options === void 0 ? void 0 : options.highWaterMark) || Math.pow(2, 24);
+    return new ReadableStream(Object.assign(Object.assign({}, options), {
       start(controller) {
         next(controller, it || (it = source[Symbol.iterator]()));
       },
@@ -15124,7 +15178,7 @@ return true;`);
         (it === null || it === void 0 ? void 0 : it.return) && it.return();
         it = null;
       }
-    }), Object.assign({ highWaterMark: bm ? hwm : void 0 }, options2));
+    }), Object.assign({ highWaterMark: bm ? hwm : void 0 }, options));
     function next(controller, it2) {
       let buf;
       let r = null;
@@ -15142,11 +15196,11 @@ return true;`);
       controller.close();
     }
   }
-  function asyncIterableAsReadableDOMStream(source, options2) {
+  function asyncIterableAsReadableDOMStream(source, options) {
     let it = null;
-    const bm = (options2 === null || options2 === void 0 ? void 0 : options2.type) === "bytes" || false;
-    const hwm = (options2 === null || options2 === void 0 ? void 0 : options2.highWaterMark) || Math.pow(2, 24);
-    return new ReadableStream(Object.assign(Object.assign({}, options2), {
+    const bm = (options === null || options === void 0 ? void 0 : options.type) === "bytes" || false;
+    const hwm = (options === null || options === void 0 ? void 0 : options.highWaterMark) || Math.pow(2, 24);
+    return new ReadableStream(Object.assign(Object.assign({}, options), {
       start(controller) {
         return __awaiter(this, void 0, void 0, function* () {
           yield next(controller, it || (it = source[Symbol.asyncIterator]()));
@@ -15163,7 +15217,7 @@ return true;`);
           it = null;
         });
       }
-    }), Object.assign({ highWaterMark: bm ? hwm : void 0 }, options2));
+    }), Object.assign({ highWaterMark: bm ? hwm : void 0 }, options));
     function next(controller, it2) {
       return __awaiter(this, void 0, void 0, function* () {
         let buf;
@@ -15193,8 +15247,8 @@ return true;`);
   });
 
   // ../../node_modules/apache-arrow/io/whatwg/builder.mjs
-  function builderThroughDOMStream(options2) {
-    return new BuilderTransform(options2);
+  function builderThroughDOMStream(options) {
+    return new BuilderTransform(options);
   }
   var BuilderTransform, chunkLength, chunkByteLength;
   var init_builder3 = __esm({
@@ -15203,11 +15257,11 @@ return true;`);
       init_tslib_es6();
       init_factories();
       BuilderTransform = class {
-        constructor(options2) {
+        constructor(options) {
           this._numChunks = 0;
           this._finished = false;
           this._bufferedSize = 0;
-          const { ["readableStrategy"]: readableStrategy, ["writableStrategy"]: writableStrategy, ["queueingStrategy"]: queueingStrategy = "count" } = options2, builderOptions = __rest(options2, ["readableStrategy", "writableStrategy", "queueingStrategy"]);
+          const { ["readableStrategy"]: readableStrategy, ["writableStrategy"]: writableStrategy, ["queueingStrategy"]: queueingStrategy = "count" } = options, builderOptions = __rest(options, ["readableStrategy", "writableStrategy", "queueingStrategy"]);
           this._controller = null;
           this._builder = makeBuilder(builderOptions);
           this._getSize = queueingStrategy !== "bytes" ? chunkLength : chunkByteLength;
@@ -15710,8 +15764,8 @@ return true;`);
   function convertArrowToSchema(arrowSchema) {
     return serializeArrowSchema(arrowSchema);
   }
-  function convertSchemaToArrow(schema, options2) {
-    return deserializeArrowSchema(schema, options2);
+  function convertSchemaToArrow(schema, options) {
+    return deserializeArrowSchema(schema, options);
   }
   function serializeArrowSchema(arrowSchema) {
     return {
@@ -15719,9 +15773,9 @@ return true;`);
       metadata: serializeArrowMetadata(arrowSchema.metadata)
     };
   }
-  function deserializeArrowSchema(schema, options2) {
+  function deserializeArrowSchema(schema, options) {
     return new Schema2(
-      schema.fields.map((field) => deserializeArrowField(field, options2)),
+      schema.fields.map((field) => deserializeArrowField(field, options)),
       deserializeArrowMetadata(schema.metadata)
     );
   }
@@ -15739,10 +15793,10 @@ return true;`);
       metadata: serializeArrowMetadata(field.metadata)
     };
   }
-  function deserializeArrowField(field, options2) {
+  function deserializeArrowField(field, options) {
     return new Field2(
       field.name,
-      deserializeArrowType(field.type, options2),
+      deserializeArrowType(field.type, options),
       field.nullable,
       deserializeArrowMetadata(field.metadata)
     );
@@ -15768,7 +15822,7 @@ return true;`);
         return "bool";
       case Int_:
         const intType = arrowType;
-        return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
+        return `${intType.isSigned ? "" : "u"}int${intType.bitWidth}`;
       case Int8:
         return "int8";
       case Int16:
@@ -15918,36 +15972,36 @@ return true;`);
         throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
     }
   }
-  function deserializeArrowType(dataType, options2) {
+  function deserializeArrowType(dataType, options) {
     if (typeof dataType === "object") {
       switch (dataType.type) {
         case "decimal":
           return new Decimal2(dataType.scale, dataType.precision, dataType.bitWidth);
         case "map": {
           const children = dataType.children.map(
-            (arrowField) => deserializeArrowField(arrowField, options2)
+            (arrowField) => deserializeArrowField(arrowField, options)
           );
-          return new Map_(children, dataType.keysSorted);
+          return new Map_(children[0], dataType.keysSorted);
         }
         case "list": {
-          const field = deserializeArrowField(dataType.children[0], options2);
+          const field = deserializeArrowField(dataType.children[0], options);
           return new List2(field);
         }
         case "fixed-size-list": {
-          const child = deserializeArrowField(dataType.children[0], options2);
+          const child = deserializeArrowField(dataType.children[0], options);
           return new FixedSizeList2(dataType.listSize, child);
         }
         case "fixed-size-binary":
           return new FixedSizeBinary2(dataType.byteWidth);
         case "struct": {
           const children = dataType.children.map(
-            (arrowField) => deserializeArrowField(arrowField, options2)
+            (arrowField) => deserializeArrowField(arrowField, options)
           );
           return new Struct(children);
         }
         case "dictionary": {
           return new Dictionary(
-            deserializeArrowType(dataType.dictionary, options2),
+            deserializeArrowType(dataType.dictionary, options),
             deserializeArrowDictionaryKeyType(dataType.indices),
             dataType.id,
             dataType.isOrdered
@@ -15961,7 +16015,7 @@ return true;`);
       case "null":
         return new Null2();
       case "binary":
-        return makeVariableWidthArrowType("BinaryView", new Binary2(), options2);
+        return makeVariableWidthArrowType("BinaryView", new Binary2(), options);
       case "binary-view":
         return makeRequiredArrowViewType("BinaryView");
       case "bool":
@@ -15989,7 +16043,7 @@ return true;`);
       case "float64":
         return new Float64();
       case "utf8":
-        return makeVariableWidthArrowType("Utf8View", new Utf82(), options2);
+        return makeVariableWidthArrowType("Utf8View", new Utf82(), options);
       case "utf8-view":
         return makeRequiredArrowViewType("Utf8View");
       case "date-day":
@@ -16032,8 +16086,8 @@ return true;`);
     const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
     return Boolean(guard?.(arrowType));
   }
-  function makeVariableWidthArrowType(viewTypeName, fallbackType, options2) {
-    const viewTypeMode = options2?.viewTypes || "never";
+  function makeVariableWidthArrowType(viewTypeName, fallbackType, options) {
+    const viewTypeMode = options?.viewTypes || "never";
     if (viewTypeMode === "never") {
       return fallbackType;
     }
@@ -16312,7 +16366,7 @@ return true;`);
         if (table.schema) {
           const objectRow2 = target || {};
           for (let i = 0; i < table.schema.fields.length; i++) {
-            objectRow2[table.schema.fields[i].name] = table.features[rowIndex][i];
+            objectRow2[table.schema.fields[i].name] = table.features[rowIndex][table.schema.fields[i].name];
           }
           return objectRow2;
         }
@@ -16416,11 +16470,11 @@ return true;`);
   });
 
   // ../schema-utils/src/lib/table/batches/make-arrow-batch-iterator.ts
-  function* makeArrowRecordBatchIterator(table, options2) {
+  function* makeArrowRecordBatchIterator(table, options) {
     const arrowSchema = convertSchemaToArrow(table.schema);
     const length = getTableLength(table);
     const numColumns = getTableNumCols(table);
-    const batchSize = options2?.batchSize || length;
+    const batchSize = options?.batchSize || length;
     const builders = arrowSchema?.fields.map(
       (arrowField) => makeBuilder({
         type: arrowField.type,
@@ -16462,7 +16516,7 @@ return true;`);
   });
 
   // ../schema-utils/src/lib/table/tables/convert-arrow-table.ts
-  function convertTableToArrow(table, options2) {
+  function convertTableToArrow(table, options) {
     switch (table.shape) {
       case "arrow-table":
         return table.data;
@@ -16471,7 +16525,7 @@ return true;`);
       // return convertColumnarTableToArrow(table, options);
       // fall through
       default:
-        const arrowBatchIterator = makeArrowRecordBatchIterator(table, options2);
+        const arrowBatchIterator = makeArrowRecordBatchIterator(table, options);
         return new Table(arrowBatchIterator);
     }
   }
@@ -16562,7 +16616,7 @@ return true;`);
   }
   function convertToColumnarTable(table) {
     const schema = table.schema || deduceTableSchema(table);
-    const fields = table.schema?.fields || [];
+    const fields = schema.fields;
     if (table.shape === "columnar-table") {
       return { ...table, schema };
     }
@@ -16826,14 +16880,15 @@ return true;`);
       return null;
     }
     const extensionMetadata = {};
-    if (columnMetadata.crs !== void 0) {
+    if (columnMetadata.crs === void 0) {
+      extensionMetadata.crs = "OGC:CRS84";
+      extensionMetadata.crs_type = "authority_code";
+    } else if (columnMetadata.crs !== null) {
       extensionMetadata.crs = columnMetadata.crs;
+      extensionMetadata.crs_type = "projjson";
     }
-    if (columnMetadata.crs_type !== void 0) {
-      extensionMetadata.crs_type = columnMetadata.crs_type;
-    }
-    if (columnMetadata.edges === "spherical") {
-      extensionMetadata.edges = "spherical";
+    if (columnMetadata.edges && columnMetadata.edges !== "planar") {
+      extensionMetadata.edges = columnMetadata.edges;
     }
     return Object.keys(extensionMetadata).length > 0 ? { extensionName, extensionMetadata } : { extensionName };
   }
@@ -17140,10 +17195,10 @@ ${val.stack}`;
     WASM_VECTOR_LEN = arg.length;
     return ptr;
   }
-  function readParquet(parquet_file, options2) {
+  function readParquet(parquet_file, options) {
     const ptr0 = passArray8ToWasm0(parquet_file, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.readParquet(ptr0, len0, isLikeNone(options2) ? 0 : addToExternrefTable0(options2));
+    const ret = wasm.readParquet(ptr0, len0, isLikeNone(options) ? 0 : addToExternrefTable0(options));
     if (ret[2]) {
       throw takeFromExternrefTable0(ret[1]);
     }
@@ -18579,8 +18634,8 @@ ${val.stack}`;
          * @param {ReaderOptions | null} [options]
          * @returns {Promise<Table>}
          */
-        read(options2) {
-          const ret = wasm.parquetfile_read(this.__wbg_ptr, isLikeNone(options2) ? 0 : addToExternrefTable0(options2));
+        read(options) {
+          const ret = wasm.parquetfile_read(this.__wbg_ptr, isLikeNone(options) ? 0 : addToExternrefTable0(options));
           return ret;
         }
         /**
@@ -18612,8 +18667,8 @@ ${val.stack}`;
          * @param {ReaderOptions | null} [options]
          * @returns {Promise<ReadableStream>}
          */
-        stream(options2) {
-          const ret = wasm.parquetfile_stream(this.__wbg_ptr, isLikeNone(options2) ? 0 : addToExternrefTable0(options2));
+        stream(options) {
+          const ret = wasm.parquetfile_stream(this.__wbg_ptr, isLikeNone(options) ? 0 : addToExternrefTable0(options));
           return ret;
         }
         /**
@@ -19449,15 +19504,15 @@ ${val.stack}`;
   });
 
   // src/lib/utils/make-stream-iterator.ts
-  function makeStreamIterator(stream, options2) {
-    return isBrowser || isReadableStream(stream) ? makeBrowserStreamIterator(stream, options2) : makeNodeStreamIterator(stream, options2);
+  function makeStreamIterator(stream, options) {
+    return isBrowser || isReadableStream(stream) ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
   }
   function isReadableStream(stream) {
     return typeof stream.getReader === "function";
   }
-  async function* makeBrowserStreamIterator(stream, options2) {
+  async function* makeBrowserStreamIterator(stream, options) {
     const reader = stream.getReader();
-    const signal = options2?.signal;
+    const signal = options?.signal;
     const abortListener = () => {
       void reader.cancel(signal?.reason).catch(() => {
       });
@@ -19485,7 +19540,7 @@ ${val.stack}`;
           streamFinished = true;
           return;
         }
-        if (options2?._streamReadAhead) {
+        if (options?._streamReadAhead) {
           nextBatchPromise = reader.read();
           void nextBatchPromise.catch(() => {
           });
@@ -19517,9 +19572,9 @@ ${val.stack}`;
       }
     }
   }
-  async function* makeNodeStreamIterator(stream, options2) {
+  async function* makeNodeStreamIterator(stream, options) {
     const iterator = stream[Symbol.asyncIterator]();
-    const signal = options2?.signal;
+    const signal = options?.signal;
     let abortListener;
     const abortPromise = signal ? new Promise((_resolve, reject) => {
       abortListener = () => reject(getAbortReason(signal));
@@ -19583,9 +19638,9 @@ ${val.stack}`;
   });
 
   // src/lib/parsers/parse-parquet-to-arrow.ts
-  async function parseParquetFileToArrow(file, options2) {
-    const wasmUrl = options2?.wasmUrl;
-    const readerOptions = getReaderOptions(options2);
+  async function parseParquetFileToArrow(file, options) {
+    const wasmUrl = options?.wasmUrl;
+    const readerOptions = getReaderOptions(options);
     const wasm2 = await loadWasm(wasmUrl);
     const parquetFile = await createParquetFile(file, wasm2);
     try {
@@ -19603,9 +19658,9 @@ ${val.stack}`;
       parquetFile.free();
     }
   }
-  async function* parseParquetFileToArrowInBatches(file, options2) {
-    const wasmUrl = options2?.wasmUrl;
-    const readerOptions = getReaderOptions(options2);
+  async function* parseParquetFileToArrowInBatches(file, options) {
+    const wasmUrl = options?.wasmUrl;
+    const readerOptions = getReaderOptions(options);
     const wasm2 = await loadWasm(wasmUrl);
     const parquetFile = await createParquetFile(file, wasm2);
     try {
@@ -19621,13 +19676,11 @@ ${val.stack}`;
           schemaMetadata
         );
         schema ||= normalizedArrowTable.schema;
-        yield {
-          batchType: "data",
+        yield makeTableScanBatch({
           shape: "arrow-table",
           schema,
-          data: normalizedArrowTable.data,
-          length: normalizedArrowTable.data.numRows
-        };
+          data: normalizedArrowTable.data
+        });
       }
     } finally {
       parquetFile.free();
@@ -19639,14 +19692,15 @@ ${val.stack}`;
     }
     return await wasm2.ParquetFile.fromUrl(file.url);
   }
-  function getReaderOptions(options2) {
-    const { wasmUrl, ...readerOptions } = options2 || {};
+  function getReaderOptions(options) {
+    const { wasmUrl, ...readerOptions } = options || {};
     return readerOptions;
   }
   var init_parse_parquet_to_arrow = __esm({
     "src/lib/parsers/parse-parquet-to-arrow.ts"() {
       "use strict";
       init_process();
+      init_src2();
       init_Arrow_dom();
       init_geospatial_metadata();
       init_load_wasm();
@@ -19655,10 +19709,24 @@ ${val.stack}`;
   });
 
   // src/lib/utils/normalize-parquet-options.ts
-  function normalizeParquetOptions(options2, parquetDefaults) {
+  function normalizeParquetOptions(options, parquetDefaults) {
+    const scanOptions = options?._scan;
+    if (scanOptions) {
+      for (const key of Object.keys(scanOptions)) {
+        if (key !== "columns" && key !== "limit") {
+          throw new Error(`Parquet _scan option "${key}" is not supported`);
+        }
+      }
+    }
+    const parquetOptions = options?.parquet || {};
     return {
-      ...options2,
-      parquet: { ...parquetDefaults, ...options2?.parquet }
+      ...options,
+      parquet: {
+        ...parquetDefaults,
+        ...parquetOptions,
+        ...scanOptions?.columns !== void 0 ? { columns: [...scanOptions.columns] } : {},
+        ...scanOptions?.limit !== void 0 ? { limit: scanOptions.limit } : {}
+      }
     };
   }
   var init_normalize_parquet_options = __esm({
@@ -19779,7 +19847,7 @@ ${val.stack}`;
       init_process();
       init_parquet_format();
       init_parquet_loader_options();
-      VERSION = true ? "5.0.0-alpha.2" : "latest";
+      VERSION = true ? "5.0.0-alpha.4" : "latest";
       PARQUET_LOADER_BASE = {
         ...ParquetFormat,
         dataType: null,
@@ -19797,6 +19865,9 @@ ${val.stack}`;
   });
 
   // src/parquet-worker-url.ts
+  function getParquetWorkerUrl(moduleUrl) {
+    return `${moduleUrl.slice(0, moduleUrl.lastIndexOf("/") + 1)}${getParquetWorkerFile()}`;
+  }
   function getParquetWorkerFile() {
     const isNode = Boolean(
       globalThis.process?.versions?.node
@@ -19809,7 +19880,7 @@ ${val.stack}`;
       "use strict";
       init_process();
       import_meta3 = {};
-      PARQUET_WORKER_URL = import_meta3.url ? new URL(getParquetWorkerFile(), import_meta3.url).toString() : typeof __dirname === "string" ? `${__dirname}/parquet-worker-node.cjs` : true;
+      PARQUET_WORKER_URL = import_meta3.url ? getParquetWorkerUrl(import_meta3.url) : typeof __dirname === "string" ? `${__dirname}/parquet-worker-node.cjs` : true;
     }
   });
 
@@ -19839,16 +19910,16 @@ ${val.stack}`;
     ParquetLoaderWithParser: () => ParquetLoaderWithParser,
     getParquetOptions: () => getParquetOptions
   });
-  async function parseParquetTable(file, options2) {
-    const parquetOptions = getParquetOptions(options2);
+  async function parseParquetTable(file, options) {
+    const parquetOptions = getParquetOptions(options);
     if (parquetOptions.parquet?.shape === "arrow-table") {
       return await parseParquetFileToArrow(file, parquetOptions.parquet);
     }
     const arrowTable = await parseParquetFileToArrow(file, parquetOptions.parquet);
     return convertArrowTableToObjectRows(arrowTable);
   }
-  async function* parseParquetTableInBatches(file, options2) {
-    const parquetOptions = getParquetOptions(options2);
+  async function* parseParquetTableInBatches(file, options) {
+    const parquetOptions = getParquetOptions(options);
     if (parquetOptions.parquet?.shape === "arrow-table") {
       yield* parseParquetFileToArrowInBatches(file, parquetOptions.parquet);
       return;
@@ -19857,8 +19928,8 @@ ${val.stack}`;
       yield convertArrowBatchToObjectRows(batch);
     }
   }
-  function getParquetOptions(options2) {
-    return normalizeParquetOptions(options2, ParquetLoaderWithParser.options.parquet);
+  function getParquetOptions(options) {
+    return normalizeParquetOptions(options, ParquetLoaderWithParser.options.parquet);
   }
   var _ParquetLoaderPreload, ParquetLoaderMetadataWithoutPreload, ParquetLoaderWithParser;
   var init_parquet_loader = __esm({
@@ -19874,18 +19945,18 @@ ${val.stack}`;
       ({ preload: _ParquetLoaderPreload, ...ParquetLoaderMetadataWithoutPreload } = ParquetLoader);
       ParquetLoaderWithParser = {
         ...ParquetLoaderMetadataWithoutPreload,
-        parse(arrayBuffer, options2) {
-          return parseParquetTable(new BlobFile(arrayBuffer), options2);
+        parse(arrayBuffer, options) {
+          return parseParquetTable(new BlobFile(arrayBuffer), options);
         },
-        parseFile(file, options2) {
-          return parseParquetTable(file, options2);
+        parseFile(file, options) {
+          return parseParquetTable(file, options);
         },
-        parseFileInBatches(file, options2) {
-          return parseParquetTableInBatches(file, options2);
+        parseFileInBatches(file, options) {
+          return parseParquetTableInBatches(file, options);
         },
-        async *parseInBatches(asyncIterator, options2, _context) {
+        async *parseInBatches(asyncIterator, options, _context) {
           const arrayBuffer = await concatenateArrayBuffersAsync(asyncIterator);
-          yield* parseParquetTableInBatches(new BlobFile(arrayBuffer), options2);
+          yield* parseParquetTableInBatches(new BlobFile(arrayBuffer), options);
         },
         serializeWorkerResult: serializeParquetWorkerResult,
         deserializeWorkerResult: deserializeParquetWorkerResult
@@ -19899,18 +19970,18 @@ ${val.stack}`;
   init_parquet_loader();
   var ParquetWorkerLoader = {
     ...ParquetLoaderWithParser,
-    parse(arrayBuffer, options2) {
-      return ParquetLoaderWithParser.parse(arrayBuffer, addWorkerWasmUrl(options2));
+    parse(arrayBuffer, options) {
+      return ParquetLoaderWithParser.parse(arrayBuffer, addWorkerWasmUrl(options));
     }
   };
-  function addWorkerWasmUrl(options2) {
-    if (options2?.parquet?.wasmUrl || typeof globalThis.location?.href !== "string") {
-      return options2;
+  function addWorkerWasmUrl(options) {
+    if (options?.parquet?.wasmUrl || typeof globalThis.location?.href !== "string") {
+      return options;
     }
     return {
-      ...options2,
+      ...options,
       parquet: {
-        ...options2?.parquet,
+        ...options?.parquet,
         wasmUrl: new URL("parquet_wasm_bg.wasm", globalThis.location.href).toString()
       }
     };