@loaders.gl/core 5.0.0-alpha.12 → 5.0.0-alpha.13

package/dist/schema-utils/arrow-transport.cjs

@@ -0,0 +1,665 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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);
+
+// src/schema-utils/arrow-transport.ts
+var arrow_transport_exports = {};
+__export(arrow_transport_exports, {
+  dehydrateArrowTable: () => dehydrateArrowTable,
+  deserializeArrowTableFromIPC: () => deserializeArrowTableFromIPC,
+  deserializeArrowWorkerResult: () => deserializeArrowWorkerResult,
+  hydrateArrowTable: () => hydrateArrowTable,
+  serializeArrowTableToIPC: () => serializeArrowTableToIPC,
+  serializeArrowWorkerResult: () => serializeArrowWorkerResult,
+  splitArrowBuffers: () => splitArrowBuffers,
+  splitArrowTableBuffers: () => splitArrowTableBuffers
+});
+module.exports = __toCommonJS(arrow_transport_exports);
+
+// src/schema-utils/lib/arrow/arrow-table-transport.ts
+var arrow3 = __toESM(require("apache-arrow"), 1);
+
+// src/schema-utils/lib/schema/convert-arrow-schema.ts
+var arrow = __toESM(require("apache-arrow"), 1);
+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";
+  }
+  if (isOptionalArrowType(arrowType, "LargeList")) {
+    const largeListType = arrowType;
+    return {
+      type: "large-list",
+      children: [serializeArrowField(largeListType.valueField)]
+    };
+  }
+  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.SparseUnion:
+    case arrow.DenseUnion:
+      const unionType = arrowType;
+      return {
+        type: unionType instanceof arrow.DenseUnion ? "dense-union" : "sparse-union",
+        typeIds: unionType.typeIds,
+        children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
+        typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
+      };
+    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[0], dataType.keysSorted);
+      }
+      case "list": {
+        const field = deserializeArrowField(dataType.children[0], options);
+        return new arrow.List(field);
+      }
+      case "large-list": {
+        const field = deserializeArrowField(dataType.children[0], options);
+        const LargeList = getOptionalArrowConstructor("LargeList");
+        if (!LargeList) {
+          throw new Error(
+            "LargeList requires an Apache Arrow runtime that exports the LargeList constructor"
+          );
+        }
+        return new LargeList(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 "sparse-union":
+      case "dense-union": {
+        const children = dataType.children.map(
+          (arrowField) => deserializeArrowField(arrowField, options)
+        );
+        return dataType.type === "dense-union" ? new arrow.DenseUnion(dataType.typeIds, children) : new arrow.SparseUnion(dataType.typeIds, 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 getOptionalArrowConstructor(typeName) {
+  return arrow[typeName];
+}
+function isArrowViewType(arrowType, viewTypeName) {
+  const constructor = getOptionalArrowConstructor(viewTypeName);
+  if (constructor && arrowType instanceof constructor) {
+    return true;
+  }
+  const guards = arrow.DataType;
+  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 = getOptionalArrowConstructor(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 = getOptionalArrowConstructor(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}`);
+  }
+}
+
+// src/schema-utils/lib/arrow/split-arrow-buffers.ts
+var arrow2 = __toESM(require("apache-arrow"), 1);
+function splitArrowBuffers(input, options = {}) {
+  if (isArrowTable(input)) {
+    return splitArrowTableBuffersInternal(input, options);
+  }
+  if (isArrowRecordBatch(input)) {
+    return splitArrowRecordBatchBuffers(input, options);
+  }
+  if (isArrowVector(input)) {
+    return splitArrowVectorBuffers(input, options);
+  }
+  return splitArrowDataBuffers(input, options);
+}
+function splitArrowTableBuffers(table, options) {
+  return splitArrowTableBuffersInternal(table, options ?? {});
+}
+function isArrowTable(input) {
+  return "batches" in input;
+}
+function isArrowRecordBatch(input) {
+  return "schema" in input && "data" in input && !Array.isArray(input.data);
+}
+function isArrowVector(input) {
+  return "data" in input && Array.isArray(input.data);
+}
+function splitArrowTableBuffersInternal(table, options) {
+  const recordBatches = table.batches.map(
+    (recordBatch) => splitArrowRecordBatchBuffers(recordBatch, options)
+  );
+  return new arrow2.Table(table.schema, recordBatches);
+}
+function splitArrowRecordBatchBuffers(recordBatch, options) {
+  return new arrow2.RecordBatch(
+    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 = {
+    [arrow2.BufferType.OFFSET]: splitArrowBuffer(data.buffers[arrow2.BufferType.OFFSET], options),
+    [arrow2.BufferType.DATA]: splitArrowBuffer(data.buffers[arrow2.BufferType.DATA], options),
+    [arrow2.BufferType.VALIDITY]: splitArrowBuffer(data.buffers[arrow2.BufferType.VALIDITY], options),
+    [arrow2.BufferType.TYPE]: splitArrowBuffer(data.buffers[arrow2.BufferType.TYPE], options)
+  };
+  return new arrow2.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 arrow2.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);
+}
+
+// src/schema-utils/lib/arrow/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 arrow3.RecordBatch(schema, hydrateArrowData(recordBatch.data))
+  );
+  return new arrow3.Table(schema, recordBatches);
+}
+function serializeArrowTableToIPC(table) {
+  return {
+    shape: "arrow-table",
+    transport: "arrow-ipc",
+    data: arrow3.tableToIPC(table)
+  };
+}
+function deserializeArrowTableFromIPC(table) {
+  const data = isSerializedArrowTableIPC(table) ? table.data : table;
+  return arrow3.tableFromIPC(data);
+}
+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: {
+      [arrow3.BufferType.OFFSET]: data.buffers[arrow3.BufferType.OFFSET],
+      [arrow3.BufferType.DATA]: data.buffers[arrow3.BufferType.DATA],
+      [arrow3.BufferType.VALIDITY]: data.buffers[arrow3.BufferType.VALIDITY],
+      [arrow3.BufferType.TYPE]: data.buffers[arrow3.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 arrow3.Data(
+    deserializeArrowType(data.type),
+    data.offset,
+    data.length,
+    data.nullCount,
+    data.buffers,
+    children,
+    dictionary
+  );
+}
+function hydrateArrowVector(vector) {
+  return new arrow3.Vector(vector.data.map((data) => hydrateArrowData(data)));
+}
+function isSerializedArrowTableIPC(value) {
+  return Boolean(
+    value && typeof value === "object" && value.shape === "arrow-table" && value.transport === "arrow-ipc"
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dehydrateArrowTable,
+  deserializeArrowTableFromIPC,
+  deserializeArrowWorkerResult,
+  hydrateArrowTable,
+  serializeArrowTableToIPC,
+  serializeArrowWorkerResult,
+  splitArrowBuffers,
+  splitArrowTableBuffers
+});

package/dist/schema-utils/arrow-transport.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/schema-utils/arrow-transport.ts", "../../src/schema-utils/lib/arrow/arrow-table-transport.ts", "../../src/schema-utils/lib/schema/convert-arrow-schema.ts", "../../src/schema-utils/lib/arrow/split-arrow-buffers.ts"],
+  "mappings": "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",
+  "names": ["arrow", "arrow"]
+}

package/dist/schema-utils/arrow-transport.d.ts

@@ -0,0 +1,4 @@
+/** Transfer-safe Apache Arrow table serialization and buffer ownership helpers. */
+export * from "./lib/arrow/arrow-table-transport.js";
+export * from "./lib/arrow/split-arrow-buffers.js";
+//# sourceMappingURL=arrow-transport.d.ts.map

package/dist/schema-utils/arrow-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-transport.d.ts","sourceRoot":"","sources":["../../src/schema-utils/arrow-transport.ts"],"names":[],"mappings":"AAIA,mFAAmF;AACnF,qDAAkD;AAClD,mDAAgD"}