@loaders.gl/excel 4.4.5 → 5.0.0-alpha.2

package/dist/index.cjs

@@ -1,8 +1,18 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,34 +25,39 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
-  ExcelFormat: () => ExcelFormat,
-  ExcelLoader: () => ExcelLoader,
-  ExcelWorkerLoader: () => ExcelWorkerLoader
-});
-module.exports = __toCommonJS(dist_exports);
-
 // dist/excel-format.js
-var ExcelFormat = {
-  name: "Excel",
-  id: "excel",
-  module: "excel",
-  extensions: ["xls", "xlsb", "xlsm", "xlsx"],
-  mimeTypes: [
-    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    "application/vnd.ms-excel"
-  ],
-  category: "table",
-  binary: true
-};
+var ExcelFormat;
+var init_excel_format = __esm({
+  "dist/excel-format.js"() {
+    "use strict";
+    ExcelFormat = {
+      name: "Excel",
+      id: "excel",
+      module: "excel",
+      encoding: "zip",
+      format: "excel",
+      extensions: ["xls", "xlsb", "xlsm", "xlsx"],
+      mimeTypes: [
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "application/vnd.ms-excel"
+      ],
+      category: "table",
+      binary: true
+    };
+  }
+});
 
 // dist/lib/parse-excel.js
-var import_xlsx = require("xlsx");
-var dataTableNamesMap = {};
 function parseExcel(arrayBuffer, options) {
   var _a, _b, _c;
   const dataUrl = "dummy";
@@ -65,28 +80,862 @@ function parseExcel(arrayBuffer, options) {
   }
   return dataRows;
 }
+var import_xlsx, dataTableNamesMap;
+var init_parse_excel = __esm({
+  "dist/lib/parse-excel.js"() {
+    "use strict";
+    import_xlsx = require("xlsx");
+    dataTableNamesMap = {};
+  }
+});
 
-// dist/excel-loader.js
-var VERSION = true ? "4.4.5" : "latest";
-var ExcelWorkerLoader = {
-  ...ExcelFormat,
-  dataType: null,
-  batchType: null,
-  version: VERSION,
-  worker: true,
-  options: {
-    excel: {
-      shape: "object-row-table",
-      sheet: void 0
-      // Load default Sheet
+// ../schema-utils/src/lib/schema/data-type.ts
+function getDataTypeFromValue(value, defaultNumberType = "float32") {
+  if (value instanceof Date) {
+    return "date-millisecond";
+  }
+  if (typeof value === "number") {
+    return defaultNumberType;
+  }
+  if (typeof value === "boolean") {
+    return "bool";
+  }
+  if (typeof value === "string") {
+    return "utf8";
+  }
+  if (value === null || value === "undefined") {
+    return "null";
+  }
+  return "null";
+}
+function getDataTypeFromArray(array) {
+  let type = getDataTypeFromTypedArray(array);
+  if (type !== "null") {
+    return { type, nullable: false };
+  }
+  if (array.length > 0) {
+    type = getDataTypeFromValue(array[0]);
+    return { type, nullable: true };
+  }
+  return { type: "null", nullable: true };
+}
+function getDataTypeFromTypedArray(array) {
+  switch (array.constructor) {
+    case Int8Array:
+      return "int8";
+    case Uint8Array:
+    case Uint8ClampedArray:
+      return "uint8";
+    case Int16Array:
+      return "int16";
+    case Uint16Array:
+      return "uint16";
+    case Int32Array:
+      return "int32";
+    case Uint32Array:
+      return "uint32";
+    case Float32Array:
+      return "float32";
+    case Float64Array:
+      return "float64";
+    default:
+      return "null";
+  }
+}
+var init_data_type = __esm({
+  "../schema-utils/src/lib/schema/data-type.ts"() {
+    "use strict";
+  }
+});
+
+// ../schema-utils/src/lib/schema/convert-arrow-schema.ts
+function convertArrowToSchema(arrowSchema) {
+  return serializeArrowSchema(arrowSchema);
+}
+function convertSchemaToArrow(schema, options) {
+  return deserializeArrowSchema(schema, options);
+}
+function serializeArrowSchema(arrowSchema) {
+  return {
+    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+    metadata: serializeArrowMetadata(arrowSchema.metadata)
+  };
+}
+function deserializeArrowSchema(schema, options) {
+  return new arrow.Schema(
+    schema.fields.map((field) => deserializeArrowField(field, options)),
+    deserializeArrowMetadata(schema.metadata)
+  );
+}
+function serializeArrowMetadata(arrowMetadata) {
+  return Object.fromEntries(arrowMetadata);
+}
+function deserializeArrowMetadata(metadata) {
+  return metadata ? new Map(Object.entries(metadata)) : /* @__PURE__ */ new Map();
+}
+function serializeArrowField(field) {
+  return {
+    name: field.name,
+    type: serializeArrowType(field.type),
+    nullable: field.nullable,
+    metadata: serializeArrowMetadata(field.metadata)
+  };
+}
+function deserializeArrowField(field, options) {
+  return new arrow.Field(
+    field.name,
+    deserializeArrowType(field.type, options),
+    field.nullable,
+    deserializeArrowMetadata(field.metadata)
+  );
+}
+function serializeArrowType(arrowType) {
+  if (isArrowViewType(arrowType, "BinaryView")) {
+    return "binary-view";
+  }
+  if (isArrowViewType(arrowType, "Utf8View")) {
+    return "utf8-view";
+  }
+  switch (arrowType.constructor) {
+    case arrow.Null:
+      return "null";
+    case arrow.Binary:
+      return "binary";
+    case arrow.FixedSizeBinary:
+      return {
+        type: "fixed-size-binary",
+        byteWidth: arrowType.byteWidth
+      };
+    case arrow.Bool:
+      return "bool";
+    case arrow.Int:
+      const intType = arrowType;
+      return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Int64:
+      return "int64";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    case arrow.Uint64:
+      return "uint64";
+    case arrow.Float:
+      const precision = arrowType.precision;
+      switch (precision) {
+        case arrow.Precision.HALF:
+          return "float16";
+        case arrow.Precision.SINGLE:
+          return "float32";
+        case arrow.Precision.DOUBLE:
+          return "float64";
+        default:
+          return "float16";
+      }
+    case arrow.Float16:
+      return "float16";
+    case arrow.Float32:
+      return "float32";
+    case arrow.Float64:
+      return "float64";
+    case arrow.Utf8:
+      return "utf8";
+    case arrow.Decimal:
+      const decimal = arrowType;
+      return {
+        type: "decimal",
+        bitWidth: decimal.bitWidth,
+        precision: decimal.precision,
+        scale: decimal.scale
+      };
+    case arrow.Date_:
+      const dateUnit = arrowType.unit;
+      return dateUnit === arrow.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow.DateDay:
+      return "date-day";
+    case arrow.DateMillisecond:
+      return "date-millisecond";
+    case arrow.Time:
+      const timeUnit = arrowType.unit;
+      switch (timeUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "time-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "time-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "time-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "time-nanosecond";
+        default:
+          return "time-second";
+      }
+    case arrow.TimeMillisecond:
+      return "time-millisecond";
+    case arrow.TimeSecond:
+      return "time-second";
+    case arrow.TimeMicrosecond:
+      return "time-microsecond";
+    case arrow.TimeNanosecond:
+      return "time-nanosecond";
+    case arrow.Timestamp:
+      const timeStampUnit = arrowType.unit;
+      switch (timeStampUnit) {
+        case arrow.TimeUnit.SECOND:
+          return "timestamp-second";
+        case arrow.TimeUnit.MILLISECOND:
+          return "timestamp-millisecond";
+        case arrow.TimeUnit.MICROSECOND:
+          return "timestamp-microsecond";
+        case arrow.TimeUnit.NANOSECOND:
+          return "timestamp-nanosecond";
+        default:
+          return "timestamp-second";
+      }
+    case arrow.TimestampSecond:
+      return "timestamp-second";
+    case arrow.TimestampMillisecond:
+      return "timestamp-millisecond";
+    case arrow.TimestampMicrosecond:
+      return "timestamp-microsecond";
+    case arrow.TimestampNanosecond:
+      return "timestamp-nanosecond";
+    case arrow.Interval:
+      const intervalUnit = arrowType.unit;
+      switch (intervalUnit) {
+        case arrow.IntervalUnit.DAY_TIME:
+          return "interval-daytime";
+        case arrow.IntervalUnit.YEAR_MONTH:
+          return "interval-yearmonth";
+        default:
+          return "interval-daytime";
+      }
+    case arrow.IntervalDayTime:
+      return "interval-daytime";
+    case arrow.IntervalYearMonth:
+      return "interval-yearmonth";
+    case arrow.Map_:
+      const mapType = arrowType;
+      return {
+        type: "map",
+        keysSorted: mapType.keysSorted,
+        children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.List:
+      const listType = arrowType;
+      const listField = listType.valueField;
+      return {
+        type: "list",
+        children: [serializeArrowField(listField)]
+      };
+    case arrow.FixedSizeList:
+      const fixedSizeList = arrowType;
+      return {
+        type: "fixed-size-list",
+        listSize: fixedSizeList.listSize,
+        children: [serializeArrowField(fixedSizeList.children[0])]
+      };
+    case arrow.Struct:
+      const structType = arrowType;
+      return {
+        type: "struct",
+        children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+      };
+    case arrow.Dictionary:
+      const dictionaryType = arrowType;
+      return {
+        type: "dictionary",
+        id: dictionaryType.id,
+        indices: serializeArrowDictionaryKeyType(dictionaryType.indices),
+        dictionary: serializeArrowType(dictionaryType.dictionary),
+        isOrdered: dictionaryType.isOrdered
+      };
+    default:
+      throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function deserializeArrowType(dataType, options) {
+  if (typeof dataType === "object") {
+    switch (dataType.type) {
+      case "decimal":
+        return new arrow.Decimal(dataType.scale, dataType.precision, dataType.bitWidth);
+      case "map": {
+        const children = dataType.children.map(
+          (arrowField) => deserializeArrowField(arrowField, options)
+        );
+        return new arrow.Map_(children, dataType.keysSorted);
+      }
+      case "list": {
+        const field = deserializeArrowField(dataType.children[0], options);
+        return new arrow.List(field);
+      }
+      case "fixed-size-list": {
+        const child = deserializeArrowField(dataType.children[0], options);
+        return new arrow.FixedSizeList(dataType.listSize, child);
+      }
+      case "fixed-size-binary":
+        return new arrow.FixedSizeBinary(dataType.byteWidth);
+      case "struct": {
+        const children = dataType.children.map(
+          (arrowField) => deserializeArrowField(arrowField, options)
+        );
+        return new arrow.Struct(children);
+      }
+      case "dictionary": {
+        return new arrow.Dictionary(
+          deserializeArrowType(dataType.dictionary, options),
+          deserializeArrowDictionaryKeyType(dataType.indices),
+          dataType.id,
+          dataType.isOrdered
+        );
+      }
+      default:
+        throw new Error("array type not supported");
     }
   }
-};
-var ExcelLoader = {
-  ...ExcelWorkerLoader,
-  async parse(arrayBuffer, options) {
-    const data = parseExcel(arrayBuffer, options);
-    return { shape: "object-row-table", data };
+  switch (dataType) {
+    case "null":
+      return new arrow.Null();
+    case "binary":
+      return makeVariableWidthArrowType("BinaryView", new arrow.Binary(), options);
+    case "binary-view":
+      return makeRequiredArrowViewType("BinaryView");
+    case "bool":
+      return new arrow.Bool();
+    case "int8":
+      return new arrow.Int8();
+    case "int16":
+      return new arrow.Int16();
+    case "int32":
+      return new arrow.Int32();
+    case "int64":
+      return new arrow.Int64();
+    case "uint8":
+      return new arrow.Uint8();
+    case "uint16":
+      return new arrow.Uint16();
+    case "uint32":
+      return new arrow.Uint32();
+    case "uint64":
+      return new arrow.Uint64();
+    case "float16":
+      return new arrow.Float16();
+    case "float32":
+      return new arrow.Float32();
+    case "float64":
+      return new arrow.Float64();
+    case "utf8":
+      return makeVariableWidthArrowType("Utf8View", new arrow.Utf8(), options);
+    case "utf8-view":
+      return makeRequiredArrowViewType("Utf8View");
+    case "date-day":
+      return new arrow.DateDay();
+    case "date-millisecond":
+      return new arrow.DateMillisecond();
+    case "time-second":
+      return new arrow.TimeSecond();
+    case "time-millisecond":
+      return new arrow.TimeMillisecond();
+    case "time-microsecond":
+      return new arrow.TimeMicrosecond();
+    case "time-nanosecond":
+      return new arrow.TimeNanosecond();
+    case "timestamp-second":
+      return new arrow.TimestampSecond();
+    case "timestamp-millisecond":
+      return new arrow.TimestampMillisecond();
+    case "timestamp-microsecond":
+      return new arrow.TimestampMicrosecond();
+    case "timestamp-nanosecond":
+      return new arrow.TimestampNanosecond();
+    case "interval-daytime":
+      return new arrow.IntervalDayTime();
+    case "interval-yearmonth":
+      return new arrow.IntervalYearMonth();
+    default:
+      throw new Error("array type not supported");
   }
-};
+}
+function getArrowViewConstructors() {
+  return arrow;
+}
+function isArrowViewType(arrowType, viewTypeName) {
+  const constructor = getArrowViewConstructors()[viewTypeName];
+  if (constructor && arrowType instanceof constructor) {
+    return true;
+  }
+  const guards = arrow.DataType;
+  const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
+  return Boolean(guard == null ? void 0 : guard(arrowType));
+}
+function makeVariableWidthArrowType(viewTypeName, fallbackType, options) {
+  const viewTypeMode = (options == null ? void 0 : options.viewTypes) || "never";
+  if (viewTypeMode === "never") {
+    return fallbackType;
+  }
+  const constructor = getArrowViewConstructors()[viewTypeName];
+  if (constructor) {
+    return new constructor();
+  }
+  if (viewTypeMode === "require") {
+    throw new Error(
+      `${viewTypeName} requires apache-arrow 21.2.0 or later; the installed runtime does not support it`
+    );
+  }
+  return fallbackType;
+}
+function makeRequiredArrowViewType(viewTypeName) {
+  const constructor = getArrowViewConstructors()[viewTypeName];
+  if (!constructor) {
+    throw new Error(
+      `${viewTypeName} requires apache-arrow 21.2.0 or later; the installed runtime does not support it`
+    );
+  }
+  return new constructor();
+}
+function serializeArrowDictionaryKeyType(arrowType) {
+  if (arrowType instanceof arrow.Int) {
+    const prefix = arrowType.isSigned ? "int" : "uint";
+    const keyType = `${prefix}${arrowType.bitWidth}`;
+    if (isSchemaDictionaryKeyType(keyType)) {
+      return keyType;
+    }
+  }
+  switch (arrowType.constructor) {
+    case arrow.Int8:
+      return "int8";
+    case arrow.Int16:
+      return "int16";
+    case arrow.Int32:
+      return "int32";
+    case arrow.Uint8:
+      return "uint8";
+    case arrow.Uint16:
+      return "uint16";
+    case arrow.Uint32:
+      return "uint32";
+    default:
+      throw new Error(`arrow dictionary index type not supported: ${arrowType.constructor.name}`);
+  }
+}
+function isSchemaDictionaryKeyType(keyType) {
+  return ["int8", "int16", "int32", "uint8", "uint16", "uint32"].includes(keyType);
+}
+function deserializeArrowDictionaryKeyType(keyType) {
+  switch (keyType) {
+    case "int8":
+      return new arrow.Int8();
+    case "int16":
+      return new arrow.Int16();
+    case "int32":
+      return new arrow.Int32();
+    case "uint8":
+      return new arrow.Uint8();
+    case "uint16":
+      return new arrow.Uint16();
+    case "uint32":
+      return new arrow.Uint32();
+    default:
+      throw new Error(`schema dictionary index type not supported: ${keyType}`);
+  }
+}
+var arrow;
+var init_convert_arrow_schema = __esm({
+  "../schema-utils/src/lib/schema/convert-arrow-schema.ts"() {
+    "use strict";
+    arrow = __toESM(require("apache-arrow"), 1);
+  }
+});
+
+// ../schema-utils/src/lib/schema/deduce-table-schema.ts
+function deduceTableSchema(table) {
+  switch (table.shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return deduceSchemaFromRows(table.data);
+    case "geojson-table":
+      return deduceSchemaFromGeoJSON(table.features);
+    case "columnar-table":
+      return deduceSchemaFromColumns(table.data);
+    case "arrow-table":
+    default:
+      throw new Error("Deduce schema");
+  }
+}
+function deduceSchemaFromColumns(columnarTable) {
+  const fields = [];
+  for (const [columnName, column] of Object.entries(columnarTable)) {
+    const field = deduceFieldFromColumn(column, columnName);
+    fields.push(field);
+  }
+  return { fields, metadata: {} };
+}
+function deduceSchemaFromRows(rowTable) {
+  if (!rowTable.length) {
+    throw new Error("deduce from empty table");
+  }
+  const fields = [];
+  const row0 = rowTable[0];
+  for (const [columnName, value] of Object.entries(row0)) {
+    fields.push(deduceFieldFromValue(value, columnName));
+  }
+  return { fields, metadata: {} };
+}
+function deduceSchemaFromGeoJSON(features) {
+  if (!features.length) {
+    throw new Error("deduce from empty table");
+  }
+  const fields = [];
+  const row0 = features[0].properties || {};
+  for (const [columnName, value] of Object.entries(row0)) {
+    fields.push(deduceFieldFromValue(value, columnName));
+  }
+  return { fields, metadata: {} };
+}
+function deduceFieldFromColumn(column, name) {
+  if (ArrayBuffer.isView(column)) {
+    const type = getDataTypeFromArray(column);
+    return {
+      name,
+      type: type.type || "null",
+      nullable: type.nullable
+      // metadata: {}
+    };
+  }
+  if (Array.isArray(column) && column.length > 0) {
+    const value = column[0];
+    const type = getDataTypeFromValue(value);
+    return {
+      name,
+      type,
+      nullable: true
+      // metadata: {},
+    };
+  }
+  throw new Error("empty table");
+}
+function deduceFieldFromValue(value, name) {
+  const type = getDataTypeFromValue(value);
+  return {
+    name,
+    type,
+    nullable: true
+    // metadata: {}
+  };
+}
+var init_deduce_table_schema = __esm({
+  "../schema-utils/src/lib/schema/deduce-table-schema.ts"() {
+    "use strict";
+    init_data_type();
+  }
+});
+
+// ../schema-utils/src/lib/table/tables/make-table.ts
+function makeTableFromData(data) {
+  let table;
+  switch (getTableShapeFromData(data)) {
+    case "array-row-table":
+      table = { shape: "array-row-table", data };
+      break;
+    case "object-row-table":
+      table = { shape: "object-row-table", data };
+      break;
+    case "columnar-table":
+      table = { shape: "columnar-table", data };
+      break;
+    case "arrow-table":
+      table = { shape: "arrow-table", data };
+      break;
+    default:
+      throw new Error("table");
+  }
+  const schema = deduceTableSchema(table);
+  return { ...table, schema };
+}
+function getTableShapeFromData(data) {
+  if (data instanceof arrow2.Table) {
+    return "arrow-table";
+  }
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      throw new Error("cannot deduce type of empty table");
+    }
+    const firstRow = data[0];
+    if (Array.isArray(firstRow)) {
+      return "array-row-table";
+    }
+    if (firstRow && typeof firstRow === "object") {
+      return "object-row-table";
+    }
+  }
+  if (data && typeof data === "object") {
+    return "columnar-table";
+  }
+  throw new Error("invalid table");
+}
+var arrow2;
+var init_make_table = __esm({
+  "../schema-utils/src/lib/table/tables/make-table.ts"() {
+    "use strict";
+    arrow2 = __toESM(require("apache-arrow"), 1);
+    init_deduce_table_schema();
+  }
+});
+
+// ../schema-utils/src/lib/table/batch-builder/arrow-table-builder.ts
+var arrow3, ArrowTableBuilder;
+var init_arrow_table_builder = __esm({
+  "../schema-utils/src/lib/table/batch-builder/arrow-table-builder.ts"() {
+    "use strict";
+    arrow3 = __toESM(require("apache-arrow"), 1);
+    init_src();
+    ArrowTableBuilder = class {
+      schema;
+      arrowSchema;
+      arrowBuilders;
+      length;
+      constructor(schema, options) {
+        this.arrowSchema = convertSchemaToArrow(schema, options);
+        this.schema = (options == null ? void 0 : options.viewTypes) && options.viewTypes !== "never" ? convertArrowToSchema(this.arrowSchema) : schema;
+        this.arrowBuilders = this.arrowSchema.fields.map(
+          (field) => arrow3.makeBuilder({ type: field.type, nullValues: [null] })
+        );
+        this.length = 0;
+      }
+      addObjectRow(row) {
+        for (let i = 0; i < this.arrowBuilders.length; i++) {
+          const columnName = this.schema.fields[i].name;
+          const value = row[columnName];
+          this.arrowBuilders[i].append(value);
+        }
+        this.length++;
+      }
+      addArrayRow(row) {
+        for (let i = 0; i < this.arrowBuilders.length; i++) {
+          this.arrowBuilders[i].append(row[i]);
+        }
+        this.length++;
+      }
+      /** Makes sure that a first batch with schema is sent even if no rows */
+      firstBatch() {
+        const arrowRecordBatch = this._getArrowRecordBatch();
+        if (arrowRecordBatch.numCols !== 0) {
+          return null;
+        }
+        return {
+          shape: "arrow-table",
+          batchType: "data",
+          length: arrowRecordBatch.numRows,
+          schema: this.schema,
+          data: new arrow3.Table(arrowRecordBatch)
+        };
+      }
+      /** Flush the current batch if conditions are right */
+      flushBatch() {
+        const arrowRecordBatch = this._getArrowRecordBatch();
+        if (arrowRecordBatch.numCols === 0) {
+          return null;
+        }
+        return {
+          shape: "arrow-table",
+          batchType: "data",
+          length: arrowRecordBatch.numRows,
+          schema: this.schema,
+          data: new arrow3.Table(arrowRecordBatch)
+        };
+      }
+      /** Get a last batch if any data is left */
+      finishBatch() {
+        const arrowRecordBatch = this._getArrowRecordBatch();
+        this.arrowBuilders.forEach((builder) => builder.finish());
+        if (arrowRecordBatch.numCols === 0) {
+          return null;
+        }
+        return {
+          shape: "arrow-table",
+          batchType: "data",
+          length: arrowRecordBatch.numRows,
+          schema: this.schema,
+          data: new arrow3.Table(arrowRecordBatch)
+        };
+      }
+      /** Return a table with all the accumulated data */
+      finishTable() {
+        const arrowRecordBatch = this._getArrowRecordBatch();
+        this.arrowBuilders.forEach((builder) => builder.finish());
+        return {
+          shape: "arrow-table",
+          schema: this.schema,
+          data: new arrow3.Table(arrowRecordBatch)
+        };
+      }
+      /** Extract a record batch flushing the currently accumulated data in the builders */
+      _getArrowRecordBatch() {
+        var _a;
+        const { arrowBuilders, arrowSchema } = this;
+        const arrowDatas = arrowBuilders.map((builder) => builder.flush());
+        const length = ((_a = arrowDatas[0]) == null ? void 0 : _a.length) || this.length;
+        this.length = 0;
+        const structField = new arrow3.Struct(arrowSchema.fields);
+        const arrowStructData = new arrow3.Data(structField, 0, length, 0, void 0, arrowDatas);
+        const arrowRecordBatch = new arrow3.RecordBatch(arrowSchema, arrowStructData);
+        return arrowRecordBatch;
+      }
+    };
+  }
+});
+
+// ../schema-utils/src/index.ts
+var init_src = __esm({
+  "../schema-utils/src/index.ts"() {
+    "use strict";
+    init_convert_arrow_schema();
+    init_make_table();
+    init_arrow_table_builder();
+  }
+});
+
+// dist/lib/convert-excel-rows-to-arrow.js
+function convertExcelRowsToArrowTable(rows) {
+  const table = rows.length > 0 ? makeTableFromData(rows) : { shape: "object-row-table", schema: { fields: [], metadata: {} }, data: rows };
+  const schema = deducePrimitiveAwareSchema(table);
+  if (table.data.length === 0 || schema.fields.length === 0) {
+    return {
+      shape: "arrow-table",
+      schema,
+      data: new arrow4.Table(new arrow4.Schema([]))
+    };
+  }
+  const arrowTableBuilder = new ArrowTableBuilder(schema);
+  for (const row of table.data) {
+    arrowTableBuilder.addObjectRow(row);
+  }
+  return arrowTableBuilder.finishTable();
+}
+function deducePrimitiveAwareSchema(table) {
+  const fields = table.schema.fields.map((field) => {
+    if (field.type === "float32") {
+      return { ...field, type: "float64" };
+    }
+    if (field.type !== "null") {
+      return field;
+    }
+    for (const row of table.data) {
+      const type = getDataTypeFromPrimitive(row[field.name]);
+      if (type !== "null") {
+        return { ...field, type };
+      }
+    }
+    return field;
+  });
+  return { ...table.schema, fields };
+}
+function getDataTypeFromPrimitive(value) {
+  switch (typeof value) {
+    case "number":
+      return "float64";
+    case "boolean":
+      return "bool";
+    case "string":
+      return "utf8";
+    default:
+      return value instanceof Date ? "date-millisecond" : "null";
+  }
+}
+var arrow4;
+var init_convert_excel_rows_to_arrow = __esm({
+  "dist/lib/convert-excel-rows-to-arrow.js"() {
+    "use strict";
+    init_src();
+    arrow4 = __toESM(require("apache-arrow"), 1);
+  }
+});
+
+// dist/excel-loader-with-parser.js
+var excel_loader_with_parser_exports = {};
+__export(excel_loader_with_parser_exports, {
+  ExcelLoaderWithParser: () => ExcelLoaderWithParser,
+  ExcelWorkerLoaderWithParser: () => ExcelWorkerLoaderWithParser
+});
+var _ExcelWorkerLoaderPreload, ExcelWorkerLoaderMetadataWithoutPreload, _ExcelLoaderPreload, ExcelLoaderMetadataWithoutPreload, ExcelWorkerLoaderWithParser, ExcelLoaderWithParser;
+var init_excel_loader_with_parser = __esm({
+  "dist/excel-loader-with-parser.js"() {
+    "use strict";
+    init_parse_excel();
+    init_convert_excel_rows_to_arrow();
+    init_excel_loader();
+    init_excel_loader();
+    ({ preload: _ExcelWorkerLoaderPreload, ...ExcelWorkerLoaderMetadataWithoutPreload } = ExcelWorkerLoader);
+    ({ preload: _ExcelLoaderPreload, ...ExcelLoaderMetadataWithoutPreload } = ExcelLoader);
+    ExcelWorkerLoaderWithParser = {
+      ...ExcelWorkerLoaderMetadataWithoutPreload
+    };
+    ExcelLoaderWithParser = {
+      ...ExcelLoaderMetadataWithoutPreload,
+      async parse(arrayBuffer, options) {
+        var _a;
+        const excelOptions = {
+          ...options,
+          excel: { ...ExcelLoaderWithParser.options.excel, ...options == null ? void 0 : options.excel }
+        };
+        const rows = parseExcel(arrayBuffer, excelOptions);
+        if (((_a = excelOptions.excel) == null ? void 0 : _a.shape) === "arrow-table") {
+          return convertExcelRowsToArrowTable(rows);
+        }
+        return { shape: "object-row-table", data: rows };
+      }
+    };
+  }
+});
+
+// dist/excel-loader.js
+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 init_excel_loader = __esm({
+  "dist/excel-loader.js"() {
+    "use strict";
+    init_excel_format();
+    VERSION = true ? "5.0.0-alpha.2" : "latest";
+    ExcelWorkerLoader = {
+      ...ExcelFormat,
+      dataType: null,
+      batchType: null,
+      version: VERSION,
+      worker: true,
+      options: {
+        excel: {
+          shape: "object-row-table",
+          sheet: void 0
+          // Load default Sheet
+        }
+      },
+      preload
+    };
+    ExcelLoader = {
+      ...ExcelWorkerLoader,
+      preload
+    };
+  }
+});
+
+// dist/index.js
+var index_exports = {};
+__export(index_exports, {
+  ExcelFormat: () => ExcelFormat,
+  ExcelLoader: () => ExcelLoader,
+  ExcelWorkerLoader: () => ExcelWorkerLoader
+});
+module.exports = __toCommonJS(index_exports);
+init_excel_format();
+init_excel_loader();
+init_excel_loader();
 //# sourceMappingURL=index.cjs.map