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

package/dist/schema-utils/index.cjs

@@ -0,0 +1,3423 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ArrowLikeDataType: () => DataType3,
+  ArrowLikeField: () => ArrowLikeField,
+  ArrowLikeSchema: () => ArrowLikeSchema,
+  ArrowLikeTable: () => ArrowLikeTable,
+  ArrowTableBuilder: () => ArrowTableBuilder,
+  AsyncQueue: () => AsyncQueue,
+  ColumnarTableBatchAggregator: () => ColumnarTableBatchAggregator,
+  PointCloudTiler: () => PointCloudTiler,
+  RowTableBatchAggregator: () => RowTableBatchAggregator,
+  TABLE_CONVERTERS: () => TABLE_CONVERTERS,
+  TableBatchBuilder: () => TableBatchBuilder,
+  TableConverter: () => TableConverter,
+  convert: () => convert,
+  convertArrowToSchema: () => convertArrowToSchema,
+  convertArrowToTable: () => convertArrowToTable2,
+  convertBatch: () => convertBatch,
+  convertBatches: () => convertBatches,
+  convertMeshToTable: () => convertMeshToTable,
+  convertSchemaToArrow: () => convertSchemaToArrow,
+  convertTable: () => convertTable2,
+  convertTableToArrow: () => convertTableToArrow2,
+  convertTableToMesh: () => convertTableToMesh,
+  convertToArrayRow: () => convertToArrayRow2,
+  convertToObjectRow: () => convertToObjectRow2,
+  deduceMeshField: () => deduceMeshField,
+  deduceMeshSchema: () => deduceMeshSchema,
+  deduceTableSchema: () => deduceTableSchema,
+  deserializeArrowField: () => deserializeArrowField,
+  deserializeArrowMetadata: () => deserializeArrowMetadata,
+  deserializeArrowSchema: () => deserializeArrowSchema,
+  deserializeArrowType: () => deserializeArrowType,
+  getArrayTypeFromDataType: () => getArrayTypeFromDataType,
+  getArrowViewTypeSupport: () => getArrowViewTypeSupport,
+  getDataTypeFromArray: () => getDataTypeFromArray,
+  getMeshBoundingBox: () => getMeshBoundingBox,
+  getMeshSize: () => getMeshSize,
+  getTableCell: () => getTableCell,
+  getTableCellAt: () => getTableCellAt,
+  getTableColumnIndex: () => getTableColumnIndex,
+  getTableColumnName: () => getTableColumnName,
+  getTableLength: () => getTableLength,
+  getTableNumCols: () => getTableNumCols,
+  getTableRowAsArray: () => getTableRowAsArray,
+  getTableRowAsObject: () => getTableRowAsObject,
+  getTableRowShape: () => getTableRowShape,
+  getTypeInfo: () => getTypeInfo,
+  isArrayRowTable: () => isArrayRowTable,
+  isArrowTable: () => isArrowTable,
+  isColumnarTable: () => isColumnarTable,
+  isGeoJSONTable: () => isGeoJSONTable,
+  isObjectRowTable: () => isObjectRowTable,
+  isTable: () => isTable,
+  makeArrayRowIterator: () => makeArrayRowIterator,
+  makeArrowRecordBatchIterator: () => makeArrowRecordBatchIterator,
+  makeArrowTableBatchIterator: () => makeArrowTableBatchIterator,
+  makeBatchFromTable: () => makeBatchFromTable,
+  makeMeshArrowTable: () => makeMeshArrowTable,
+  makeMeshAttributeMetadata: () => makeMeshAttributeMetadata,
+  makeObjectRowIterator: () => makeObjectRowIterator,
+  makeRowIterator: () => makeRowIterator,
+  makeTableBatchIterator: () => makeTableBatchIterator,
+  makeTableFromBatches: () => makeTableFromBatches,
+  makeTableFromData: () => makeTableFromData,
+  queryArrowTable: () => queryArrowTable,
+  selectArrowTableRows: () => selectArrowTableRows,
+  serializeArrowField: () => serializeArrowField,
+  serializeArrowMetadata: () => serializeArrowMetadata,
+  serializeArrowSchema: () => serializeArrowSchema,
+  serializeArrowType: () => serializeArrowType
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/schema-utils/lib/schema/data-type.ts
+var import_types = require("@math.gl/core/types");
+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) {
+  if (typeof Float16Array !== "undefined" && array instanceof Float16Array) {
+    return "float16";
+  }
+  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 BigInt64Array:
+      return "int64";
+    case BigUint64Array:
+      return "uint64";
+    case Float32Array:
+      return "float32";
+    case Float64Array:
+      return "float64";
+    default:
+      return "null";
+  }
+}
+function getArrayTypeFromDataType(type, nullable) {
+  if (!nullable) {
+    switch (type) {
+      case "int8":
+        return Int8Array;
+      case "uint8":
+        return Uint8Array;
+      case "int16":
+        return Int16Array;
+      case "uint16":
+        return Uint16Array;
+      case "int32":
+        return Int32Array;
+      case "uint32":
+        return Uint32Array;
+      case "float32":
+        return Float32Array;
+      case "float64":
+        return Float64Array;
+      case "float16":
+        return (0, import_types.getFloat16ArrayConstructor)();
+      default:
+        break;
+    }
+  }
+  return Array;
+}
+
+// src/schema-utils/lib/converters/convert.ts
+function convert(input, targetShape, converters, options) {
+  const normalizedConverters = Array.isArray(converters) ? converters : [converters];
+  const sourceShape = detectSourceShape(input, normalizedConverters);
+  if (sourceShape === targetShape) {
+    return input;
+  }
+  const steps = findConversionPath(sourceShape, targetShape, normalizedConverters);
+  if (!steps) {
+    throw new Error(
+      `No conversion path found from "${sourceShape}" to "${targetShape}" using converters: ${normalizedConverters.map((converter) => converter.id).join(", ")}`
+    );
+  }
+  let currentValue = input;
+  let currentShape = sourceShape;
+  const path = [sourceShape, ...steps.map((step) => step.shape)];
+  for (let stepIndex = 0; stepIndex < steps.length; stepIndex++) {
+    const step = steps[stepIndex];
+    const context = {
+      sourceShape,
+      targetShape,
+      currentShape,
+      path,
+      converters: normalizedConverters,
+      stepIndex
+    };
+    currentValue = step.converter.convert(currentValue, step.shape, options, context);
+    currentShape = step.shape;
+  }
+  return currentValue;
+}
+function detectSourceShape(input, converters) {
+  const detectedShapes = /* @__PURE__ */ new Set();
+  const fallbackShape = getShapeFromInput(input);
+  if (fallbackShape !== null) {
+    detectedShapes.add(fallbackShape);
+  }
+  for (const converter of converters) {
+    const detectedShape = converter.detectInputShape?.(input);
+    if (detectedShape) {
+      detectedShapes.add(detectedShape);
+    }
+  }
+  if (detectedShapes.size === 0) {
+    throw new Error("Could not detect source shape for conversion input");
+  }
+  if (detectedShapes.size > 1) {
+    throw new Error(
+      `Ambiguous source shape for conversion input: ${Array.from(detectedShapes).join(", ")}`
+    );
+  }
+  return Array.from(detectedShapes)[0];
+}
+function getShapeFromInput(input) {
+  return typeof input === "object" && input !== null && "shape" in input && typeof input.shape === "string" ? input.shape : null;
+}
+function findConversionPath(sourceShape, targetShape, converters) {
+  const queue = [
+    { shape: sourceShape, path: [] }
+  ];
+  const visitedShapes = /* @__PURE__ */ new Set([sourceShape]);
+  while (queue.length > 0) {
+    const candidate = queue.shift();
+    for (const converter of converters) {
+      if (!converter.from.includes(candidate.shape)) {
+        continue;
+      }
+      for (const nextShape of converter.to) {
+        if (!converter.canConvert?.(candidate.shape, nextShape) && converter.canConvert !== void 0) {
+          continue;
+        }
+        const nextPath = [...candidate.path, { shape: nextShape, converter }];
+        if (nextShape === targetShape) {
+          return nextPath;
+        }
+        if (!visitedShapes.has(nextShape)) {
+          visitedShapes.add(nextShape);
+          queue.push({ shape: nextShape, path: nextPath });
+        }
+      }
+    }
+  }
+  return null;
+}
+
+// src/schema-utils/lib/schema/convert-arrow-schema.ts
+var arrow = __toESM(require("apache-arrow"), 1);
+function getArrowViewTypeSupport() {
+  return {
+    binaryView: typeof getOptionalArrowConstructor("BinaryView") === "function",
+    utf8View: typeof getOptionalArrowConstructor("Utf8View") === "function"
+  };
+}
+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";
+  }
+  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/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: {}
+  };
+}
+
+// src/schema-utils/lib/table/tables/make-table.ts
+var arrow2 = __toESM(require("apache-arrow"), 1);
+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");
+}
+
+// src/schema-utils/lib/table/tables/table-accessors.ts
+function isTable(table) {
+  const shape = typeof table === "object" && table?.shape;
+  switch (shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return Array.isArray(table.data);
+    case "geojson-table":
+      return Array.isArray(table.features);
+    case "columnar-table":
+      return Boolean(table.data && typeof table.data === "object");
+    case "arrow-table":
+      return Boolean(table?.data?.numRows !== void 0);
+    default:
+      return false;
+  }
+}
+function getTableLength(table) {
+  switch (table.shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return table.data.length;
+    case "geojson-table":
+      return table.features.length;
+    case "arrow-table":
+      const arrowTable = table.data;
+      return arrowTable.numRows;
+    case "columnar-table":
+      for (const column of Object.values(table.data)) {
+        return column.length || 0;
+      }
+      return 0;
+    default:
+      throw new Error("table");
+  }
+}
+function getTableNumCols(table) {
+  if (table.schema) {
+    return table.schema.fields.length;
+  }
+  if (getTableLength(table) === 0) {
+    throw new Error("empty table");
+  }
+  switch (table.shape) {
+    case "array-row-table":
+      return table.data[0].length;
+    case "object-row-table":
+      return Object.keys(table.data[0]).length;
+    case "geojson-table":
+      return Object.keys(table.features[0]).length;
+    case "columnar-table":
+      return Object.keys(table.data).length;
+    case "arrow-table":
+      const arrowTable = table.data;
+      return arrowTable.numCols;
+    default:
+      throw new Error("table");
+  }
+}
+function getTableCell(table, rowIndex, columnName) {
+  switch (table.shape) {
+    case "array-row-table":
+      const columnIndex = getTableColumnIndex(table, columnName);
+      return table.data[rowIndex][columnIndex];
+    case "object-row-table":
+      return table.data[rowIndex][columnName];
+    case "geojson-table":
+      return table.features[rowIndex][columnName];
+    case "columnar-table":
+      const column = table.data[columnName];
+      return column[rowIndex];
+    case "arrow-table":
+      const arrowTable = table.data;
+      const arrowColumnIndex = arrowTable.schema.fields.findIndex(
+        (field) => field.name === columnName
+      );
+      return arrowTable.getChildAt(arrowColumnIndex)?.get(rowIndex);
+    default:
+      throw new Error("todo");
+  }
+}
+function getTableCellAt(table, rowIndex, columnIndex) {
+  switch (table.shape) {
+    case "array-row-table":
+      return table.data[rowIndex][columnIndex];
+    case "object-row-table":
+      const columnName1 = getTableColumnName(table, columnIndex);
+      return table.data[rowIndex][columnName1];
+    case "geojson-table":
+      const columnName2 = getTableColumnName(table, columnIndex);
+      return table.features[rowIndex][columnName2];
+    case "columnar-table":
+      const columnName3 = getTableColumnName(table, columnIndex);
+      const column = table.data[columnName3];
+      return column[rowIndex];
+    case "arrow-table":
+      const arrowTable = table.data;
+      return arrowTable.getChildAt(columnIndex)?.get(rowIndex);
+    default:
+      throw new Error("todo");
+  }
+}
+function getTableRowShape(table) {
+  switch (table.shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return table.shape;
+    case "geojson-table":
+      return "object-row-table";
+    case "columnar-table":
+    default:
+      throw new Error("Not a row table");
+  }
+}
+function getTableColumnIndex(table, columnName) {
+  const columnIndex = table.schema?.fields.findIndex((field) => field.name === columnName);
+  if (columnIndex === void 0) {
+    throw new Error(columnName);
+  }
+  return columnIndex;
+}
+function getTableColumnName(table, columnIndex) {
+  const columnName = table.schema?.fields[columnIndex]?.name;
+  if (!columnName) {
+    throw new Error(`${columnIndex}`);
+  }
+  return columnName;
+}
+function getTableRowAsObject(table, rowIndex, target, copy) {
+  switch (table.shape) {
+    case "object-row-table":
+      return copy ? Object.fromEntries(Object.entries(table.data[rowIndex])) : table.data[rowIndex];
+    case "array-row-table":
+      if (table.schema) {
+        const objectRow2 = target || {};
+        for (let i = 0; i < table.schema.fields.length; i++) {
+          objectRow2[table.schema.fields[i].name] = table.data[rowIndex][i];
+        }
+        return objectRow2;
+      }
+      throw new Error("no schema");
+    case "geojson-table":
+      if (table.schema) {
+        const objectRow2 = target || {};
+        for (let i = 0; i < table.schema.fields.length; i++) {
+          objectRow2[table.schema.fields[i].name] = table.features[rowIndex][table.schema.fields[i].name];
+        }
+        return objectRow2;
+      }
+      throw new Error("no schema");
+    case "columnar-table":
+      if (table.schema) {
+        const objectRow2 = target || {};
+        for (let i = 0; i < table.schema.fields.length; i++) {
+          objectRow2[table.schema.fields[i].name] = table.data[table.schema.fields[i].name][rowIndex];
+        }
+        return objectRow2;
+      } else {
+        const objectRow2 = target || {};
+        for (const [name, column] of Object.entries(table.data)) {
+          objectRow2[name] = column[rowIndex];
+        }
+        return objectRow2;
+      }
+    case "arrow-table":
+      const arrowTable = table.data;
+      const objectRow = target || {};
+      const row = arrowTable.get(rowIndex);
+      const schema = arrowTable.schema;
+      for (let i = 0; i < schema.fields.length; i++) {
+        objectRow[schema.fields[i].name] = row?.[schema.fields[i].name];
+      }
+      return objectRow;
+    default:
+      throw new Error("shape");
+  }
+}
+function getTableRowAsArray(table, rowIndex, target, copy) {
+  switch (table.shape) {
+    case "array-row-table":
+      return copy ? Array.from(table.data[rowIndex]) : table.data[rowIndex];
+    case "object-row-table":
+      if (table.schema) {
+        const arrayRow2 = target || [];
+        for (let i = 0; i < table.schema.fields.length; i++) {
+          arrayRow2[i] = table.data[rowIndex][table.schema.fields[i].name];
+        }
+        return arrayRow2;
+      }
+      return Object.values(table.data[rowIndex]);
+    case "geojson-table":
+      if (table.schema) {
+        const arrayRow2 = target || [];
+        for (let i = 0; i < table.schema.fields.length; i++) {
+          arrayRow2[i] = table.features[rowIndex][table.schema.fields[i].name];
+        }
+        return arrayRow2;
+      }
+      return Object.values(table.features[rowIndex]);
+    case "columnar-table":
+      if (table.schema) {
+        const arrayRow2 = target || [];
+        for (let i = 0; i < table.schema.fields.length; i++) {
+          arrayRow2[i] = table.data[table.schema.fields[i].name][rowIndex];
+        }
+        return arrayRow2;
+      } else {
+        const arrayRow2 = target || [];
+        let i = 0;
+        for (const column of Object.values(table.data)) {
+          arrayRow2[i] = column[rowIndex];
+          i++;
+        }
+        return arrayRow2;
+      }
+    case "arrow-table":
+      const arrowTable = table.data;
+      const arrayRow = target || [];
+      const row = arrowTable.get(rowIndex);
+      const schema = arrowTable.schema;
+      for (let i = 0; i < schema.fields.length; i++) {
+        arrayRow[i] = row?.[schema.fields[i].name];
+      }
+      return arrayRow;
+    default:
+      throw new Error("shape");
+  }
+}
+function* makeRowIterator(table, shape) {
+  switch (shape) {
+    case "array-row-table":
+      yield* makeArrayRowIterator(table);
+      break;
+    case "object-row-table":
+      yield* makeObjectRowIterator(table);
+      break;
+    default:
+      throw new Error(`Unknown row type ${shape}`);
+  }
+}
+function* makeArrayRowIterator(table, target = []) {
+  const length = getTableLength(table);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    yield getTableRowAsArray(table, rowIndex, target);
+  }
+}
+function* makeObjectRowIterator(table, target = {}) {
+  const length = getTableLength(table);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    yield getTableRowAsObject(table, rowIndex, target);
+  }
+}
+
+// src/schema-utils/lib/table/batches/make-table-from-batches.ts
+async function makeTableFromBatches(batchIterator) {
+  let arrayRows;
+  let objectRows;
+  let features;
+  let shape = null;
+  let schema;
+  for await (const batch of batchIterator) {
+    shape = shape || batch.shape;
+    schema = schema || batch.schema;
+    switch (batch.shape) {
+      case "array-row-table":
+        arrayRows = arrayRows || [];
+        for (let rowIndex = 0; rowIndex < getTableLength(batch); rowIndex++) {
+          const row = batch.data[rowIndex];
+          arrayRows.push(row);
+        }
+        break;
+      case "object-row-table":
+        objectRows = objectRows || [];
+        for (let rowIndex = 0; rowIndex < getTableLength(batch); rowIndex++) {
+          const row = batch.data[rowIndex];
+          objectRows.push(row);
+        }
+        break;
+      case "geojson-table":
+        features = features || [];
+        for (let rowIndex = 0; rowIndex < getTableLength(batch); rowIndex++) {
+          const row = batch.features[rowIndex];
+          features.push(row);
+        }
+        break;
+      case "columnar-table":
+      case "arrow-table":
+      default:
+        throw new Error("shape");
+    }
+  }
+  if (!shape) {
+    return null;
+  }
+  switch (shape) {
+    case "array-row-table":
+      return { shape: "array-row-table", data: arrayRows, schema };
+    case "object-row-table":
+      return { shape: "object-row-table", data: objectRows, schema };
+    case "geojson-table":
+      return { shape: "geojson-table", type: "FeatureCollection", features, schema };
+    default:
+      return null;
+  }
+}
+
+// src/schema-utils/lib/table/tables/table-column.ts
+function makeColumnFromField(field, length) {
+  const ArrayType = getArrayTypeFromDataType(field.type, field.nullable);
+  return new ArrayType(length);
+}
+
+// src/schema-utils/lib/table/tables/convert-arrow-table.ts
+var arrow4 = __toESM(require("apache-arrow"), 1);
+
+// src/schema-utils/lib/table/batches/make-arrow-batch-iterator.ts
+var arrow3 = __toESM(require("apache-arrow"), 1);
+function* makeArrowTableBatchIterator(table, options) {
+  for (const batch of makeArrowRecordBatchIterator(table, options)) {
+    const arrowTable = new arrow3.Table([batch]);
+    yield {
+      ...batch,
+      shape: "arrow-table",
+      schema: table.schema,
+      batchType: "data",
+      length: arrowTable.numRows,
+      data: arrowTable
+    };
+  }
+}
+function* makeArrowRecordBatchIterator(table, options) {
+  const arrowSchema = convertSchemaToArrow(table.schema);
+  const length = getTableLength(table);
+  const numColumns = getTableNumCols(table);
+  const batchSize = options?.batchSize || length;
+  const builders = arrowSchema?.fields.map(
+    (arrowField) => arrow3.makeBuilder({
+      type: arrowField.type,
+      nullValues: [null, void 0]
+    })
+  );
+  const structField = new arrow3.Struct(arrowSchema.fields);
+  let batchLength = 0;
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    for (let columnIndex = 0; columnIndex < numColumns; ++columnIndex) {
+      const value = getTableCellAt(table, rowIndex, columnIndex);
+      const builder = builders[columnIndex];
+      builder.append(value);
+    }
+    batchLength++;
+    if (batchLength >= batchSize) {
+      const datas = builders.map((builder) => builder.flush());
+      const structData = new arrow3.Data(structField, 0, batchLength, 0, void 0, datas);
+      yield new arrow3.RecordBatch(arrowSchema, structData);
+      batchLength = 0;
+    }
+  }
+  if (batchLength > 0) {
+    const datas = builders.map((builder) => builder.flush());
+    const structData = new arrow3.Data(structField, 0, batchLength, 0, void 0, datas);
+    yield new arrow3.RecordBatch(arrowSchema, structData);
+    batchLength = 0;
+  }
+  builders.map((builder) => builder.finish());
+}
+
+// src/schema-utils/lib/table/tables/convert-arrow-table.ts
+function convertTableToArrow(table, options) {
+  switch (table.shape) {
+    case "arrow-table":
+      return table.data;
+    case "columnar-table":
+    // TODO - optimized implementation is possible
+    // return convertColumnarTableToArrow(table, options);
+    // fall through
+    default:
+      const arrowBatchIterator = makeArrowRecordBatchIterator(table, options);
+      return new arrow4.Table(arrowBatchIterator);
+  }
+}
+function convertArrowToTable(arrowTable, shape) {
+  switch (shape) {
+    case "arrow-table":
+      return convertArrowToArrowTable(arrowTable);
+    case "array-row-table":
+      return convertArrowToArrayRowTable(arrowTable);
+    case "object-row-table":
+      return convertArrowToObjectRowTable(arrowTable);
+    case "columnar-table":
+      return convertArrowToColumnarTable(arrowTable);
+    case "geojson-table":
+      return convertArrowToGeoJSONTable(arrowTable);
+    default:
+      throw new Error(shape);
+  }
+}
+function convertArrowToArrowTable(arrowTable) {
+  return {
+    shape: "arrow-table",
+    schema: convertArrowToSchema(arrowTable.schema),
+    data: arrowTable
+  };
+}
+function convertArrowToArrayRowTable(arrowTable) {
+  const columnarTable = convertArrowToColumnarTable(arrowTable);
+  return convertTable(columnarTable, "array-row-table");
+}
+function convertArrowToObjectRowTable(arrowTable) {
+  const columnarTable = convertArrowToColumnarTable(arrowTable);
+  return convertTable(columnarTable, "object-row-table");
+}
+function convertArrowToColumnarTable(arrowTable) {
+  const columns = {};
+  for (const field of arrowTable.schema.fields) {
+    const arrowColumn = arrowTable.getChild(field.name);
+    const values = arrowColumn?.toArray();
+    columns[field.name] = values;
+  }
+  const schema = convertArrowToSchema(arrowTable.schema);
+  return {
+    shape: "columnar-table",
+    schema,
+    data: columns
+  };
+}
+function convertArrowToGeoJSONTable(arrowTable) {
+  const schema = convertArrowToSchema(arrowTable.schema);
+  const features = [];
+  for (let row = 0; row < arrowTable.numRows; row++) {
+    const properties = arrowTable.get(row)?.toJSON() || {};
+    features.push({ type: "Feature", geometry: null, properties });
+  }
+  return {
+    shape: "geojson-table",
+    type: "FeatureCollection",
+    schema,
+    features
+  };
+}
+
+// src/schema-utils/lib/table/tables/convert-table.ts
+function convertTable(table, shape) {
+  switch (shape) {
+    case "object-row-table":
+      return convertToObjectRowTable(table);
+    case "array-row-table":
+      return convertToArrayRowTable(table);
+    case "columnar-table":
+      return convertToColumnarTable(table);
+    case "arrow-table":
+      return convertToArrowTable(table);
+    default:
+      throw new Error(shape);
+  }
+}
+function convertToColumnarTable(table) {
+  const schema = table.schema || deduceTableSchema(table);
+  const fields = schema.fields;
+  if (table.shape === "columnar-table") {
+    return { ...table, schema };
+  }
+  const length = getTableLength(table);
+  const columns = {};
+  for (const field of fields) {
+    const column = makeColumnFromField(field, length);
+    columns[field.name] = column;
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+      column[rowIndex] = getTableCell(table, rowIndex, field.name);
+    }
+  }
+  return {
+    shape: "columnar-table",
+    schema,
+    data: columns
+  };
+}
+function convertToArrayRowTable(table) {
+  if (table.shape === "array-row-table") {
+    return table;
+  }
+  const length = getTableLength(table);
+  const data = new Array(length);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    data[rowIndex] = getTableRowAsArray(table, rowIndex);
+  }
+  return {
+    shape: "array-row-table",
+    schema: table.schema,
+    data
+  };
+}
+function convertToObjectRowTable(table) {
+  if (table.shape === "object-row-table") {
+    return table;
+  }
+  const length = getTableLength(table);
+  const data = new Array(length);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    data[rowIndex] = getTableRowAsObject(table, rowIndex);
+  }
+  return {
+    shape: "object-row-table",
+    schema: table.schema,
+    data
+  };
+}
+function convertToArrowTable(table) {
+  const schema = table.schema || deduceTableSchema(table);
+  const arrowTable = convertTableToArrow({ ...table, schema });
+  return {
+    shape: "arrow-table",
+    schema,
+    data: arrowTable
+  };
+}
+
+// src/schema-utils/lib/table/tables/table-converter/convert-tables.ts
+function convertTables(table, shape) {
+  switch (shape) {
+    case "object-row-table":
+      return convertTable(table, "object-row-table");
+    case "array-row-table":
+      return convertTable(table, "array-row-table");
+    case "columnar-table":
+      return convertTable(table, "columnar-table");
+    case "arrow-table":
+      return convertTable(table, "arrow-table");
+    default:
+      throw new Error(`Unsupported table conversion target: ${shape}`);
+  }
+}
+
+// src/schema-utils/lib/table/tables/table-converter/table-converter.ts
+var TableConverter = {
+  id: "table",
+  from: ["object-row-table", "array-row-table", "columnar-table", "arrow-table"],
+  to: ["object-row-table", "array-row-table", "columnar-table", "arrow-table"],
+  canConvert(sourceShape, targetShape) {
+    return sourceShape !== targetShape;
+  },
+  detectInputShape(input) {
+    if (typeof input === "object" && input !== null && "shape" in input && typeof input.shape === "string" && ["object-row-table", "array-row-table", "columnar-table", "arrow-table"].includes(input.shape)) {
+      return input.shape;
+    }
+    return null;
+  },
+  convert(input, targetShape) {
+    switch (targetShape) {
+      case "object-row-table":
+        return convertTables(input, "object-row-table");
+      case "array-row-table":
+        return convertTables(input, "array-row-table");
+      case "columnar-table":
+        return convertTables(input, "columnar-table");
+      case "arrow-table":
+        return convertTables(input, "arrow-table");
+      default:
+        throw new Error(`Unsupported table conversion target: ${targetShape}`);
+    }
+  }
+};
+var TABLE_CONVERTERS = [TableConverter];
+
+// src/schema-utils/lib/table/tables/row-utils.ts
+function convertToObjectRow(arrayRow, headers) {
+  if (!arrayRow) {
+    throw new Error("null row");
+  }
+  const objectRow = {};
+  if (headers) {
+    for (let i = 0; i < headers.length; i++) {
+      objectRow[headers[i]] = arrayRow[i];
+    }
+  } else {
+    for (let i = 0; i < arrayRow.length; i++) {
+      const columnName = `column-${i}`;
+      objectRow[columnName] = arrayRow[i];
+    }
+  }
+  return objectRow;
+}
+function convertToArrayRow(objectRow, headers) {
+  if (!objectRow) {
+    throw new Error("null row");
+  }
+  if (headers) {
+    const arrayRow = new Array(headers.length);
+    for (let i = 0; i < headers.length; i++) {
+      arrayRow[i] = objectRow[headers[i]];
+    }
+    return arrayRow;
+  }
+  return Object.values(objectRow);
+}
+function inferHeadersFromArrayRow(arrayRow) {
+  const headers = [];
+  for (let i = 0; i < arrayRow.length; i++) {
+    const columnName = `column-${i}`;
+    headers.push(columnName);
+  }
+  return headers;
+}
+function inferHeadersFromObjectRow(row) {
+  return Object.keys(row);
+}
+
+// src/schema-utils/deprecated.ts
+var convertTable2 = ((...args) => convertTable(
+  ...args
+));
+var convertArrowToTable2 = ((...args) => convertArrowToTable(
+  ...args
+));
+var convertTableToArrow2 = ((...args) => convertTableToArrow(
+  ...args
+));
+var convertToObjectRow2 = ((...args) => convertToObjectRow(
+  ...args
+));
+var convertToArrayRow2 = ((...args) => convertToArrayRow(
+  ...args
+));
+
+// src/schema-utils/lib/table/batches/make-table-batch-iterator.ts
+function* makeTableBatchIterator(table) {
+  yield makeBatchFromTable(table);
+}
+function makeBatchFromTable(table) {
+  return { ...table, length: getTableLength(table), batchType: "data" };
+}
+
+// src/schema-utils/lib/table/query-arrow-table.ts
+var arrow5 = __toESM(require("apache-arrow"), 1);
+function queryArrowTable(table, options = {}, filterRows) {
+  const availableColumns = table.data.schema.fields.map((field) => field.name);
+  const selectedColumns = options.columns ? [...options.columns] : availableColumns;
+  for (const columnName of selectedColumns) {
+    if (!availableColumns.includes(columnName)) {
+      throw new Error(`Arrow table query could not read column "${columnName}".`);
+    }
+  }
+  let rowIndices;
+  if (options.predicate !== void 0) {
+    if (!filterRows) throw new Error("Arrow table query requires a predicate evaluator.");
+    const columns = Object.fromEntries(
+      availableColumns.map((name) => [name, [...table.data.getChild(name) || []]])
+    );
+    rowIndices = filterRows(options.predicate, columns, table.data.numRows);
+  }
+  const limitedRowIndices = rowIndices ? rowIndices.slice(0, options.limit ?? Number.POSITIVE_INFINITY) : void 0;
+  const data = limitedRowIndices ? createArrowTableFromRowIndices(table.data, selectedColumns, limitedRowIndices) : table.data.select(selectedColumns).slice(0, options.limit ?? Number.POSITIVE_INFINITY);
+  const schema = table.schema ? {
+    ...table.schema,
+    fields: selectedColumns.flatMap(
+      (columnName) => table.schema?.fields.filter((field) => field.name === columnName) || []
+    )
+  } : void 0;
+  return schema ? { shape: "arrow-table", schema, data } : { shape: "arrow-table", data };
+}
+function selectArrowTableRows(table, rowIndices, columns, limit) {
+  const availableColumns = table.data.schema.fields.map((field) => field.name);
+  const selectedColumns = columns ? [...columns] : availableColumns;
+  for (const columnName of selectedColumns) {
+    if (!availableColumns.includes(columnName)) {
+      throw new Error(`Arrow table query could not read column "${columnName}".`);
+    }
+  }
+  const limitedRowIndices = rowIndices.slice(0, limit ?? Number.POSITIVE_INFINITY);
+  const data = createArrowTableFromRowIndices(table.data, selectedColumns, limitedRowIndices);
+  const schema = table.schema ? {
+    ...table.schema,
+    fields: selectedColumns.flatMap(
+      (columnName) => table.schema?.fields.filter((field) => field.name === columnName) || []
+    )
+  } : void 0;
+  return schema ? { shape: "arrow-table", schema, data } : { shape: "arrow-table", data };
+}
+function createArrowTableFromRowIndices(sourceData, selectedColumns, rowIndices) {
+  const schema = new arrow5.Schema(
+    selectedColumns.map(
+      (columnName) => sourceData.schema.fields.find((field) => field.name === columnName)
+    )
+  );
+  const vectors = Object.fromEntries(
+    selectedColumns.map((columnName) => {
+      const sourceVector = sourceData.getChild(columnName);
+      return [
+        columnName,
+        arrow5.vectorFromArray(
+          rowIndices.map((rowIndex) => sourceVector?.get(rowIndex)),
+          sourceVector?.type
+        )
+      ];
+    })
+  );
+  const children = selectedColumns.map((columnName) => vectors[columnName].data[0]);
+  const data = new arrow5.Data(
+    new arrow5.Struct(schema.fields),
+    0,
+    rowIndices.length,
+    0,
+    void 0,
+    children
+  );
+  return new arrow5.Table(schema, new arrow5.RecordBatch(schema, data));
+}
+
+// src/schema-utils/lib/table/batches/convert-batches.ts
+function convertBatch(batch, shape) {
+  switch (shape) {
+    case "object-row-table":
+      return { ...batch, ...convertTable(batch, "object-row-table") };
+    case "array-row-table":
+      return { ...batch, ...convertTable(batch, "array-row-table") };
+    case "columnar-table":
+      return { ...batch, ...convertTable(batch, "columnar-table") };
+    case "arrow-table":
+      return { ...batch, ...convertTable(batch, "arrow-table") };
+    default:
+      throw new Error(shape);
+  }
+}
+async function* convertBatches(batches, shape) {
+  for await (const batch of batches) {
+    switch (shape) {
+      case "object-row-table":
+        yield convertBatch(batch, "object-row-table");
+        break;
+      case "array-row-table":
+        yield convertBatch(batch, "array-row-table");
+        break;
+      case "columnar-table":
+        yield convertBatch(batch, "columnar-table");
+        break;
+      case "arrow-table":
+        yield convertBatch(batch, "arrow-table");
+        break;
+      default:
+        throw new Error(shape);
+    }
+  }
+}
+
+// src/schema-utils/lib/table/tables/table-types.ts
+function isArrayRowTable(table) {
+  return table.shape === "array-row-table";
+}
+function isObjectRowTable(table) {
+  return table.shape === "object-row-table";
+}
+function isColumnarTable(table) {
+  return table.shape === "columnar-table";
+}
+function isGeoJSONTable(table) {
+  return table.shape === "geojson-table";
+}
+function isArrowTable(table) {
+  return table.shape === "arrow-table";
+}
+
+// src/schema-utils/lib/table/batch-builder/base-table-batch-aggregator.ts
+var DEFAULT_ROW_COUNT = 100;
+var BaseTableBatchAggregator = class {
+  schema;
+  options;
+  shape;
+  length = 0;
+  rows = null;
+  cursor = 0;
+  _headers = [];
+  constructor(schema, options) {
+    this.options = options;
+    this.schema = schema;
+    if (!Array.isArray(schema)) {
+      this._headers = [];
+      for (const key in schema) {
+        this._headers[schema[key].index] = schema[key].name;
+      }
+    }
+  }
+  rowCount() {
+    return this.length;
+  }
+  addArrayRow(row, cursor) {
+    if (Number.isFinite(cursor)) {
+      this.cursor = cursor;
+    }
+    this.shape = "array-row-table";
+    this.rows = this.rows || new Array(DEFAULT_ROW_COUNT);
+    this.rows[this.length] = row;
+    this.length++;
+  }
+  addObjectRow(row, cursor) {
+    if (Number.isFinite(cursor)) {
+      this.cursor = cursor;
+    }
+    this.shape = "object-row-table";
+    this.rows = this.rows || new Array(DEFAULT_ROW_COUNT);
+    this.rows[this.length] = row;
+    this.length++;
+  }
+  getBatch() {
+    let rows = this.rows;
+    if (!rows) {
+      return null;
+    }
+    rows = rows.slice(0, this.length);
+    this.rows = null;
+    const batch = {
+      shape: this.shape || "array-row-table",
+      batchType: "data",
+      data: rows,
+      length: this.length,
+      schema: this.schema,
+      cursor: this.cursor
+    };
+    return batch;
+  }
+};
+
+// src/schema-utils/lib/table/batch-builder/row-table-batch-aggregator.ts
+var DEFAULT_ROW_COUNT2 = 100;
+var RowTableBatchAggregator = class {
+  schema;
+  options;
+  length = 0;
+  objectRows = null;
+  arrayRows = null;
+  cursor = 0;
+  _headers = null;
+  constructor(schema, options) {
+    this.options = options;
+    this.schema = schema;
+    if (schema) {
+      this._headers = [];
+      for (let i = 0; i < schema.fields.length; i++) {
+        this._headers[i] = schema.fields[i].name;
+      }
+    }
+  }
+  rowCount() {
+    return this.length;
+  }
+  addArrayRow(row, cursor) {
+    if (Number.isFinite(cursor)) {
+      this.cursor = cursor;
+    }
+    this._headers ||= inferHeadersFromArrayRow(row);
+    switch (this.options.shape) {
+      case "object-row-table":
+        const rowObject = convertToObjectRow(row, this._headers);
+        this.addObjectRow(rowObject, cursor);
+        break;
+      case "array-row-table":
+        this.arrayRows = this.arrayRows || new Array(DEFAULT_ROW_COUNT2);
+        this.arrayRows[this.length] = row;
+        this.length++;
+        break;
+    }
+  }
+  addObjectRow(row, cursor) {
+    if (Number.isFinite(cursor)) {
+      this.cursor = cursor;
+    }
+    this._headers ||= inferHeadersFromObjectRow(row);
+    switch (this.options.shape) {
+      case "array-row-table":
+        const rowArray = convertToArrayRow(row, this._headers);
+        this.addArrayRow(rowArray, cursor);
+        break;
+      case "object-row-table":
+        this.objectRows = this.objectRows || new Array(DEFAULT_ROW_COUNT2);
+        this.objectRows[this.length] = row;
+        this.length++;
+        break;
+    }
+  }
+  getBatch() {
+    let rows = this.arrayRows || this.objectRows;
+    if (!rows) {
+      return null;
+    }
+    rows = rows.slice(0, this.length);
+    this.arrayRows = null;
+    this.objectRows = null;
+    return {
+      shape: this.options.shape,
+      batchType: "data",
+      data: rows,
+      length: this.length,
+      // @ts-expect-error we should infer a schema
+      schema: this.schema,
+      cursor: this.cursor
+    };
+  }
+};
+
+// src/schema-utils/lib/table/batch-builder/columnar-table-batch-aggregator.ts
+var import_types2 = require("@math.gl/core/types");
+var DEFAULT_ROW_COUNT3 = 100;
+var ColumnarTableBatchAggregator = class {
+  schema;
+  length = 0;
+  allocated = 0;
+  columns = {};
+  constructor(schema, options) {
+    this.schema = schema;
+    this._reallocateColumns();
+  }
+  rowCount() {
+    return this.length;
+  }
+  addArrayRow(row) {
+    this._reallocateColumns();
+    let i = 0;
+    for (const fieldName in this.columns) {
+      this.columns[fieldName][this.length] = row[i++];
+    }
+    this.length++;
+  }
+  addObjectRow(row) {
+    this._reallocateColumns();
+    for (const fieldName in row) {
+      this.columns[fieldName][this.length] = row[fieldName];
+    }
+    this.length++;
+  }
+  getBatch() {
+    this._pruneColumns();
+    const batch = {
+      shape: "columnar-table",
+      batchType: "data",
+      data: this.columns,
+      schema: this.schema,
+      length: this.length
+    };
+    return batch;
+  }
+  // HELPERS
+  _reallocateColumns() {
+    if (this.length < this.allocated) {
+      return;
+    }
+    this.allocated = this.allocated > 0 ? this.allocated * 2 : DEFAULT_ROW_COUNT3;
+    this.columns = {};
+    for (const field of this.schema.fields) {
+      const ArrayType = getArrayTypeFromDataType(field.type, field.nullable);
+      const oldColumn = this.columns[field.name];
+      if (!oldColumn) {
+        this.columns[field.name] = new ArrayType(this.allocated);
+      } else if (Array.isArray(oldColumn)) {
+        oldColumn.length = this.allocated;
+      } else if ((0, import_types2.isTypedArray)(oldColumn)) {
+        const typedArray = new ArrayType(this.allocated);
+        typedArray.set(oldColumn);
+        this.columns[field.name] = typedArray;
+      } else {
+        throw new Error("Invalid column type");
+      }
+    }
+  }
+  _pruneColumns() {
+    for (const [columnName, column] of Object.entries(this.columns)) {
+      this.columns[columnName] = column.slice(0, this.length);
+    }
+  }
+};
+
+// src/schema-utils/lib/table/batch-builder/arrow-table-batch-aggregator.ts
+var arrow6 = __toESM(require("apache-arrow"), 1);
+var ArrowTableBatchAggregator = class extends ColumnarTableBatchAggregator {
+  arrowSchema;
+  constructor(schema, options) {
+    super(schema, options);
+    this.arrowSchema = null;
+  }
+  getBatch() {
+    const batch = super.getBatch();
+    if (batch) {
+      this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);
+      const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);
+      const recordBatch = new arrow6.RecordBatch(
+        this.arrowSchema,
+        arrow6.makeData({
+          type: new arrow6.Struct(this.arrowSchema.fields),
+          children: arrowVectors.map(({ data }) => data[0])
+        })
+      );
+      return {
+        shape: "arrow-table",
+        batchType: "data",
+        data: new arrow6.Table([recordBatch]),
+        length: batch.length
+      };
+    }
+    return null;
+  }
+};
+function getArrowSchema(schema) {
+  const arrowFields = [];
+  const fields = Array.isArray(schema.fields) ? schema.fields : Object.values(schema);
+  for (const field of fields) {
+    if (field.type === "float32" || field.type === Float32Array) {
+      const metadata = /* @__PURE__ */ new Map();
+      const arrowField = new arrow6.Field(field.name, new arrow6.Float32(), field.nullable, metadata);
+      arrowFields.push(arrowField);
+    }
+  }
+  if (arrowFields.length === 0) {
+    throw new Error("No arrow convertible fields");
+  }
+  if (arrowFields.length !== fields.length) {
+    throw new Error("Some schema fields are not arrow convertible");
+  }
+  return new arrow6.Schema(arrowFields);
+}
+function getArrowVectors(arrowSchema, data) {
+  const arrowVectors = [];
+  for (const field of arrowSchema.fields) {
+    const vector = data[field.name];
+    if (vector instanceof Float32Array) {
+      const arrowVector = arrow6.makeVector(vector);
+      arrowVectors.push(arrowVector);
+    }
+  }
+  if (arrowSchema.fields.length !== arrowVectors.length) {
+    throw new Error("Some columns not arrow convertible");
+  }
+  return arrowVectors;
+}
+
+// src/schema-utils/lib/table/batch-builder/table-batch-builder.ts
+var DEFAULT_OPTIONS = {
+  shape: void 0,
+  batchSize: "auto",
+  batchDebounceMs: 0,
+  limit: 0,
+  _limitMB: 0
+};
+var TableBatchBuilder = class {
+  schema;
+  options;
+  aggregator = null;
+  batchCount = 0;
+  bytesUsed = 0;
+  isChunkComplete = false;
+  lastBatchEmittedMs = Date.now();
+  totalLength = 0;
+  totalBytes = 0;
+  rowBytes = 0;
+  static ArrowBatch;
+  constructor(schema, options) {
+    this.schema = schema;
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  limitReached() {
+    if (Boolean(this.options?.limit) && this.totalLength >= this.options.limit) {
+      return true;
+    }
+    if (Boolean(this.options?._limitMB) && this.totalBytes / 1e6 >= this.options._limitMB) {
+      return true;
+    }
+    return false;
+  }
+  /** @deprecated Use addArrayRow or addObjectRow */
+  addRow(row) {
+    if (this.limitReached()) {
+      return;
+    }
+    this.totalLength++;
+    this.rowBytes = this.rowBytes || this._estimateRowMB(row);
+    this.totalBytes += this.rowBytes;
+    if (Array.isArray(row)) {
+      this.addArrayRow(row);
+    } else {
+      this.addObjectRow(row);
+    }
+  }
+  /** Add one row to the batch */
+  addArrayRow(row) {
+    if (!this.aggregator) {
+      const TableBatchType = this._getTableBatchType();
+      this.aggregator = new TableBatchType(this.schema, this.options);
+    }
+    this.aggregator.addArrayRow(row);
+  }
+  /** Add one row to the batch */
+  addObjectRow(row) {
+    if (!this.aggregator) {
+      const TableBatchType = this._getTableBatchType();
+      this.aggregator = new TableBatchType(this.schema, this.options);
+    }
+    this.aggregator.addObjectRow(row);
+  }
+  /** Mark an incoming raw memory chunk has completed */
+  chunkComplete(chunk) {
+    if (chunk instanceof ArrayBuffer) {
+      this.bytesUsed += chunk.byteLength;
+    }
+    if (typeof chunk === "string") {
+      this.bytesUsed += chunk.length;
+    }
+    this.isChunkComplete = true;
+  }
+  getFullBatch(options) {
+    return this._isFull() ? this._getBatch(options) : null;
+  }
+  getFinalBatch(options) {
+    return this._getBatch(options);
+  }
+  // INTERNAL
+  _estimateRowMB(row) {
+    return Array.isArray(row) ? row.length * 8 : Object.keys(row).length * 8;
+  }
+  _isFull() {
+    if (!this.aggregator || this.aggregator.rowCount() === 0) {
+      return false;
+    }
+    if (this.options.batchSize === "auto") {
+      if (!this.isChunkComplete) {
+        return false;
+      }
+    } else if (this.options.batchSize > this.aggregator.rowCount()) {
+      return false;
+    }
+    if (this.options.batchDebounceMs > Date.now() - this.lastBatchEmittedMs) {
+      return false;
+    }
+    this.isChunkComplete = false;
+    this.lastBatchEmittedMs = Date.now();
+    return true;
+  }
+  /**
+   * bytesUsed can be set via chunkComplete or via getBatch*
+   */
+  _getBatch(options) {
+    if (!this.aggregator) {
+      return null;
+    }
+    if (options?.bytesUsed) {
+      this.bytesUsed = options.bytesUsed;
+    }
+    const normalizedBatch = this.aggregator.getBatch();
+    normalizedBatch.count = this.batchCount;
+    normalizedBatch.bytesUsed = this.bytesUsed;
+    Object.assign(normalizedBatch, options);
+    this.batchCount++;
+    this.aggregator = null;
+    return normalizedBatch;
+  }
+  _getTableBatchType() {
+    switch (this.options.shape) {
+      case "array-row-table":
+      case "object-row-table":
+        return RowTableBatchAggregator;
+      case "columnar-table":
+        return ColumnarTableBatchAggregator;
+      case "arrow-table":
+        return ArrowTableBatchAggregator;
+      default:
+        return BaseTableBatchAggregator;
+    }
+  }
+};
+
+// src/schema-utils/lib/table/arrow-api/arrow-like-field.ts
+var ArrowLikeField = class _ArrowLikeField {
+  name;
+  type;
+  nullable;
+  metadata;
+  constructor(name, type, nullable = false, metadata = /* @__PURE__ */ new Map()) {
+    this.name = name;
+    this.type = type;
+    this.nullable = nullable;
+    this.metadata = metadata;
+  }
+  get typeId() {
+    return this.type && this.type.typeId;
+  }
+  clone() {
+    return new _ArrowLikeField(this.name, this.type, this.nullable, this.metadata);
+  }
+  compareTo(other) {
+    return this.name === other.name && this.type === other.type && this.nullable === other.nullable && this.metadata === other.metadata;
+  }
+  toString() {
+    return `${JSON.stringify(this.type)}${this.nullable ? ", nullable" : ""}${this.metadata ? `, metadata: ${JSON.stringify(this.metadata)}` : ""}`;
+  }
+};
+
+// src/schema-utils/lib/table/arrow-api/arrow-like-schema.ts
+var ArrowLikeSchema = class _ArrowLikeSchema {
+  fields;
+  metadata;
+  constructor(fields, metadata = /* @__PURE__ */ new Map()) {
+    this.fields = fields.map(
+      (field) => new ArrowLikeField(field.name, field.type, field.nullable, field.metadata)
+    );
+    this.metadata = metadata instanceof Map ? metadata : new Map(Object.entries(metadata));
+  }
+  // TODO - arrow only seems to compare fields, not metadata
+  compareTo(other) {
+    if (this.metadata !== other.metadata) {
+      return false;
+    }
+    if (this.fields.length !== other.fields.length) {
+      return false;
+    }
+    for (let i = 0; i < this.fields.length; ++i) {
+      if (!this.fields[i].compareTo(other.fields[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  select(...columnNames) {
+    const nameMap = /* @__PURE__ */ Object.create(null);
+    for (const name of columnNames) {
+      nameMap[name] = true;
+    }
+    const selectedFields = this.fields.filter((field) => nameMap[field.name]);
+    return new _ArrowLikeSchema(selectedFields, this.metadata);
+  }
+  selectAt(...columnIndices) {
+    const selectedFields = columnIndices.map((index) => this.fields[index]).filter(Boolean);
+    return new _ArrowLikeSchema(selectedFields, this.metadata);
+  }
+  assign(schemaOrFields) {
+    let fields;
+    let metadata = this.metadata;
+    if (schemaOrFields instanceof _ArrowLikeSchema) {
+      const otherArrowLikeSchema = schemaOrFields;
+      fields = otherArrowLikeSchema.fields;
+      metadata = mergeMaps(mergeMaps(/* @__PURE__ */ new Map(), this.metadata), otherArrowLikeSchema.metadata);
+    } else {
+      fields = schemaOrFields;
+    }
+    const fieldMap = /* @__PURE__ */ Object.create(null);
+    for (const field of this.fields) {
+      fieldMap[field.name] = field;
+    }
+    for (const field of fields) {
+      fieldMap[field.name] = field;
+    }
+    const mergedFields = Object.values(fieldMap);
+    return new _ArrowLikeSchema(mergedFields, metadata);
+  }
+};
+function mergeMaps(m1, m2) {
+  return new Map([...m1 || /* @__PURE__ */ new Map(), ...m2 || /* @__PURE__ */ new Map()]);
+}
+
+// src/schema-utils/lib/table/arrow-api/arrow-like-table.ts
+var ArrowLikeVector = class {
+  table;
+  columnName;
+  constructor(table, columnName) {
+    this.table = table;
+    this.columnName = columnName;
+  }
+  get(rowIndex) {
+    return getTableCell(this.table, rowIndex, this.columnName);
+  }
+  toArray() {
+    switch (this.table.shape) {
+      case "arrow-table":
+        const arrowTable = this.table.data;
+        return arrowTable.getChild(this.columnName)?.toArray();
+      case "columnar-table":
+        return this.table.data[this.columnName];
+      default:
+        throw new Error(this.table.shape);
+    }
+  }
+};
+var ArrowLikeTable = class {
+  schema;
+  table;
+  constructor(table) {
+    const schema = table.schema || deduceTableSchema(table);
+    this.schema = new ArrowLikeSchema(schema.fields, schema.metadata);
+    this.table = { ...table, schema };
+  }
+  // get schema() {
+  //   return this.table.schema;
+  // }
+  get data() {
+    return this.table.shape === "geojson-table" ? this.table.features : this.table.data;
+  }
+  get numCols() {
+    return getTableNumCols(this.table);
+  }
+  get length() {
+    return getTableLength(this.table);
+  }
+  getChild(columnName) {
+    return new ArrowLikeVector(this.table, columnName);
+  }
+  // getChildAt(columnIndex: number): ArrowLikeVector {
+  //   return
+  // }
+};
+
+// src/schema-utils/lib/mesh/mesh-utils.ts
+function getMeshSize(attributes) {
+  let size = 0;
+  for (const attributeName in attributes) {
+    const attribute = attributes[attributeName];
+    if (ArrayBuffer.isView(attribute)) {
+      size += attribute.byteLength * attribute.BYTES_PER_ELEMENT;
+    }
+  }
+  return size;
+}
+function getMeshBoundingBox(attributes) {
+  const positionAttribute = attributes?.POSITION;
+  if (!positionAttribute || !("value" in positionAttribute) || !positionAttribute.value.length) {
+    return null;
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  const positions = positionAttribute.value;
+  const len = positions.length;
+  for (let i = 0; i < len; i += 3) {
+    const x = positions[i];
+    const y = positions[i + 1];
+    const z = positions[i + 2];
+    minX = x < minX ? x : minX;
+    minY = y < minY ? y : minY;
+    minZ = z < minZ ? z : minZ;
+    maxX = x > maxX ? x : maxX;
+    maxY = y > maxY ? y : maxY;
+    maxZ = z > maxZ ? z : maxZ;
+  }
+  return [
+    [minX, minY, minZ],
+    [maxX, maxY, maxZ]
+  ];
+}
+
+// src/schema/float16.ts
+var import_types3 = require("@math.gl/core/types");
+function createFloat16Array(length) {
+  const ArrayConstructor = (0, import_types3.getFloat16ArrayConstructor)();
+  return new ArrayConstructor(length);
+}
+function isNativeFloat16Array(value) {
+  return Boolean(import_types3.NativeFloat16ArrayConstructor && value instanceof import_types3.NativeFloat16ArrayConstructor);
+}
+function setFloat16Value(array, index, value) {
+  if (isNativeFloat16Array(array)) {
+    array[index] = value;
+  } else {
+    array[index] = encodeFloat16(value);
+  }
+}
+function getFloat16Value(array, index) {
+  if (isNativeFloat16Array(array)) {
+    return array[index];
+  }
+  return decodeFloat16(array[index]);
+}
+function getFloat16Storage(array) {
+  return isNativeFloat16Array(array) ? new Uint16Array(array.buffer, array.byteOffset, array.length) : array;
+}
+function encodeFloat16(value) {
+  if (!Number.isFinite(value)) {
+    return value === Infinity ? 31744 : value === -Infinity ? 64512 : 32256;
+  }
+  const sign = value < 0 || Object.is(value, -0) ? 32768 : 0;
+  const absoluteValue = Math.abs(value);
+  if (absoluteValue === 0) {
+    return sign;
+  }
+  if (absoluteValue >= 65520) {
+    return sign | 31744;
+  }
+  if (absoluteValue >= 65504) {
+    return sign | 31743;
+  }
+  const exponent = Math.floor(Math.log2(absoluteValue));
+  if (exponent < -14) {
+    return sign | Math.round(absoluteValue / 2 ** -24);
+  }
+  const normalizedExponent = exponent + 15;
+  const mantissa = Math.round((absoluteValue / 2 ** exponent - 1) * 1024);
+  if (mantissa === 1024) {
+    return sign | normalizedExponent + 1 << 10;
+  }
+  return sign | normalizedExponent << 10 | mantissa;
+}
+function decodeFloat16(value) {
+  const sign = value & 32768 ? -1 : 1;
+  const exponent = value >> 10 & 31;
+  const mantissa = value & 1023;
+  if (exponent === 0) {
+    return sign * mantissa * 2 ** -24;
+  }
+  if (exponent === 31) {
+    return mantissa ? NaN : sign * Infinity;
+  }
+  return sign * (1 + mantissa / 1024) * 2 ** (exponent - 15);
+}
+
+// src/schema/categories/category-mesh.ts
+var arrow7 = __toESM(require("apache-arrow"), 1);
+var meshArrowSchema = new arrow7.Schema([
+  new arrow7.Field(
+    "POSITION",
+    new arrow7.FixedSizeList(3, new arrow7.Field("value", new arrow7.Float32(), false)),
+    false
+  )
+]);
+var indexedMeshArrowSchema = new arrow7.Schema([
+  ...meshArrowSchema.fields,
+  new arrow7.Field(
+    "indices",
+    new arrow7.List(new arrow7.Field("item", new arrow7.Uint32(), false)),
+    true
+  )
+]);
+
+// src/schema-utils/lib/mesh/convert-mesh-to-table.ts
+var arrow9 = __toESM(require("apache-arrow"), 1);
+
+// src/schema-utils/lib/arrow-utils/arrow-fixed-size-list-utils.ts
+var arrow8 = __toESM(require("apache-arrow"), 1);
+function getFixedSizeListSize(vector) {
+  return vector.type instanceof arrow8.FixedSizeList ? vector.type.listSize : 1;
+}
+function getFixedSizeListVector(typedArray, stride, logicalType) {
+  const data = getFixedSizeListData(typedArray, stride, logicalType);
+  return new arrow8.Vector([data]);
+}
+function getFixedSizeListData(typedArray, stride, logicalType) {
+  const listType = getFixedSizeListType(typedArray, stride, logicalType);
+  const nestedType = listType.children[0].type;
+  const storage = logicalType === "float16" && isNativeFloat16Array(typedArray) ? getFloat16Storage(typedArray) : typedArray;
+  const buffers = {
+    // valueOffsets: undefined,
+    [arrow8.BufferType.DATA]: storage
+    // values
+    // nullBitmap: undefined,
+    // typeIds: undefined
+  };
+  const nestedData = new arrow8.Data(nestedType, 0, storage.length, 0, buffers);
+  const data = new arrow8.Data(
+    listType,
+    0,
+    storage.length / stride,
+    0,
+    void 0,
+    [nestedData]
+  );
+  return data;
+}
+function getFixedSizeListType(typedArray, stride, logicalType) {
+  const type = logicalType || getDataTypeFromArray(typedArray).type;
+  const arrowType = deserializeArrowType(type);
+  const listType = new arrow8.FixedSizeList(stride, new arrow8.Field("value", arrowType, false));
+  return listType;
+}
+
+// src/schema-utils/lib/mesh/convert-mesh-to-table.ts
+var MESH_ARROW_ATTRIBUTE_ORDER = ["POSITION"];
+function convertMeshToTable(mesh, shape) {
+  switch (shape) {
+    case "columnar-table":
+      return convertMeshToColumnarTable(mesh);
+    case "arrow-table":
+      return convertMeshToArrowTable(mesh);
+    default:
+      throw new Error(shape);
+  }
+}
+function convertMeshToColumnarTable(mesh) {
+  const columns = {};
+  const hasIndices = hasMeshIndices(mesh);
+  for (const [columnName, attribute] of Object.entries(mesh.attributes)) {
+    columns[columnName] = attribute.value;
+  }
+  return {
+    shape: "columnar-table",
+    schema: mesh.schema,
+    data: columns,
+    topology: mesh.topology,
+    indices: hasIndices ? mesh.indices : void 0
+  };
+}
+function convertMeshToArrowTable(mesh, batchSize) {
+  return makeMeshArrowTable(mesh.attributes, {
+    schema: mesh.schema,
+    topology: mesh.topology,
+    mode: mesh.mode,
+    boundingBox: mesh.header?.boundingBox,
+    indices: hasMeshIndices(mesh) ? mesh.indices : void 0
+  });
+}
+function makeMeshArrowTable(attributes, options = {}) {
+  const fields = [];
+  const columns = {};
+  const attributeNames = getOrderedAttributeNames(attributes);
+  for (const attributeName of attributeNames) {
+    const attribute = attributes[attributeName];
+    const { value, size = 1 } = attribute;
+    const column = getAttributeArrowVector(value, size, attribute.componentType);
+    columns[attributeName] = column;
+    fields.push(
+      getAttributeArrowField(options.schema, attributeName, column, attribute.componentType)
+    );
+    if (attributeName === "POSITION" && options.indices?.value?.length) {
+      const indicesField = indexedMeshArrowSchema.fields.find((field) => field.name === "indices");
+      columns.indices = getIndicesVector(options.indices.value, column.length, indicesField.type);
+      fields.push(indicesField);
+    }
+  }
+  const arrowSchema = new arrow9.Schema(fields, getMeshArrowMetadata(options));
+  const table = columns[attributeNames[0]]?.length === 0 ? new arrow9.Table(arrowSchema) : new arrow9.Table(arrowSchema, columns);
+  const schema = serializeArrowSchema(table.schema);
+  return {
+    shape: "arrow-table",
+    schema,
+    data: table,
+    topology: options.topology || "point-list",
+    indices: options.indices
+  };
+}
+function getAttributeArrowVector(value, size, componentType) {
+  if (componentType === "float16") {
+    const storage = isNativeFloat16Array(value) ? getFloat16Storage(value) : value;
+    if (size === 1) {
+      const data = new arrow9.Data(new arrow9.Float16(), 0, storage.length, 0, {
+        [arrow9.BufferType.DATA]: storage
+      });
+      return new arrow9.Vector([data]);
+    }
+    return getFixedSizeListVector(value, size, componentType);
+  }
+  return size === 1 ? arrow9.makeVector(value) : getFixedSizeListVector(value, size);
+}
+function getOrderedAttributeNames(attributes) {
+  const attributeNames = Object.keys(attributes);
+  const orderedAttributeNames = MESH_ARROW_ATTRIBUTE_ORDER.filter(
+    (attributeName) => attributeName in attributes
+  );
+  const remainingAttributeNames = attributeNames.filter(
+    (attributeName) => !MESH_ARROW_ATTRIBUTE_ORDER.includes(attributeName)
+  );
+  return [...orderedAttributeNames, ...remainingAttributeNames];
+}
+function hasMeshIndices(mesh) {
+  return Boolean(mesh.indices?.value?.length);
+}
+function getAttributeArrowField(schema, attributeName, column, componentType) {
+  if (attributeName === "POSITION" && isMeshPositionColumn(column)) {
+    const canonicalField = meshArrowSchema.fields[0];
+    const suppliedField = schema?.fields.find((schemaField) => schemaField.name === attributeName);
+    if (!suppliedField?.metadata) {
+      return canonicalField;
+    }
+    const metadata = new Map(canonicalField.metadata);
+    for (const [key, value] of Object.entries(suppliedField.metadata)) {
+      metadata.set(key, value);
+    }
+    return new arrow9.Field(
+      canonicalField.name,
+      canonicalField.type,
+      canonicalField.nullable,
+      metadata
+    );
+  }
+  const field = schema?.fields.find((schemaField) => schemaField.name === attributeName);
+  if (componentType === "float16") {
+    const metadata = new Map(Object.entries(field?.metadata || {}));
+    metadata.set("componentType", "float16");
+    return new arrow9.Field(attributeName, column.type, false, metadata);
+  }
+  if (field && field.type.toString() !== column.type.toString()) {
+    const deserializedField = deserializeArrowField(field);
+    return new arrow9.Field(
+      attributeName,
+      column.type,
+      deserializedField.nullable,
+      deserializedField.metadata
+    );
+  }
+  return field ? deserializeArrowField(field) : new arrow9.Field(attributeName, column.type, false);
+}
+function isMeshPositionColumn(column) {
+  return column.type instanceof arrow9.FixedSizeList && column.type.listSize === 3 && column.type.children[0].type instanceof arrow9.Float32;
+}
+function getIndicesVector(indices, vertexCount, type) {
+  const indicesType = type;
+  const values = indices instanceof Uint32Array ? indices : Uint32Array.from(indices);
+  const valueOffsets = new Int32Array(vertexCount + 1);
+  if (vertexCount > 0) {
+    valueOffsets.fill(values.length, 1);
+  }
+  const nullBitmap = new Uint8Array(Math.ceil(vertexCount / 8));
+  if (vertexCount > 0) {
+    nullBitmap[0] = 1;
+  }
+  const valuesData = new arrow9.Data(
+    indicesType.children[0].type,
+    0,
+    values.length,
+    0,
+    { [arrow9.BufferType.DATA]: values }
+  );
+  const indicesData = new arrow9.Data(
+    indicesType,
+    0,
+    vertexCount,
+    Math.max(0, vertexCount - 1),
+    {
+      [arrow9.BufferType.OFFSET]: valueOffsets,
+      [arrow9.BufferType.VALIDITY]: nullBitmap
+    },
+    [valuesData]
+  );
+  return new arrow9.Vector([indicesData]);
+}
+function getMeshArrowMetadata(options) {
+  const metadata = { ...options.schema?.metadata };
+  if (options.topology) {
+    metadata.topology ||= options.topology;
+  }
+  if (Number.isFinite(options.mode)) {
+    metadata.mode ||= String(options.mode);
+  }
+  if (options.boundingBox) {
+    metadata.boundingBox ||= JSON.stringify(options.boundingBox);
+  }
+  return deserializeArrowMetadata(metadata);
+}
+
+// src/schema-utils/lib/mesh/convert-table-to-mesh.ts
+var arrow10 = __toESM(require("apache-arrow"), 1);
+function convertTableToMesh(table) {
+  switch (table.shape) {
+    // case 'columnar-table':
+    //   return convertColumnarTableToMesh(table);
+    case "arrow-table":
+      return convertArrowTableToMesh(table);
+    default:
+      throw new Error(table.shape);
+  }
+}
+function convertArrowTableToMesh(table) {
+  const arrowTable = table.data;
+  const schema = serializeArrowSchema(arrowTable.schema);
+  const fields = schema.fields;
+  const attributes = {};
+  const columns = [];
+  for (const field of fields) {
+    const { name } = field;
+    if (name === "indices") {
+      continue;
+    }
+    const attributeData = arrowTable.getChild(name);
+    const size = getFixedSizeListSize(attributeData);
+    const typedArray = getAttributeTypedArray(attributeData, size);
+    const metadata = getMeshAttributeMetadata(field.metadata);
+    const value = metadata.componentType === "float16" ? restoreFloat16Array(typedArray) : typedArray;
+    const shared = columns.find(
+      (column) => column.data.length === attributeData.data.length && attributes[column.name].value.constructor === value.constructor && column.data.every((chunk, index) => shareArrowStorage(chunk, attributeData.data[index]))
+    );
+    attributes[name] = {
+      value: shared ? attributes[shared.name].value : value,
+      size,
+      ...metadata
+    };
+    if (!shared) columns.push({ name, data: attributeData.data });
+  }
+  fixMetadata(schema);
+  const topology = schema.metadata.topology;
+  const mode = getMeshMode(schema);
+  const indices = getIndices(arrowTable);
+  const boundingBox = attributes.POSITION?.transform?.type === "quantization" ? getMeshBoundingBoxFromSchema(schema) || getMeshBoundingBox(attributes) : getMeshBoundingBox(attributes);
+  return {
+    schema,
+    attributes,
+    topology,
+    mode,
+    indices,
+    header: {
+      vertexCount: arrowTable.numRows,
+      boundingBox: boundingBox ?? void 0
+    }
+  };
+}
+function getMeshBoundingBoxFromSchema(schema) {
+  const serializedBoundingBox = schema.metadata?.boundingBox;
+  if (!serializedBoundingBox) {
+    return null;
+  }
+  try {
+    const boundingBox = JSON.parse(serializedBoundingBox);
+    if (Array.isArray(boundingBox) && boundingBox.length === 2 && boundingBox.every(
+      (corner) => Array.isArray(corner) && corner.length === 3 && corner.every((value) => typeof value === "number")
+    )) {
+      return boundingBox;
+    }
+  } catch {
+  }
+  return null;
+}
+function getMeshAttributeMetadata(metadata = {}) {
+  const result = {};
+  if (metadata.byteOffset !== void 0) {
+    result.byteOffset = Number(metadata.byteOffset);
+  }
+  if (metadata.byteStride !== void 0) {
+    result.byteStride = Number(metadata.byteStride);
+  }
+  if (metadata.normalized !== void 0) {
+    result.normalized = metadata.normalized === "true";
+  }
+  if (metadata.componentType === "float16") {
+    result.componentType = "float16";
+  }
+  if (metadata["loaders.gl.transform"]) {
+    try {
+      const transform = JSON.parse(metadata["loaders.gl.transform"]);
+      if (isMeshAttributeTransform(transform)) {
+        result.transform = transform;
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function isMeshAttributeTransform(value) {
+  if (!value || typeof value !== "object" || !("type" in value)) {
+    return false;
+  }
+  const transform = value;
+  if (transform.type === "octahedron") {
+    return Number.isInteger(transform.bits) && transform.bits >= 1 && transform.bits <= 30;
+  }
+  return transform.type === "quantization" && Number.isInteger(transform.bits) && transform.bits >= 1 && transform.bits <= 30 && Array.isArray(transform.origin) && transform.origin.every((component) => typeof component === "number") && typeof transform.range === "number";
+}
+function fixMetadata(schema) {
+  schema.metadata ||= {};
+  schema.metadata.topology ||= "point-list";
+  schema.metadata.mode ||= "0";
+}
+function getAttributeTypedArray(attributeData, size) {
+  if (!(attributeData.type instanceof arrow10.FixedSizeList)) {
+    return attributeData.toArray();
+  }
+  const values = attributeData.data[0].children[0].values;
+  const TypedArrayConstructor = values.constructor;
+  const typedArray = new TypedArrayConstructor(attributeData.length * size);
+  let targetOffset = 0;
+  for (const data of attributeData.data) {
+    const child = data.children[0];
+    const sourceLength = data.length * size;
+    const sourceOffset = child.offset || data.offset * size;
+    const sourceStart = sourceOffset + sourceLength <= child.values.length ? sourceOffset : 0;
+    const source = child.values.subarray(sourceStart, sourceStart + sourceLength);
+    typedArray.set(source, targetOffset);
+    targetOffset += sourceLength;
+  }
+  return typedArray;
+}
+function restoreFloat16Array(typedArray) {
+  const result = createFloat16Array(typedArray.length);
+  for (let index = 0; index < typedArray.length; index++) {
+    setFloat16Value(result, index, getFloat16Value(typedArray, index));
+  }
+  return result;
+}
+function getMeshMode(schema) {
+  const mode = Number(schema.metadata?.mode);
+  return Number.isFinite(mode) ? mode : 0;
+}
+function getIndices(arrowTable) {
+  const indicesColumn = arrowTable.getChild("indices");
+  if (!indicesColumn?.isValid(0)) {
+    return void 0;
+  }
+  const indicesData = indicesColumn.data[0];
+  const valueOffsets = indicesData.valueOffsets;
+  const start = valueOffsets[indicesData.offset];
+  const end = valueOffsets[indicesData.offset + 1];
+  const values = indicesData.children[0].values.subarray(start, end);
+  return { value: values, size: 1 };
+}
+function shareArrowStorage(left, right) {
+  const rightBuffers = Object.values(right.buffers);
+  return left.type.toString() === right.type.toString() && left.offset === right.offset && left.length === right.length && left.nullCount === right.nullCount && left.dictionary === right.dictionary && Object.values(left.buffers).every((buffer, index) => {
+    const other = rightBuffers[index];
+    return buffer === other || Boolean(
+      buffer && other && buffer.buffer === other.buffer && buffer.byteOffset === other.byteOffset && buffer.byteLength === other.byteLength
+    );
+  }) && left.children.length === right.children.length && left.children.every((child, index) => shareArrowStorage(child, right.children[index]));
+}
+
+// src/schema-utils/lib/mesh/deduce-mesh-schema.ts
+function deduceMeshSchema(attributes, metadata = {}) {
+  const fields = deduceMeshFields(attributes);
+  return { fields, metadata };
+}
+function deduceMeshField(name, attribute, optionalMetadata) {
+  const type = attribute.componentType || getDataTypeFromTypedArray(attribute.value);
+  const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
+  const dataType = attribute.size === 1 ? type : { type: "fixed-size-list", listSize: attribute.size, children: [{ name: "value", type }] };
+  return {
+    name,
+    type: dataType,
+    nullable: false,
+    metadata
+  };
+}
+function deduceMeshFields(attributes) {
+  const fields = [];
+  for (const attributeName in attributes) {
+    const attribute = attributes[attributeName];
+    fields.push(deduceMeshField(attributeName, attribute));
+  }
+  return fields;
+}
+function makeMeshAttributeMetadata(attribute) {
+  const result = {};
+  if ("byteOffset" in attribute) {
+    result.byteOffset = attribute.byteOffset.toString(10);
+  }
+  if ("byteStride" in attribute) {
+    result.byteStride = attribute.byteStride.toString(10);
+  }
+  if ("normalized" in attribute) {
+    result.normalized = attribute.normalized.toString();
+  }
+  if (attribute.componentType) {
+    result.componentType = attribute.componentType;
+  }
+  if (attribute.transform) {
+    result["loaders.gl.transform"] = JSON.stringify(attribute.transform);
+  }
+  return result;
+}
+
+// src/schema-utils/lib/table/arrow-api/enum.ts
+var Type = /* @__PURE__ */ ((Type2) => {
+  Type2[Type2["NONE"] = 0] = "NONE";
+  Type2[Type2["Null"] = 1] = "Null";
+  Type2[Type2["Int"] = 2] = "Int";
+  Type2[Type2["Float"] = 3] = "Float";
+  Type2[Type2["Binary"] = 4] = "Binary";
+  Type2[Type2["Utf8"] = 5] = "Utf8";
+  Type2[Type2["Bool"] = 6] = "Bool";
+  Type2[Type2["Decimal"] = 7] = "Decimal";
+  Type2[Type2["Date"] = 8] = "Date";
+  Type2[Type2["Time"] = 9] = "Time";
+  Type2[Type2["Timestamp"] = 10] = "Timestamp";
+  Type2[Type2["Interval"] = 11] = "Interval";
+  Type2[Type2["List"] = 12] = "List";
+  Type2[Type2["Struct"] = 13] = "Struct";
+  Type2[Type2["Union"] = 14] = "Union";
+  Type2[Type2["FixedSizeBinary"] = 15] = "FixedSizeBinary";
+  Type2[Type2["FixedSizeList"] = 16] = "FixedSizeList";
+  Type2[Type2["Map"] = 17] = "Map";
+  Type2[Type2["Dictionary"] = -1] = "Dictionary";
+  Type2[Type2["Int8"] = -2] = "Int8";
+  Type2[Type2["Int16"] = -3] = "Int16";
+  Type2[Type2["Int32"] = -4] = "Int32";
+  Type2[Type2["Int64"] = -5] = "Int64";
+  Type2[Type2["Uint8"] = -6] = "Uint8";
+  Type2[Type2["Uint16"] = -7] = "Uint16";
+  Type2[Type2["Uint32"] = -8] = "Uint32";
+  Type2[Type2["Uint64"] = -9] = "Uint64";
+  Type2[Type2["Float16"] = -10] = "Float16";
+  Type2[Type2["Float32"] = -11] = "Float32";
+  Type2[Type2["Float64"] = -12] = "Float64";
+  Type2[Type2["DateDay"] = -13] = "DateDay";
+  Type2[Type2["DateMillisecond"] = -14] = "DateMillisecond";
+  Type2[Type2["TimestampSecond"] = -15] = "TimestampSecond";
+  Type2[Type2["TimestampMillisecond"] = -16] = "TimestampMillisecond";
+  Type2[Type2["TimestampMicrosecond"] = -17] = "TimestampMicrosecond";
+  Type2[Type2["TimestampNanosecond"] = -18] = "TimestampNanosecond";
+  Type2[Type2["TimeSecond"] = -19] = "TimeSecond";
+  Type2[Type2["TimeMillisecond"] = -20] = "TimeMillisecond";
+  Type2[Type2["TimeMicrosecond"] = -21] = "TimeMicrosecond";
+  Type2[Type2["TimeNanosecond"] = -22] = "TimeNanosecond";
+  Type2[Type2["DenseUnion"] = -23] = "DenseUnion";
+  Type2[Type2["SparseUnion"] = -24] = "SparseUnion";
+  Type2[Type2["IntervalDayTime"] = -25] = "IntervalDayTime";
+  Type2[Type2["IntervalYearMonth"] = -26] = "IntervalYearMonth";
+  return Type2;
+})(Type || {});
+
+// src/schema-utils/lib/table/arrow-api/arrow-like-type.ts
+var DataType3 = class {
+  static isNull(x) {
+    return x && x.typeId === 1 /* Null */;
+  }
+  static isInt(x) {
+    return x && x.typeId === 2 /* Int */;
+  }
+  static isFloat(x) {
+    return x && x.typeId === 3 /* Float */;
+  }
+  static isBinary(x) {
+    return x && x.typeId === 4 /* Binary */;
+  }
+  static isUtf8(x) {
+    return x && x.typeId === 5 /* Utf8 */;
+  }
+  static isBool(x) {
+    return x && x.typeId === 6 /* Bool */;
+  }
+  static isDecimal(x) {
+    return x && x.typeId === 7 /* Decimal */;
+  }
+  static isDate(x) {
+    return x && x.typeId === 8 /* Date */;
+  }
+  static isTime(x) {
+    return x && x.typeId === 9 /* Time */;
+  }
+  static isTimestamp(x) {
+    return x && x.typeId === 10 /* Timestamp */;
+  }
+  static isInterval(x) {
+    return x && x.typeId === 11 /* Interval */;
+  }
+  static isList(x) {
+    return x && x.typeId === 12 /* List */;
+  }
+  static isStruct(x) {
+    return x && x.typeId === 13 /* Struct */;
+  }
+  static isUnion(x) {
+    return x && x.typeId === 14 /* Union */;
+  }
+  static isFixedSizeBinary(x) {
+    return x && x.typeId === 15 /* FixedSizeBinary */;
+  }
+  static isFixedSizeList(x) {
+    return x && x.typeId === 16 /* FixedSizeList */;
+  }
+  static isMap(x) {
+    return x && x.typeId === 17 /* Map */;
+  }
+  static isDictionary(x) {
+    return x && x.typeId === -1 /* Dictionary */;
+  }
+  get typeId() {
+    return 0 /* NONE */;
+  }
+  // get ArrayType(): AnyArrayType {
+  //   return Int8Array;
+  // }
+  // get ArrayType() { return Array; }
+  compareTo(other) {
+    return this === other;
+  }
+};
+
+// src/schema-utils/lib/table/batch-builder/arrow-table-builder.ts
+var arrow11 = __toESM(require("apache-arrow"), 1);
+var ArrowTableBuilder = class {
+  schema;
+  arrowSchema;
+  arrowBuilders;
+  length;
+  constructor(schema, options) {
+    this.arrowSchema = convertSchemaToArrow(schema, options);
+    this.schema = options?.viewTypes && options.viewTypes !== "never" ? convertArrowToSchema(this.arrowSchema) : schema;
+    this.arrowBuilders = this.arrowSchema.fields.map(
+      (field) => arrow11.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 arrow11.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 arrow11.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 && arrowRecordBatch.numRows === 0) {
+      return null;
+    }
+    return {
+      shape: "arrow-table",
+      batchType: "data",
+      length: arrowRecordBatch.numRows,
+      schema: this.schema,
+      data: new arrow11.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 arrow11.Table(arrowRecordBatch)
+    };
+  }
+  /** Extract a record batch flushing the currently accumulated data in the builders */
+  _getArrowRecordBatch() {
+    const { arrowBuilders, arrowSchema } = this;
+    const arrowDatas = arrowBuilders.map((builder) => builder.flush());
+    const length = arrowDatas[0]?.length || this.length;
+    this.length = 0;
+    const structField = new arrow11.Struct(arrowSchema.fields);
+    const arrowStructData = new arrow11.Data(structField, 0, length, 0, void 0, arrowDatas);
+    const arrowRecordBatch = new arrow11.RecordBatch(arrowSchema, arrowStructData);
+    return arrowRecordBatch;
+  }
+};
+
+// src/schema-utils/lib/table/arrow-api/get-type-info.ts
+function getTypeInfo(arrowTypeLike) {
+  return {
+    typeId: arrowTypeLike.typeId,
+    ArrayType: arrowTypeLike.ArrayType,
+    typeName: arrowTypeLike.toString(),
+    typeEnumName: getTypeKey(arrowTypeLike.typeId),
+    precision: arrowTypeLike.precision
+  };
+}
+var ReverseType = null;
+function getTypeKey(typeKey) {
+  if (!ReverseType) {
+    ReverseType = {};
+    for (const key in Type) {
+      ReverseType[Type[key]] = key;
+    }
+  }
+  return ReverseType[typeKey];
+}
+
+// src/schema-utils/lib/utils/async-queue.ts
+var ArrayQueue = class extends Array {
+  enqueue(value) {
+    return this.push(value);
+  }
+  dequeue() {
+    return this.shift();
+  }
+};
+var AsyncQueue = class {
+  _values;
+  _settlers;
+  _closed;
+  constructor() {
+    this._values = new ArrayQueue();
+    this._settlers = new ArrayQueue();
+    this._closed = false;
+  }
+  close() {
+    while (this._settlers.length > 0) {
+      this._settlers.dequeue().resolve({ done: true });
+    }
+    this._closed = true;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  enqueue(value) {
+    if (this._closed) {
+      throw new Error("Closed");
+    }
+    if (this._settlers.length > 0) {
+      if (this._values.length > 0) {
+        throw new Error("Illegal internal state");
+      }
+      const settler = this._settlers.dequeue();
+      if (value instanceof Error) {
+        settler.reject(value);
+      } else {
+        settler.resolve({ value });
+      }
+    } else {
+      this._values.enqueue(value);
+    }
+  }
+  /**
+   * @returns a Promise for an IteratorResult
+   */
+  next() {
+    if (this._values.length > 0) {
+      const value = this._values.dequeue();
+      if (value instanceof Error) {
+        return Promise.reject(value);
+      }
+      return Promise.resolve({ value });
+    }
+    if (this._closed) {
+      if (this._settlers.length > 0) {
+        throw new Error("Illegal internal state");
+      }
+      return Promise.resolve({ done: true });
+    }
+    return new Promise((resolve, reject) => {
+      this._settlers.enqueue({ resolve, reject });
+    });
+  }
+};
+
+// src/schema-utils/lib/mesh/point-cloud-tiler.ts
+var PointCloudTiler = class {
+  /** Resolves after validation, bounds calculation and root sampling. */
+  ready;
+  /** Exact number of validated source rows. */
+  sourcePointCount = 0;
+  /** Number of source point rows, available after ready. */
+  get pointCount() {
+    return this.sourcePointCount;
+  }
+  /** Lifetime cancellation, including close(). */
+  controller = new AbortController();
+  /** Resolved source and allocation limits. */
+  options;
+  /** Combined caller and lifetime cancellation. */
+  signal;
+  /** Source typed attributes, retained without copying Mesh inputs. */
+  mesh = null;
+  /** Discovered octree nodes. */
+  nodes = /* @__PURE__ */ new Map();
+  /** Live row-index bytes including intermediate allocations. */
+  indexBytes = 0;
+  /** Packed source bytes per row. */
+  pointByteLength = 0;
+  /** Starts indexing one decoded point dataset with explicit allocation limits. */
+  constructor(input, options = {}) {
+    this.options = {
+      nodePointLimit: options.nodePointLimit ?? 5e4,
+      maximumDepth: options.maximumDepth ?? 16,
+      maxInputBytes: options.maxInputBytes ?? 512 * 1024 * 1024,
+      maxIndexBytes: options.maxIndexBytes ?? 128 * 1024 * 1024,
+      maxTileBytes: options.maxTileBytes ?? 64 * 1024 * 1024,
+      maxNodes: options.maxNodes ?? 1e5
+    };
+    for (const [name, value] of Object.entries(this.options)) {
+      if (!Number.isSafeInteger(value) || value < (name === "maximumDepth" ? 0 : 1))
+        throw new Error(`PointCloudTiler: invalid ${name}`);
+    }
+    if (this.options.maximumDepth > 24 || this.options.nodePointLimit > 1e6)
+      throw new Error("PointCloudTiler: maximumDepth must be <= 24 and nodePointLimit <= 1000000");
+    this.signal = options.signal ? AbortSignal.any([options.signal, this.controller.signal]) : this.controller.signal;
+    this.ready = this.initialize(input).catch((error) => {
+      this.close();
+      throw error;
+    });
+  }
+  /** Returns the root after indexing, without discovering its children. */
+  async getRootNode() {
+    await this.ready;
+    return this.getNode("r").node;
+  }
+  /** Returns checked source-owned metadata for an already discovered node. */
+  async getNodeMetadata(id) {
+    await this.ready;
+    return this.getNode(id).node;
+  }
+  /** Partitions only the requested node, in deterministic octant order. */
+  async getChildNodes(id) {
+    await this.ready;
+    const state = this.getNode(id);
+    if (!state.childrenPromise) state.childrenPromise = this.splitNode(state);
+    return state.childrenPromise;
+  }
+  /** Splits one node exactly once, sharing its result with concurrent callers. */
+  async splitNode(state) {
+    const id = state.node.id;
+    if (state.children) return state.children;
+    const groups = Array.from({ length: 8 }, () => 0);
+    const midpoint = state.node.bounds[0].map(
+      (value, axis) => value + (state.node.bounds[1][axis] - value) / 2
+    );
+    for (let index = 0; index < state.remaining.length; index++) {
+      if (index % 65536 === 0) await this.checkpoint();
+      groups[this.getOctant(state.remaining[index], midpoint)]++;
+    }
+    if (this.nodes.size + groups.filter((count) => count > 0).length > this.options.maxNodes)
+      throw new Error("PointCloudTiler: node budget exceeded");
+    const children = [];
+    const partitions = [];
+    try {
+      for (const count of groups) partitions.push(this.allocateRows(count));
+      const offsets = new Uint32Array(8);
+      for (let index = 0; index < state.remaining.length; index++) {
+        if (index % 65536 === 0) await this.checkpoint();
+        const row = state.remaining[index];
+        const octant = this.getOctant(row, midpoint);
+        partitions[octant][offsets[octant]++] = row;
+      }
+      for (let octant = 0; octant < 8; octant++) {
+        if (!partitions[octant].length) continue;
+        const bounds = state.node.bounds.map((corner) => [...corner]);
+        for (let axis = 0; axis < 3; axis++)
+          bounds[octant & 4 >> axis ? 0 : 1][axis] = midpoint[axis];
+        const child = await this.createNode(`${id}${octant}`, bounds, partitions[octant]);
+        partitions[octant] = new Uint32Array(0);
+        children.push(child.node);
+      }
+      this.releaseRows(state.remaining);
+      state.remaining = new Uint32Array(0);
+      state.children = Object.freeze(children);
+      return state.children;
+    } catch (error) {
+      this.close();
+      throw error;
+    }
+  }
+  /** Gathers a fresh packed Mesh; source row IDs and attribute component widths are preserved. */
+  async getTileMesh(id) {
+    await this.ready;
+    const state = this.getNode(id);
+    const byteLength = state.rows.length * this.pointByteLength;
+    if (byteLength > this.options.maxTileBytes)
+      throw new Error("PointCloudTiler: tile byte budget exceeded");
+    const attributes = {};
+    const gatheredValues = /* @__PURE__ */ new Map();
+    for (const [name, attribute] of Object.entries(this.mesh.attributes)) {
+      const storageKey = getAttributeStorageKey(attribute);
+      const sharedValue = gatheredValues.get(attribute.value.buffer)?.get(storageKey);
+      if (sharedValue) {
+        attributes[name] = { ...attribute, value: sharedValue, byteOffset: 0, byteStride: 0 };
+        continue;
+      }
+      const Constructor = attribute.value.constructor;
+      const value = new Constructor(state.rows.length * attribute.size);
+      const sourceBytes = new Uint8Array(
+        attribute.value.buffer,
+        attribute.value.byteOffset,
+        attribute.value.byteLength
+      );
+      const targetBytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+      const bytesPerElement = attribute.value.BYTES_PER_ELEMENT;
+      const rowBytes = attribute.size * bytesPerElement;
+      const stride = attribute.byteStride || rowBytes;
+      for (let index = 0; index < state.rows.length; index++) {
+        if (index % 65536 === 0) await this.checkpoint();
+        const offset = (attribute.byteOffset || 0) + state.rows[index] * stride;
+        targetBytes.set(sourceBytes.subarray(offset, offset + rowBytes), index * rowBytes);
+      }
+      const storage = gatheredValues.get(attribute.value.buffer) ?? /* @__PURE__ */ new Map();
+      storage.set(storageKey, value);
+      gatheredValues.set(attribute.value.buffer, storage);
+      attributes[name] = { ...attribute, value, byteOffset: 0, byteStride: 0 };
+    }
+    return {
+      ...this.mesh,
+      attributes,
+      topology: "point-list",
+      mode: 0,
+      indices: void 0,
+      header: {
+        vertexCount: state.rows.length,
+        boundingBox: state.node.bounds.map((corner) => [...corner])
+      },
+      loaderData: { ...this.mesh.loaderData, pointCloudTileId: id }
+    };
+  }
+  /** Releases retained attributes and index state and cancels subsequent operations. */
+  close() {
+    this.controller.abort(new Error("PointCloudTiler: closed"));
+    this.mesh = null;
+    this.nodes.clear();
+    this.indexBytes = 0;
+  }
+  /** Validates the decoded profile and creates a root cube from finite native coordinates. */
+  async initialize(input) {
+    this.signal.throwIfAborted();
+    if ("shape" in input) {
+      const buffers2 = /* @__PURE__ */ new Set();
+      let arrowBytes = 0;
+      const checkData = (data) => {
+        if (data.nullCount)
+          throw new Error("PointCloudTiler: null point attributes require an explicit mapping");
+        for (const view of Object.values(data.buffers)) {
+          if (view && !buffers2.has(view.buffer)) {
+            buffers2.add(view.buffer);
+            arrowBytes += view.buffer.byteLength;
+          }
+        }
+        for (const child of data.children) checkData(child);
+        if (data.dictionary)
+          for (const dictionaryData of data.dictionary.data) checkData(dictionaryData);
+      };
+      for (const batch of input.data.batches) checkData(batch.data);
+      if (arrowBytes > this.options.maxInputBytes)
+        throw new Error("PointCloudTiler: input byte budget exceeded");
+      for (const column of input.data.schema.fields) {
+        if (input.data.getChild(column.name)?.nullCount)
+          throw new Error("PointCloudTiler: null point attributes require an explicit mapping");
+      }
+    }
+    const mesh = "shape" in input ? convertTableToMesh(input) : input;
+    if (mesh.topology !== "point-list" || mesh.indices)
+      throw new Error("PointCloudTiler: unindexed point-list input required");
+    const position = mesh.attributes.POSITION;
+    if (!position || position.size !== 3 || !(position.value instanceof Float32Array || position.value instanceof Float64Array) || position.transform || position.normalized || position.componentType === "float16")
+      throw new Error("PointCloudTiler: POSITION requires decoded floating-point XYZ");
+    if (!mesh.header && (position.byteOffset || position.byteStride))
+      throw new Error("PointCloudTiler: strided POSITION requires vertexCount");
+    const count = mesh.header?.vertexCount ?? position.value.length / 3;
+    if (!Number.isSafeInteger(count) || count < 0 || count > 4294967295)
+      throw new Error("PointCloudTiler: invalid point count");
+    let inputBytes = 0;
+    const storageKeys = /* @__PURE__ */ new Map();
+    const buffers = /* @__PURE__ */ new Set();
+    for (const attribute of Object.values(mesh.attributes)) {
+      this.validateAttribute(attribute, count);
+      if (!buffers.has(attribute.value.buffer)) {
+        buffers.add(attribute.value.buffer);
+        inputBytes += attribute.value.buffer.byteLength;
+      }
+      const storage = storageKeys.get(attribute.value.buffer) ?? /* @__PURE__ */ new Set();
+      const storageKey = getAttributeStorageKey(attribute);
+      if (!storage.has(storageKey)) {
+        this.pointByteLength += attribute.size * attribute.value.BYTES_PER_ELEMENT;
+        storage.add(storageKey);
+        storageKeys.set(attribute.value.buffer, storage);
+      }
+    }
+    if (inputBytes > this.options.maxInputBytes)
+      throw new Error("PointCloudTiler: input byte budget exceeded");
+    this.mesh = mesh;
+    this.sourcePointCount = count;
+    const rows = this.allocateRows(count);
+    const minimum = [Infinity, Infinity, Infinity];
+    const maximum = [-Infinity, -Infinity, -Infinity];
+    for (let row = 0; row < count; row++) {
+      if (row % 65536 === 0) await this.checkpoint();
+      rows[row] = row;
+      for (let axis = 0; axis < 3; axis++) {
+        const coordinate = this.getCoordinate(row, axis);
+        if (!Number.isFinite(coordinate)) throw new Error("PointCloudTiler: nonfinite position");
+        minimum[axis] = Math.min(minimum[axis], coordinate);
+        maximum[axis] = Math.max(maximum[axis], coordinate);
+      }
+    }
+    if (!count) {
+      minimum.fill(0);
+      maximum.fill(0);
+    }
+    const width = Math.max(...minimum.map((value, axis) => maximum[axis] - value));
+    if (!Number.isFinite(width)) throw new Error("PointCloudTiler: coordinate extent overflow");
+    for (let axis = 0; axis < 3; axis++) maximum[axis] = minimum[axis] + width;
+    if (!maximum.every(Number.isFinite) || !Number.isFinite(Math.hypot(width, width, width)))
+      throw new Error("PointCloudTiler: coordinate extent overflow");
+    await this.createNode("r", [minimum, maximum], rows);
+    this.signal.throwIfAborted();
+  }
+  /** Selects at most one source row per grid cell; rejects no input rows. */
+  async createNode(id, bounds, inputRows) {
+    const terminal = id.length - 1 >= this.options.maximumDepth || bounds[0].every((value, axis) => value === bounds[1][axis]) || inputRows.length <= this.options.nodePointLimit;
+    let rows = inputRows;
+    let remaining = new Uint32Array(0);
+    if (!terminal) {
+      const resolution = Math.ceil(Math.cbrt(this.options.nodePointLimit));
+      const cells = /* @__PURE__ */ new Set();
+      const selected = this.allocateRows(Math.min(inputRows.length, this.options.nodePointLimit));
+      const deferred = this.allocateRows(inputRows.length);
+      let selectedCount = 0;
+      let deferredCount = 0;
+      for (let index = 0; index < inputRows.length; index++) {
+        if (index % 65536 === 0) await this.checkpoint();
+        const row = inputRows[index];
+        let cell = 0;
+        for (let axis = 0; axis < 3; axis++) {
+          const component = Math.min(
+            resolution - 1,
+            Math.floor(
+              (this.getCoordinate(row, axis) - bounds[0][axis]) / (bounds[1][axis] - bounds[0][axis]) * resolution
+            )
+          );
+          cell = cell * resolution + component;
+        }
+        if (selectedCount < selected.length && !cells.has(cell)) {
+          cells.add(cell);
+          selected[selectedCount++] = row;
+        } else deferred[deferredCount++] = row;
+      }
+      rows = selected.subarray(0, selectedCount);
+      remaining = deferred.subarray(0, deferredCount);
+      this.releaseRows(inputRows);
+    }
+    const state = {
+      node: {
+        id,
+        level: id.length - 1,
+        pointCount: rows.length,
+        bounds,
+        geometricError: remaining.length ? Math.hypot(...bounds[0].map((value, axis) => bounds[1][axis] - value)) : 0
+      },
+      rows,
+      remaining
+    };
+    Object.freeze(bounds[0]);
+    Object.freeze(bounds[1]);
+    Object.freeze(bounds);
+    Object.freeze(state.node);
+    this.signal.throwIfAborted();
+    if (this.nodes.size >= this.options.maxNodes)
+      throw new Error("PointCloudTiler: node budget exceeded");
+    this.nodes.set(id, state);
+    return state;
+  }
+  /** Reads a floating-point coordinate from a checked packed or strided accessor. */
+  getCoordinate(row, axis) {
+    const attribute = this.mesh.attributes.POSITION;
+    return Number(
+      attribute.value[(attribute.byteOffset || 0) / attribute.value.BYTES_PER_ELEMENT + row * (attribute.byteStride || 3 * attribute.value.BYTES_PER_ELEMENT) / attribute.value.BYTES_PER_ELEMENT + axis]
+    );
+  }
+  /** Validates a typed attribute's alignment and coverage before indexing or gathering. */
+  validateAttribute(attribute, count) {
+    const bytes = attribute.value?.BYTES_PER_ELEMENT;
+    const offset = attribute.byteOffset ?? 0;
+    const stride = attribute.byteStride || attribute.size * bytes;
+    if (!bytes || !Number.isSafeInteger(attribute.size) || attribute.size < 1 || !Number.isSafeInteger(offset) || offset < 0 || offset % bytes || !Number.isSafeInteger(stride) || stride < attribute.size * bytes || stride % bytes || count && offset + (count - 1) * stride + attribute.size * bytes > attribute.value.byteLength)
+      throw new Error("PointCloudTiler: invalid attribute layout");
+  }
+  /** Allocates counted row-index storage before any allocation exceeds the live budget. */
+  allocateRows(count) {
+    if (count * 4 > this.options.maxIndexBytes - this.indexBytes)
+      throw new Error("PointCloudTiler: index byte budget exceeded");
+    const rows = new Uint32Array(count);
+    this.indexBytes += rows.byteLength;
+    return rows;
+  }
+  /** Releases the allocation underlying a row subview. */
+  releaseRows(rows) {
+    this.indexBytes -= rows.buffer.byteLength;
+  }
+  /** Retrieves source-owned state, rejecting unknown or closed tiles. */
+  getNode(id) {
+    this.signal.throwIfAborted();
+    const state = this.nodes.get(id);
+    if (!state) throw new Error(`PointCloudTiler: unknown tile ${id}`);
+    return state;
+  }
+  /** Resolves deterministic octant ownership, assigning midpoint boundaries to the upper child. */
+  getOctant(row, midpoint) {
+    let octant = 0;
+    for (let axis = 0; axis < 3; axis++)
+      if (this.getCoordinate(row, axis) >= midpoint[axis]) octant |= 4 >> axis;
+    return octant;
+  }
+  /** Yields to the event loop and checks cancellation without public-network or platform APIs. */
+  async checkpoint() {
+    this.signal.throwIfAborted();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    this.signal.throwIfAborted();
+  }
+};
+function getAttributeStorageKey(attribute) {
+  return [
+    attribute.value.constructor.name,
+    attribute.value.byteOffset,
+    attribute.value.byteLength,
+    attribute.size,
+    attribute.byteOffset ?? 0,
+    attribute.byteStride || attribute.size * attribute.value.BYTES_PER_ELEMENT
+  ].join(":");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrowLikeDataType,
+  ArrowLikeField,
+  ArrowLikeSchema,
+  ArrowLikeTable,
+  ArrowTableBuilder,
+  AsyncQueue,
+  ColumnarTableBatchAggregator,
+  PointCloudTiler,
+  RowTableBatchAggregator,
+  TABLE_CONVERTERS,
+  TableBatchBuilder,
+  TableConverter,
+  convert,
+  convertArrowToSchema,
+  convertArrowToTable,
+  convertBatch,
+  convertBatches,
+  convertMeshToTable,
+  convertSchemaToArrow,
+  convertTable,
+  convertTableToArrow,
+  convertTableToMesh,
+  convertToArrayRow,
+  convertToObjectRow,
+  deduceMeshField,
+  deduceMeshSchema,
+  deduceTableSchema,
+  deserializeArrowField,
+  deserializeArrowMetadata,
+  deserializeArrowSchema,
+  deserializeArrowType,
+  getArrayTypeFromDataType,
+  getArrowViewTypeSupport,
+  getDataTypeFromArray,
+  getMeshBoundingBox,
+  getMeshSize,
+  getTableCell,
+  getTableCellAt,
+  getTableColumnIndex,
+  getTableColumnName,
+  getTableLength,
+  getTableNumCols,
+  getTableRowAsArray,
+  getTableRowAsObject,
+  getTableRowShape,
+  getTypeInfo,
+  isArrayRowTable,
+  isArrowTable,
+  isColumnarTable,
+  isGeoJSONTable,
+  isObjectRowTable,
+  isTable,
+  makeArrayRowIterator,
+  makeArrowRecordBatchIterator,
+  makeArrowTableBatchIterator,
+  makeBatchFromTable,
+  makeMeshArrowTable,
+  makeMeshAttributeMetadata,
+  makeObjectRowIterator,
+  makeRowIterator,
+  makeTableBatchIterator,
+  makeTableFromBatches,
+  makeTableFromData,
+  queryArrowTable,
+  selectArrowTableRows,
+  serializeArrowField,
+  serializeArrowMetadata,
+  serializeArrowSchema,
+  serializeArrowType
+});