@loaders.gl/excel 5.0.0-alpha.5 → 5.0.0-alpha.7

package/dist/excel-loader-with-parser.d.ts

@@ -18,9 +18,11 @@ export declare const ExcelWorkerLoaderWithParser: {
     readonly batchType: never;
     readonly version: any;
     readonly worker: true;
+    readonly serializeWorkerResult: typeof import("@loaders.gl/arrow/transport").serializeArrowWorkerResult;
+    readonly deserializeWorkerResult: typeof import("@loaders.gl/arrow/transport").deserializeArrowWorkerResult;
     readonly options: {
         readonly excel: {
-            readonly shape: "object-row-table";
+            readonly shape: "arrow-table";
             readonly sheet: undefined;
         };
     };
@@ -41,9 +43,11 @@ export declare const ExcelLoaderWithParser: {
     readonly batchType: never;
     readonly version: any;
     readonly worker: true;
+    readonly serializeWorkerResult: typeof import("@loaders.gl/arrow/transport").serializeArrowWorkerResult;
+    readonly deserializeWorkerResult: typeof import("@loaders.gl/arrow/transport").deserializeArrowWorkerResult;
     readonly options: {
         readonly excel: {
-            readonly shape: "object-row-table";
+            readonly shape: "arrow-table";
             readonly sheet: undefined;
         };
     };

package/dist/excel-loader-with-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"excel-loader-with-parser.d.ts","sourceRoot":"","sources":["../src/excel-loader-with-parser.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAA2B,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACtF,OAAO,KAAK,EAAC,UAAU,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAUnE,4CAA4C;AAC5C,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAC/C,wCAAwC;IACxC,KAAK,CAAC,EAAE;QACN,uDAAuD;QACvD,KAAK,CAAC,EAA4B,AAA1B,yBAAyB,CAAC,kBAAkB,GAAG,aAAa,CAAC;QACrE,mEAAmE;QACnE,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,+EAA+E;QAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;CAE2C,CAAC;AAEpF,8BAA8B;AAC9B,eAAO,MAAM,qBAAqB;kCAGjB,WAAW,YACd,kBAAkB,KAC3B,OAAO,CAAC,cAAc,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;CAWoD,CAAC"}
+{"version":3,"file":"excel-loader-with-parser.d.ts","sourceRoot":"","sources":["../src/excel-loader-with-parser.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAA2B,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACtF,OAAO,KAAK,EAAC,UAAU,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAUnE,4CAA4C;AAC5C,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAC/C,wCAAwC;IACxC,KAAK,CAAC,EAAE;QACN,uDAAuD;QACvD,KAAK,CAAC,EAA4B,AAA1B,yBAAyB,CAAC,kBAAkB,GAAG,aAAa,CAAC;QACrE,mEAAmE;QACnE,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,+EAA+E;QAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;CAE2C,CAAC;AAEpF,8BAA8B;AAC9B,eAAO,MAAM,qBAAqB;kCAGjB,WAAW,YACd,kBAAkB,KAC3B,OAAO,CAAC,cAAc,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;CAWoD,CAAC"}

package/dist/excel-loader.d.ts

@@ -1,5 +1,6 @@
 import type { LoaderOptions } from '@loaders.gl/loader-utils';
 import type { ArrowTable, ObjectRowTable } from '@loaders.gl/schema';
+import { deserializeArrowWorkerResult, serializeArrowWorkerResult } from '@loaders.gl/arrow/transport';
 /** Options for parsing Excel worksheets. */
 export type ExcelLoaderOptions = LoaderOptions & {
     /** Options for ExcelLoader */
@@ -19,9 +20,11 @@ declare function preload(): Promise<{
     readonly batchType: never;
     readonly version: any;
     readonly worker: true;
+    readonly serializeWorkerResult: typeof serializeArrowWorkerResult;
+    readonly deserializeWorkerResult: typeof deserializeArrowWorkerResult;
     readonly options: {
         readonly excel: {
-            readonly shape: "object-row-table";
+            readonly shape: "arrow-table";
             readonly sheet: undefined;
         };
     };
@@ -36,14 +39,16 @@ declare function preload(): Promise<{
     readonly binary: true;
 }>;
 /** Metadata-only worker loader for Excel files. */
-export declare const ExcelWorkerLoader: {
+export declare const ExcelLoader: {
     readonly dataType: ObjectRowTable | ArrowTable;
     readonly batchType: never;
     readonly version: any;
     readonly worker: true;
+    readonly serializeWorkerResult: typeof serializeArrowWorkerResult;
+    readonly deserializeWorkerResult: typeof deserializeArrowWorkerResult;
     readonly options: {
         readonly excel: {
-            readonly shape: "object-row-table";
+            readonly shape: "arrow-table";
             readonly sheet: undefined;
         };
     };
@@ -58,19 +63,21 @@ export declare const ExcelWorkerLoader: {
     readonly category: "table";
     readonly binary: true;
 };
-/** Metadata-only loader for Excel files. */
-export declare const ExcelLoader: {
-    readonly preload: typeof preload;
+/** @deprecated Use ExcelLoader. */
+export declare const ExcelWorkerLoader: {
     readonly dataType: ObjectRowTable | ArrowTable;
     readonly batchType: never;
     readonly version: any;
     readonly worker: true;
+    readonly serializeWorkerResult: typeof serializeArrowWorkerResult;
+    readonly deserializeWorkerResult: typeof deserializeArrowWorkerResult;
     readonly options: {
         readonly excel: {
-            readonly shape: "object-row-table";
+            readonly shape: "arrow-table";
             readonly sheet: undefined;
         };
     };
+    readonly preload: typeof preload;
     readonly name: "Excel";
     readonly id: "excel";
     readonly module: "excel";

package/dist/excel-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"excel-loader.d.ts","sourceRoot":"","sources":["../src/excel-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAC,UAAU,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAOnE,4CAA4C;AAC5C,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAC/C,8BAA8B;IAC9B,KAAK,CAAC,EAAE;QACN,uDAAuD;QACvD,KAAK,CAAC,EAA4B,AAA1B,yBAAyB,CAAC,kBAAkB,GAAG,aAAa,CAAC;QACrE,mEAAmE;QACnE,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,+EAA+E;QAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,+DAA+D;AAC/D,iBAAe,OAAO;;uBAQS,cAAc,GAAG,UAAU;wBACrC,KAAK;;;;;;;;;;;;;;;;;;GANzB;AAED,mDAAmD;AACnD,eAAO,MAAM,iBAAiB;uBAEC,cAAc,GAAG,UAAU;wBACrC,KAAK;;;;;;;;;;;;;;;;;;;CAUyD,CAAC;AAEpF,4CAA4C;AAC5C,eAAO,MAAM,WAAW;;uBAdO,cAAc,GAAG,UAAU;wBACrC,KAAK;;;;;;;;;;;;;;;;;;CAgByD,CAAC"}
+{"version":3,"file":"excel-loader.d.ts","sourceRoot":"","sources":["../src/excel-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAC,UAAU,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAEnE,OAAO,EACL,4BAA4B,EAC5B,0BAA0B,EAC3B,MAAM,6BAA6B,CAAC;AAMrC,4CAA4C;AAC5C,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAC/C,8BAA8B;IAC9B,KAAK,CAAC,EAAE;QACN,uDAAuD;QACvD,KAAK,CAAC,EAA4B,AAA1B,yBAAyB,CAAC,kBAAkB,GAAG,aAAa,CAAC;QACrE,mEAAmE;QACnE,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,+EAA+E;QAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF,+DAA+D;AAC/D,iBAAe,OAAO;;uBAQS,cAAc,GAAG,UAAU;wBACrC,KAAK;;;;;;;;;;;;;;;;;;;;GANzB;AAED,mDAAmD;AACnD,eAAO,MAAM,WAAW;uBAEO,cAAc,GAAG,UAAU;wBACrC,KAAK;;;;;;;;;;;;;;;;;;;;;CAYyD,CAAC;AAEpF,mCAAmC;AACnC,eAAO,MAAM,iBAAiB;uBAhBC,cAAc,GAAG,UAAU;wBACrC,KAAK;;;;;;;;;;;;;;;;;;;;;CAekB,CAAC"}

package/dist/excel-loader.js

@@ -2,32 +2,32 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { ExcelFormat } from "./excel-format.js";
+import { deserializeArrowWorkerResult, serializeArrowWorkerResult } from '@loaders.gl/arrow/transport';
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "5.0.0-alpha.5" !== 'undefined' ? "5.0.0-alpha.5" : 'latest';
+const VERSION = typeof "5.0.0-alpha.7" !== 'undefined' ? "5.0.0-alpha.7" : 'latest';
 /** Preloads the parser-bearing Excel loader implementation. */
 async function preload() {
     const { ExcelLoaderWithParser } = await import("./excel-loader-with-parser.js");
     return ExcelLoaderWithParser;
 }
 /** Metadata-only worker loader for Excel files. */
-export const ExcelWorkerLoader = {
+export const ExcelLoader = {
     ...ExcelFormat,
     dataType: null,
     batchType: null,
     version: VERSION,
     worker: true,
+    serializeWorkerResult: serializeArrowWorkerResult,
+    deserializeWorkerResult: deserializeArrowWorkerResult,
     options: {
         excel: {
-            shape: 'object-row-table',
+            shape: 'arrow-table',
             sheet: undefined // Load default Sheet
         }
     },
     preload
 };
-/** Metadata-only loader for Excel files. */
-export const ExcelLoader = {
-    ...ExcelWorkerLoader,
-    preload
-};
+/** @deprecated Use ExcelLoader. */
+export const ExcelWorkerLoader = ExcelLoader;
 //# sourceMappingURL=excel-loader.js.map

package/dist/excel-loader.js.map

@@ -1 +1 @@
-{"version":3,"file":"excel-loader.js","sourceRoot":"","sources":["../src/excel-loader.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,WAAW,EAAC,0BAAuB;AAE3C,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,sBAAkB,KAAK,WAAW,CAAC,CAAC,iBAAa,CAAC,CAAC,QAAQ,CAAC;AAe5E,+DAA+D;AAC/D,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,qBAAqB,EAAC,GAAG,MAAM,MAAM,iCAA8B,CAAC;IAC3E,OAAO,qBAAqB,CAAC;AAC/B,CAAC;AAED,mDAAmD;AACnD,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,GAAG,WAAW;IACd,QAAQ,EAAE,IAA8C;IACxD,SAAS,EAAE,IAAa;IACxB,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,IAAI;IACZ,OAAO,EAAE;QACP,KAAK,EAAE;YACL,KAAK,EAAE,kBAAkB;YACzB,KAAK,EAAE,SAAS,CAAC,qBAAqB;SACvC;KACF;IACD,OAAO;CAC0E,CAAC;AAEpF,4CAA4C;AAC5C,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,GAAG,iBAAiB;IACpB,OAAO;CAC0E,CAAC"}
+{"version":3,"file":"excel-loader.js","sourceRoot":"","sources":["../src/excel-loader.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,WAAW,EAAC,0BAAuB;AAC3C,OAAO,EACL,4BAA4B,EAC5B,0BAA0B,EAC3B,MAAM,6BAA6B,CAAC;AAErC,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,sBAAkB,KAAK,WAAW,CAAC,CAAC,iBAAa,CAAC,CAAC,QAAQ,CAAC;AAe5E,+DAA+D;AAC/D,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,qBAAqB,EAAC,GAAG,MAAM,MAAM,iCAA8B,CAAC;IAC3E,OAAO,qBAAqB,CAAC;AAC/B,CAAC;AAED,mDAAmD;AACnD,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,GAAG,WAAW;IACd,QAAQ,EAAE,IAA8C;IACxD,SAAS,EAAE,IAAa;IACxB,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,IAAI;IACZ,qBAAqB,EAAE,0BAA0B;IACjD,uBAAuB,EAAE,4BAA4B;IACrD,OAAO,EAAE;QACP,KAAK,EAAE;YACL,KAAK,EAAE,aAAa;YACpB,KAAK,EAAE,SAAS,CAAC,qBAAqB;SACvC;KACF;IACD,OAAO;CAC0E,CAAC;AAEpF,mCAAmC;AACnC,MAAM,CAAC,MAAM,iBAAiB,GAAG,WAAW,CAAC"}

package/dist/excel-worker.js

@@ -26876,6 +26876,9 @@
     return { type: "null", nullable: true };
   }
   function getDataTypeFromTypedArray(array) {
+    if (typeof Float16Array !== "undefined" && array instanceof Float16Array) {
+      return "float16";
+    }
     switch (array.constructor) {
       case Int8Array:
         return "int8";
@@ -41852,6 +41855,13 @@ return true;`);
     if (isArrowViewType(arrowType, "Utf8View")) {
       return "utf8-view";
     }
+    if (isOptionalArrowType(arrowType, "LargeList")) {
+      const largeListType = arrowType;
+      return {
+        type: "large-list",
+        children: [serializeArrowField(largeListType.valueField)]
+      };
+    }
     switch (arrowType.constructor) {
       case Null2:
         return "null";
@@ -41990,12 +42000,6 @@ return true;`);
           type: "list",
           children: [serializeArrowField(listField)]
         };
-      case LargeList2:
-        const largeListType = arrowType;
-        return {
-          type: "large-list",
-          children: [serializeArrowField(largeListType.valueField)]
-        };
       case FixedSizeList2:
         const fixedSizeList = arrowType;
         return {
@@ -42048,7 +42052,13 @@ return true;`);
         }
         case "large-list": {
           const field = deserializeArrowField(dataType.children[0], options);
-          return new LargeList2(field);
+          const LargeList3 = getOptionalArrowConstructor("LargeList");
+          if (!LargeList3) {
+            throw new Error(
+              "LargeList requires an Apache Arrow runtime that exports the LargeList constructor"
+            );
+          }
+          return new LargeList3(field);
         }
         case "fixed-size-list": {
           const child = deserializeArrowField(dataType.children[0], options);
@@ -42144,11 +42154,11 @@ return true;`);
         throw new Error("array type not supported");
     }
   }
-  function getArrowViewConstructors() {
-    return Arrow_dom_exports;
+  function getOptionalArrowConstructor(typeName) {
+    return Arrow_dom_exports[typeName];
   }
   function isArrowViewType(arrowType, viewTypeName) {
-    const constructor = getArrowViewConstructors()[viewTypeName];
+    const constructor = getOptionalArrowConstructor(viewTypeName);
     if (constructor && arrowType instanceof constructor) {
       return true;
     }
@@ -42156,12 +42166,16 @@ return true;`);
     const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
     return Boolean(guard?.(arrowType));
   }
+  function isOptionalArrowType(arrowType, typeName) {
+    const constructor = getOptionalArrowConstructor(typeName);
+    return Boolean(constructor && arrowType instanceof constructor);
+  }
   function makeVariableWidthArrowType(viewTypeName, fallbackType, options) {
     const viewTypeMode = options?.viewTypes || "never";
     if (viewTypeMode === "never") {
       return fallbackType;
     }
-    const constructor = getArrowViewConstructors()[viewTypeName];
+    const constructor = getOptionalArrowConstructor(viewTypeName);
     if (constructor) {
       return new constructor();
     }
@@ -42173,7 +42187,7 @@ return true;`);
     return fallbackType;
   }
   function makeRequiredArrowViewType(viewTypeName) {
-    const constructor = getArrowViewConstructors()[viewTypeName];
+    const constructor = getOptionalArrowConstructor(viewTypeName);
     if (!constructor) {
       throw new Error(
         `${viewTypeName} requires apache-arrow 21.2.0 or later; the installed runtime does not support it`
@@ -42557,36 +42571,217 @@ return true;`);
     }
   });
 
+  // ../arrow/src/lib/utils/split-arrow-buffers.ts
+  function splitArrowBuffers(input, options = {}) {
+    if (isArrowTable2(input)) {
+      return splitArrowTableBuffersInternal(input, options);
+    }
+    if (isArrowRecordBatch2(input)) {
+      return splitArrowRecordBatchBuffers(input, options);
+    }
+    if (isArrowVector2(input)) {
+      return splitArrowVectorBuffers(input, options);
+    }
+    return splitArrowDataBuffers(input, options);
+  }
+  function isArrowTable2(input) {
+    return "batches" in input;
+  }
+  function isArrowRecordBatch2(input) {
+    return "schema" in input && "data" in input && !Array.isArray(input.data);
+  }
+  function isArrowVector2(input) {
+    return "data" in input && Array.isArray(input.data);
+  }
+  function splitArrowTableBuffersInternal(table, options) {
+    const recordBatches = table.batches.map(
+      (recordBatch) => splitArrowRecordBatchBuffers(recordBatch, options)
+    );
+    return new Table(table.schema, recordBatches);
+  }
+  function splitArrowRecordBatchBuffers(recordBatch, options) {
+    return new RecordBatch3(
+      recordBatch.schema,
+      splitArrowDataBuffers(recordBatch.data, options)
+    );
+  }
+  function splitArrowDataBuffers(data, options) {
+    const children = data.children.map((childData) => splitArrowDataBuffers(childData, options));
+    const dictionary = data.dictionary ? splitArrowVectorBuffers(data.dictionary, options) : void 0;
+    const buffers = {
+      [BufferType.OFFSET]: splitArrowBuffer(data.buffers[BufferType.OFFSET], options),
+      [BufferType.DATA]: splitArrowBuffer(data.buffers[BufferType.DATA], options),
+      [BufferType.VALIDITY]: splitArrowBuffer(data.buffers[BufferType.VALIDITY], options),
+      [BufferType.TYPE]: splitArrowBuffer(data.buffers[BufferType.TYPE], options)
+    };
+    return new Data(
+      data.type,
+      data.offset,
+      data.length,
+      // @ts-expect-error _nullCount is protected. Reuse it to preserve lazy null-count state.
+      data._nullCount,
+      buffers,
+      children,
+      dictionary
+    );
+  }
+  function splitArrowVectorBuffers(vector, options) {
+    return new Vector(vector.data.map((data) => splitArrowDataBuffers(data, options)));
+  }
+  function splitArrowBuffer(array, options) {
+    if (!isArrowTypedArray(array)) {
+      return array;
+    }
+    if (options.copy === "none") {
+      return array;
+    }
+    if (options.copy !== "all" && array.byteOffset === 0 && array.byteLength === array.buffer.byteLength) {
+      return array;
+    }
+    return array.slice();
+  }
+  function isArrowTypedArray(value) {
+    return ArrayBuffer.isView(value) && !(value instanceof DataView);
+  }
+  var init_split_arrow_buffers = __esm({
+    "../arrow/src/lib/utils/split-arrow-buffers.ts"() {
+      "use strict";
+      init_Arrow_dom();
+    }
+  });
+
+  // ../arrow/src/lib/utils/arrow-table-transport.ts
+  function dehydrateArrowTable(table, options) {
+    const splitTable = splitArrowBuffers(table, options);
+    return {
+      shape: "arrow-table",
+      transport: "arrow-js",
+      schema: serializeArrowSchema(splitTable.schema),
+      batches: splitTable.batches.map((recordBatch) => dehydrateArrowRecordBatch(recordBatch))
+    };
+  }
+  function hydrateArrowTable(table) {
+    const schema = deserializeArrowSchema(table.schema);
+    const recordBatches = table.batches.map(
+      (recordBatch) => new RecordBatch3(schema, hydrateArrowData(recordBatch.data))
+    );
+    return new Table(schema, recordBatches);
+  }
+  function serializeArrowWorkerResult(result, options) {
+    if (!isArrowTableWrapper(result)) {
+      return result;
+    }
+    const workerOptions = options;
+    const bufferCopyMode = workerOptions?.core?.workerTransferBufferCopy ?? workerOptions?.workerTransferBufferCopy;
+    return {
+      ...result,
+      data: dehydrateArrowTable(result.data, bufferCopyMode ? { copy: bufferCopyMode } : void 0)
+    };
+  }
+  function deserializeArrowWorkerResult(result) {
+    if (!isDehydratedArrowTableWrapper(result)) {
+      return result;
+    }
+    return { ...result, data: hydrateArrowTable(result.data) };
+  }
+  function isArrowTableWrapper(value) {
+    const table = value;
+    return Boolean(
+      table && table.shape === "arrow-table" && table.data && typeof table.data === "object" && "batches" in table.data
+    );
+  }
+  function isDehydratedArrowTableWrapper(value) {
+    const table = value;
+    return Boolean(
+      table && table.shape === "arrow-table" && table.data && table.data.transport === "arrow-js" && Array.isArray(table.data.batches)
+    );
+  }
+  function dehydrateArrowRecordBatch(recordBatch) {
+    return { data: dehydrateArrowData(recordBatch.data) };
+  }
+  function dehydrateArrowData(data) {
+    return {
+      type: serializeArrowType(data.type),
+      offset: data.offset,
+      length: data.length,
+      // @ts-expect-error _nullCount is protected. Preserve the Arrow lazy null-count state.
+      nullCount: data._nullCount,
+      buffers: {
+        [BufferType.OFFSET]: data.buffers[BufferType.OFFSET],
+        [BufferType.DATA]: data.buffers[BufferType.DATA],
+        [BufferType.VALIDITY]: data.buffers[BufferType.VALIDITY],
+        [BufferType.TYPE]: data.buffers[BufferType.TYPE]
+      },
+      children: data.children.map((childData) => dehydrateArrowData(childData)),
+      dictionary: data.dictionary ? dehydrateArrowVector(data.dictionary) : void 0
+    };
+  }
+  function dehydrateArrowVector(vector) {
+    return { data: vector.data.map((data) => dehydrateArrowData(data)) };
+  }
+  function hydrateArrowData(data) {
+    const children = data.children.map((childData) => hydrateArrowData(childData));
+    const dictionary = data.dictionary ? hydrateArrowVector(data.dictionary) : void 0;
+    return new Data(
+      deserializeArrowType(data.type),
+      data.offset,
+      data.length,
+      data.nullCount,
+      data.buffers,
+      children,
+      dictionary
+    );
+  }
+  function hydrateArrowVector(vector) {
+    return new Vector(vector.data.map((data) => hydrateArrowData(data)));
+  }
+  var init_arrow_table_transport = __esm({
+    "../arrow/src/lib/utils/arrow-table-transport.ts"() {
+      "use strict";
+      init_Arrow_dom();
+      init_src();
+      init_split_arrow_buffers();
+    }
+  });
+
+  // ../arrow/src/transport.ts
+  var init_transport = __esm({
+    "../arrow/src/transport.ts"() {
+      "use strict";
+      init_arrow_table_transport();
+    }
+  });
+
   // src/excel-loader.ts
   async function preload() {
     const { ExcelLoaderWithParser: ExcelLoaderWithParser2 } = await Promise.resolve().then(() => (init_excel_loader_with_parser(), excel_loader_with_parser_exports));
     return ExcelLoaderWithParser2;
   }
-  var VERSION, ExcelWorkerLoader, ExcelLoader;
+  var VERSION, ExcelLoader, ExcelWorkerLoader;
   var init_excel_loader = __esm({
     "src/excel-loader.ts"() {
       "use strict";
       init_excel_format();
-      VERSION = true ? "5.0.0-alpha.5" : "latest";
-      ExcelWorkerLoader = {
+      init_transport();
+      VERSION = true ? "5.0.0-alpha.7" : "latest";
+      ExcelLoader = {
         ...ExcelFormat,
         dataType: null,
         batchType: null,
         version: VERSION,
         worker: true,
+        serializeWorkerResult: serializeArrowWorkerResult,
+        deserializeWorkerResult: deserializeArrowWorkerResult,
         options: {
           excel: {
-            shape: "object-row-table",
+            shape: "arrow-table",
             sheet: void 0
             // Load default Sheet
           }
         },
         preload
       };
-      ExcelLoader = {
-        ...ExcelWorkerLoader,
-        preload
-      };
+      ExcelWorkerLoader = ExcelLoader;
     }
   });
 
@@ -42936,9 +43131,22 @@ return true;`);
   }
 
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
-  async function createLoaderWorker(loader) {
+  async function createLoaderWorker(loader, selectLoader = () => loader) {
     await createWorker(
-      (input, options, workerContext, loaderContext) => processLoaderWorkerData(loader, input, options, workerContext, loaderContext)
+      (input, options, workerContext, loaderContext) => processLoaderWorkerData(
+        selectLoader(options || {}),
+        input,
+        options,
+        workerContext,
+        loaderContext
+      ),
+      (inputIterator, options, workerContext, loaderContext) => processLoaderWorkerBatches(
+        selectLoader(options || {}),
+        inputIterator,
+        options,
+        workerContext,
+        loaderContext
+      )
     );
   }
   async function processLoaderWorkerData(loader, input, options = {}, workerContext, loaderContext = {}) {
@@ -42954,6 +43162,19 @@ return true;`);
     });
     return loader.serializeWorkerResult ? loader.serializeWorkerResult(result, options, loaderContext) : result;
   }
+  async function* processLoaderWorkerBatches(loader, inputIterator, options = {}, workerContext, loaderContext = {}) {
+    if (!loader.parseInBatches) {
+      throw new Error(`${loader.id} loader does not support batched parsing`);
+    }
+    const resultIterator = loader.parseInBatches(inputIterator, options, {
+      ...loaderContext,
+      coreApi: createWorkerCoreApi(),
+      _parse: createParseOnMainThread(workerContext?.process)
+    });
+    for await (const batch of resultIterator) {
+      yield loader.serializeWorkerBatch ? loader.serializeWorkerBatch(batch, options, loaderContext) : batch;
+    }
+  }
   function createWorkerCoreApi() {
     const unavailable = (methodName) => () => {
       throw new Error(`context.coreApi.${methodName} is unavailable inside worker loaders.`);