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

package/dist/index.cjs

@@ -5,8 +5,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+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)
@@ -84,18 +89,730 @@ var init_parse_excel = __esm({
   }
 });
 
+// ../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");
+    }
+  }
+  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 ? (0, import_schema_utils.makeTableFromData)(rows) : { shape: "object-row-table", schema: { fields: [], metadata: {} }, data: 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 arrow.Table(new arrow.Schema([]))
+      data: new arrow4.Table(new arrow4.Schema([]))
     };
   }
-  const arrowTableBuilder = new import_schema_utils.ArrowTableBuilder(schema);
+  const arrowTableBuilder = new ArrowTableBuilder(schema);
   for (const row of table.data) {
     arrowTableBuilder.addObjectRow(row);
   }
@@ -131,12 +848,12 @@ function getDataTypeFromPrimitive(value) {
       return value instanceof Date ? "date-millisecond" : "null";
   }
 }
-var import_schema_utils, arrow;
+var arrow4;
 var init_convert_excel_rows_to_arrow = __esm({
   "dist/lib/convert-excel-rows-to-arrow.js"() {
     "use strict";
-    import_schema_utils = require("@loaders.gl/schema-utils");
-    arrow = __toESM(require("apache-arrow"), 1);
+    init_src();
+    arrow4 = __toESM(require("apache-arrow"), 1);
   }
 });
 
@@ -187,7 +904,7 @@ var init_excel_loader = __esm({
   "dist/excel-loader.js"() {
     "use strict";
     init_excel_format();
-    VERSION = true ? "5.0.0-alpha.1" : "latest";
+    VERSION = true ? "5.0.0-alpha.2" : "latest";
     ExcelWorkerLoader = {
       ...ExcelFormat,
       dataType: null,
@@ -211,13 +928,13 @@ var init_excel_loader = __esm({
 });
 
 // dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
+var index_exports = {};
+__export(index_exports, {
   ExcelFormat: () => ExcelFormat,
   ExcelLoader: () => ExcelLoader,
   ExcelWorkerLoader: () => ExcelWorkerLoader
 });
-module.exports = __toCommonJS(dist_exports);
+module.exports = __toCommonJS(index_exports);
 init_excel_format();
 init_excel_loader();
 init_excel_loader();