@loaders.gl/services 5.0.0-alpha.3 → 5.0.0-alpha.5

package/dist/index.cjs

@@ -738,7 +738,7 @@ function writeCoordinate(writer, coordinate, options) {
     writer.writeDoubleLE(coordinate[2]);
   }
   if (options.hasM) {
-    writer.writeDoubleLE(coordinate[3]);
+    writer.writeDoubleLE(coordinate[options.hasZ ? 3 : 2]);
   }
 }
 function getPointSize(options) {
@@ -858,7 +858,10 @@ function encodeGeometryCollection(collection, options) {
   writeWkbType(writer, 7 /* GeometryCollection */, options);
   writer.writeUInt32LE(collection.geometries.length);
   for (const geometry of collection.geometries) {
-    const arrayBuffer = convertGeometryToWKB(geometry, options);
+    const arrayBuffer = convertGeometryToWKB(
+      geometry,
+      getGeometryCollectionChildOptions(geometry, options)
+    );
     writer.writeBuffer(arrayBuffer);
   }
   return writer.arrayBuffer;
@@ -866,10 +869,18 @@ function encodeGeometryCollection(collection, options) {
 function getGeometryCollectionSize(collection, options) {
   let size = 1 + 4 + 4;
   for (const geometry of collection.geometries) {
-    size += getGeometrySize(geometry, options);
+    size += getGeometrySize(geometry, getGeometryCollectionChildOptions(geometry, options));
   }
   return size;
 }
+function getGeometryCollectionChildOptions(geometry, parentOptions) {
+  const dimension = geometry.__geoarrowDimension;
+  if (!dimension) return parentOptions;
+  return {
+    hasZ: dimension === "xyz" || dimension === "xyzm",
+    hasM: dimension === "xym" || dimension === "xyzm"
+  };
+}
 function writeWkbType(writer, geometryType, options) {
   const { hasZ, hasM, srid } = options;
   let dimensionType = 0;
@@ -908,7 +919,7 @@ var init_convert_geometry_to_wkb = __esm({
   }
 });
 
-// ../gis/src/lib/geoarrow/metadata-utils.ts
+// ../schema/src/metadata.ts
 function getMetadataValue(metadata, key) {
   return metadata instanceof Map ? metadata.get(key) || null : metadata[key] || null;
 }
@@ -919,19 +930,60 @@ function setMetadataValue(metadata, key, value) {
     metadata[key] = value;
   }
 }
+var init_metadata = __esm({
+  "../schema/src/metadata.ts"() {
+    "use strict";
+  }
+});
+
+// ../schema/src/categories/category-mesh.ts
+var arrow, meshArrowSchema, indexedMeshArrowSchema;
+var init_category_mesh = __esm({
+  "../schema/src/categories/category-mesh.ts"() {
+    "use strict";
+    arrow = __toESM(require("apache-arrow"), 1);
+    meshArrowSchema = new arrow.Schema([
+      new arrow.Field(
+        "POSITION",
+        new arrow.FixedSizeList(3, new arrow.Field("value", new arrow.Float32(), false)),
+        false
+      )
+    ]);
+    indexedMeshArrowSchema = new arrow.Schema([
+      ...meshArrowSchema.fields,
+      new arrow.Field(
+        "indices",
+        new arrow.List(new arrow.Field("item", new arrow.Int32(), false)),
+        true
+      )
+    ]);
+  }
+});
+
+// ../schema/src/index.ts
+var init_src = __esm({
+  "../schema/src/index.ts"() {
+    "use strict";
+    init_metadata();
+    init_category_mesh();
+  }
+});
+
+// ../gis/src/lib/geoarrow/metadata-utils.ts
 var init_metadata_utils = __esm({
   "../gis/src/lib/geoarrow/metadata-utils.ts"() {
     "use strict";
+    init_src();
   }
 });
 
 // ../gis/src/lib/geoarrow/geoparquet-metadata.ts
-function getGeoMetadata(metadata) {
+function getGeoMetadata2(metadata) {
   if (!metadata) {
     return null;
   }
   const stringifiedGeoMetadata = getMetadataValue(metadata, "geo");
-  const geoMetadata = stringifiedGeoMetadata && parseJSONStringMetadata(stringifiedGeoMetadata);
+  const geoMetadata = stringifiedGeoMetadata && parseJSONStringMetadata2(stringifiedGeoMetadata);
   if (!geoMetadata) {
     return null;
   }
@@ -942,10 +994,10 @@ function getGeoMetadata(metadata) {
   }
   return geoMetadata;
 }
-function setGeoMetadata(metadata, geoMetadata) {
+function setGeoMetadata2(metadata, geoMetadata) {
   setMetadataValue(metadata, "geo", JSON.stringify(geoMetadata));
 }
-function parseJSONStringMetadata(stringifiedMetadata) {
+function parseJSONStringMetadata2(stringifiedMetadata) {
   if (!stringifiedMetadata) {
     return null;
   }
@@ -981,7 +1033,7 @@ function setWKBGeometryColumnMetadata(metadata, options = {}) {
   const geometryColumnName = options.geometryColumnName || "geometry";
   const primaryColumnName = options.primaryColumnName || geometryColumnName;
   const geometryTypes = options.geometryTypes || [];
-  const nextGeoMetadata = getGeoMetadata(metadata) || { columns: {} };
+  const nextGeoMetadata = getGeoMetadata2(metadata) || { columns: {} };
   nextGeoMetadata.version = options.version || nextGeoMetadata.version || DEFAULT_GEO_METADATA_VERSION;
   nextGeoMetadata.primary_column = primaryColumnName;
   nextGeoMetadata.columns ||= {};
@@ -991,7 +1043,7 @@ function setWKBGeometryColumnMetadata(metadata, options = {}) {
     encoding: "wkb",
     geometry_types: geometryTypes
   };
-  setGeoMetadata(metadata, nextGeoMetadata);
+  setGeoMetadata2(metadata, nextGeoMetadata);
 }
 function setWKBGeometrySchemaMetadata(schema, options = {}) {
   schema.metadata ||= {};
@@ -1016,25 +1068,42 @@ function encodeWKBGeometryValue(value) {
   throw new Error("Expected a Geometry, ArrayBuffer, ArrayBufferView, or null for WKB encoding.");
 }
 function getGeometryWKBOptions(geometry) {
-  const dimensions = getCoordinateDimensions(getGeometrySampleCoordinates(geometry));
+  const dimension = getGeometryDimension(geometry);
   return {
-    hasZ: dimensions > 2,
-    hasM: dimensions > 3
+    hasZ: dimension === "xyz" || dimension === "xyzm",
+    hasM: dimension === "xym" || dimension === "xyzm"
   };
 }
+function getGeometryDimension(geometry) {
+  const declaredDimension = geometry.__geoarrowDimension;
+  if (declaredDimension) return declaredDimension;
+  if ("geometries" in geometry) {
+    let hasZ = false;
+    let hasM = false;
+    for (const child of geometry.geometries) {
+      const childDimension = getGeometryDimension(child);
+      hasZ ||= childDimension === "xyz" || childDimension === "xyzm";
+      hasM ||= childDimension === "xym" || childDimension === "xyzm";
+    }
+    return hasZ && hasM ? "xyzm" : hasZ ? "xyz" : hasM ? "xym" : "xy";
+  }
+  const dimensions = getCoordinateDimensions(getGeometrySampleCoordinates(geometry));
+  return dimensions > 3 ? "xyzm" : dimensions > 2 ? "xyz" : "xy";
+}
 function inferGeoParquetGeometryTypes(geometries) {
   const geometryTypes = /* @__PURE__ */ new Set();
   for (const geometry of geometries) {
     if (!geometry) {
       continue;
     }
-    const dimensions = getCoordinateDimensions(getGeometrySampleCoordinates(geometry));
-    geometryTypes.add(
-      dimensions > 2 ? `${geometry.type} Z` : geometry.type
-    );
+    const dimension = getGeometryDimension(geometry);
+    geometryTypes.add(`${geometry.type}${getDimensionSuffix(dimension)}`);
   }
   return [...geometryTypes];
 }
+function getDimensionSuffix(dimension) {
+  return dimension === "xy" ? "" : ` ${dimension === "xyzm" ? "ZM" : dimension.slice(2).toUpperCase()}`;
+}
 function getCoordinateDimensions(coordinates) {
   if (!Array.isArray(coordinates)) {
     return 2;
@@ -1145,7 +1214,7 @@ function serializeArrowSchema(arrowSchema) {
   };
 }
 function deserializeArrowSchema(schema, options) {
-  return new arrow.Schema(
+  return new arrow2.Schema(
     schema.fields.map((field) => deserializeArrowField(field, options)),
     deserializeArrowMetadata(schema.metadata)
   );
@@ -1165,7 +1234,7 @@ function serializeArrowField(field) {
   };
 }
 function deserializeArrowField(field, options) {
-  return new arrow.Field(
+  return new arrow2.Field(
     field.name,
     deserializeArrowType(field.type, options),
     field.nullable,
@@ -1180,57 +1249,57 @@ function serializeArrowType(arrowType) {
     return "utf8-view";
   }
   switch (arrowType.constructor) {
-    case arrow.Null:
+    case arrow2.Null:
       return "null";
-    case arrow.Binary:
+    case arrow2.Binary:
       return "binary";
-    case arrow.FixedSizeBinary:
+    case arrow2.FixedSizeBinary:
       return {
         type: "fixed-size-binary",
         byteWidth: arrowType.byteWidth
       };
-    case arrow.Bool:
+    case arrow2.Bool:
       return "bool";
-    case arrow.Int:
+    case arrow2.Int:
       const intType = arrowType;
       return `${intType.isSigned ? "" : "u"}int${intType.bitWidth}`;
-    case arrow.Int8:
+    case arrow2.Int8:
       return "int8";
-    case arrow.Int16:
+    case arrow2.Int16:
       return "int16";
-    case arrow.Int32:
+    case arrow2.Int32:
       return "int32";
-    case arrow.Int64:
+    case arrow2.Int64:
       return "int64";
-    case arrow.Uint8:
+    case arrow2.Uint8:
       return "uint8";
-    case arrow.Uint16:
+    case arrow2.Uint16:
       return "uint16";
-    case arrow.Uint32:
+    case arrow2.Uint32:
       return "uint32";
-    case arrow.Uint64:
+    case arrow2.Uint64:
       return "uint64";
-    case arrow.Float:
+    case arrow2.Float:
       const precision = arrowType.precision;
       switch (precision) {
-        case arrow.Precision.HALF:
+        case arrow2.Precision.HALF:
           return "float16";
-        case arrow.Precision.SINGLE:
+        case arrow2.Precision.SINGLE:
           return "float32";
-        case arrow.Precision.DOUBLE:
+        case arrow2.Precision.DOUBLE:
           return "float64";
         default:
           return "float16";
       }
-    case arrow.Float16:
+    case arrow2.Float16:
       return "float16";
-    case arrow.Float32:
+    case arrow2.Float32:
       return "float32";
-    case arrow.Float64:
+    case arrow2.Float64:
       return "float64";
-    case arrow.Utf8:
+    case arrow2.Utf8:
       return "utf8";
-    case arrow.Decimal:
+    case arrow2.Decimal:
       const decimal = arrowType;
       return {
         type: "decimal",
@@ -1238,99 +1307,114 @@ function serializeArrowType(arrowType) {
         precision: decimal.precision,
         scale: decimal.scale
       };
-    case arrow.Date_:
+    case arrow2.Date_:
       const dateUnit = arrowType.unit;
-      return dateUnit === arrow.DateUnit.DAY ? "date-day" : "date-millisecond";
-    case arrow.DateDay:
+      return dateUnit === arrow2.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case arrow2.DateDay:
       return "date-day";
-    case arrow.DateMillisecond:
+    case arrow2.DateMillisecond:
       return "date-millisecond";
-    case arrow.Time:
+    case arrow2.Time:
       const timeUnit = arrowType.unit;
       switch (timeUnit) {
-        case arrow.TimeUnit.SECOND:
+        case arrow2.TimeUnit.SECOND:
           return "time-second";
-        case arrow.TimeUnit.MILLISECOND:
+        case arrow2.TimeUnit.MILLISECOND:
           return "time-millisecond";
-        case arrow.TimeUnit.MICROSECOND:
+        case arrow2.TimeUnit.MICROSECOND:
           return "time-microsecond";
-        case arrow.TimeUnit.NANOSECOND:
+        case arrow2.TimeUnit.NANOSECOND:
           return "time-nanosecond";
         default:
           return "time-second";
       }
-    case arrow.TimeMillisecond:
+    case arrow2.TimeMillisecond:
       return "time-millisecond";
-    case arrow.TimeSecond:
+    case arrow2.TimeSecond:
       return "time-second";
-    case arrow.TimeMicrosecond:
+    case arrow2.TimeMicrosecond:
       return "time-microsecond";
-    case arrow.TimeNanosecond:
+    case arrow2.TimeNanosecond:
       return "time-nanosecond";
-    case arrow.Timestamp:
+    case arrow2.Timestamp:
       const timeStampUnit = arrowType.unit;
       switch (timeStampUnit) {
-        case arrow.TimeUnit.SECOND:
+        case arrow2.TimeUnit.SECOND:
           return "timestamp-second";
-        case arrow.TimeUnit.MILLISECOND:
+        case arrow2.TimeUnit.MILLISECOND:
           return "timestamp-millisecond";
-        case arrow.TimeUnit.MICROSECOND:
+        case arrow2.TimeUnit.MICROSECOND:
           return "timestamp-microsecond";
-        case arrow.TimeUnit.NANOSECOND:
+        case arrow2.TimeUnit.NANOSECOND:
           return "timestamp-nanosecond";
         default:
           return "timestamp-second";
       }
-    case arrow.TimestampSecond:
+    case arrow2.TimestampSecond:
       return "timestamp-second";
-    case arrow.TimestampMillisecond:
+    case arrow2.TimestampMillisecond:
       return "timestamp-millisecond";
-    case arrow.TimestampMicrosecond:
+    case arrow2.TimestampMicrosecond:
       return "timestamp-microsecond";
-    case arrow.TimestampNanosecond:
+    case arrow2.TimestampNanosecond:
       return "timestamp-nanosecond";
-    case arrow.Interval:
+    case arrow2.Interval:
       const intervalUnit = arrowType.unit;
       switch (intervalUnit) {
-        case arrow.IntervalUnit.DAY_TIME:
+        case arrow2.IntervalUnit.DAY_TIME:
           return "interval-daytime";
-        case arrow.IntervalUnit.YEAR_MONTH:
+        case arrow2.IntervalUnit.YEAR_MONTH:
           return "interval-yearmonth";
         default:
           return "interval-daytime";
       }
-    case arrow.IntervalDayTime:
+    case arrow2.IntervalDayTime:
       return "interval-daytime";
-    case arrow.IntervalYearMonth:
+    case arrow2.IntervalYearMonth:
       return "interval-yearmonth";
-    case arrow.Map_:
+    case arrow2.Map_:
       const mapType = arrowType;
       return {
         type: "map",
         keysSorted: mapType.keysSorted,
         children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
       };
-    case arrow.List:
+    case arrow2.List:
       const listType = arrowType;
       const listField = listType.valueField;
       return {
         type: "list",
         children: [serializeArrowField(listField)]
       };
-    case arrow.FixedSizeList:
+    case arrow2.LargeList:
+      const largeListType = arrowType;
+      return {
+        type: "large-list",
+        children: [serializeArrowField(largeListType.valueField)]
+      };
+    case arrow2.FixedSizeList:
       const fixedSizeList = arrowType;
       return {
         type: "fixed-size-list",
         listSize: fixedSizeList.listSize,
         children: [serializeArrowField(fixedSizeList.children[0])]
       };
-    case arrow.Struct:
+    case arrow2.Struct:
       const structType = arrowType;
       return {
         type: "struct",
         children: structType.children.map((arrowField) => serializeArrowField(arrowField))
       };
-    case arrow.Dictionary:
+    case arrow2.SparseUnion:
+    case arrow2.DenseUnion:
+      const unionType = arrowType;
+      return {
+        type: unionType instanceof arrow2.DenseUnion ? "dense-union" : "sparse-union",
+        typeIds: unionType.typeIds,
+        children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
+        typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
+      };
+    case arrow2.Dictionary:
       const dictionaryType = arrowType;
       return {
         type: "dictionary",
@@ -1347,31 +1431,42 @@ function deserializeArrowType(dataType, options) {
   if (typeof dataType === "object") {
     switch (dataType.type) {
       case "decimal":
-        return new arrow.Decimal(dataType.scale, dataType.precision, dataType.bitWidth);
+        return new arrow2.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);
+        return new arrow2.Map_(children[0], dataType.keysSorted);
       }
       case "list": {
         const field = deserializeArrowField(dataType.children[0], options);
-        return new arrow.List(field);
+        return new arrow2.List(field);
+      }
+      case "large-list": {
+        const field = deserializeArrowField(dataType.children[0], options);
+        return new arrow2.LargeList(field);
       }
       case "fixed-size-list": {
         const child = deserializeArrowField(dataType.children[0], options);
-        return new arrow.FixedSizeList(dataType.listSize, child);
+        return new arrow2.FixedSizeList(dataType.listSize, child);
       }
       case "fixed-size-binary":
-        return new arrow.FixedSizeBinary(dataType.byteWidth);
+        return new arrow2.FixedSizeBinary(dataType.byteWidth);
       case "struct": {
         const children = dataType.children.map(
           (arrowField) => deserializeArrowField(arrowField, options)
         );
-        return new arrow.Struct(children);
+        return new arrow2.Struct(children);
+      }
+      case "sparse-union":
+      case "dense-union": {
+        const children = dataType.children.map(
+          (arrowField) => deserializeArrowField(arrowField, options)
+        );
+        return dataType.type === "dense-union" ? new arrow2.DenseUnion(dataType.typeIds, children) : new arrow2.SparseUnion(dataType.typeIds, children);
       }
       case "dictionary": {
-        return new arrow.Dictionary(
+        return new arrow2.Dictionary(
           deserializeArrowType(dataType.dictionary, options),
           deserializeArrowDictionaryKeyType(dataType.indices),
           dataType.id,
@@ -1384,76 +1479,76 @@ function deserializeArrowType(dataType, options) {
   }
   switch (dataType) {
     case "null":
-      return new arrow.Null();
+      return new arrow2.Null();
     case "binary":
-      return makeVariableWidthArrowType("BinaryView", new arrow.Binary(), options);
+      return makeVariableWidthArrowType("BinaryView", new arrow2.Binary(), options);
     case "binary-view":
       return makeRequiredArrowViewType("BinaryView");
     case "bool":
-      return new arrow.Bool();
+      return new arrow2.Bool();
     case "int8":
-      return new arrow.Int8();
+      return new arrow2.Int8();
     case "int16":
-      return new arrow.Int16();
+      return new arrow2.Int16();
     case "int32":
-      return new arrow.Int32();
+      return new arrow2.Int32();
     case "int64":
-      return new arrow.Int64();
+      return new arrow2.Int64();
     case "uint8":
-      return new arrow.Uint8();
+      return new arrow2.Uint8();
     case "uint16":
-      return new arrow.Uint16();
+      return new arrow2.Uint16();
     case "uint32":
-      return new arrow.Uint32();
+      return new arrow2.Uint32();
     case "uint64":
-      return new arrow.Uint64();
+      return new arrow2.Uint64();
     case "float16":
-      return new arrow.Float16();
+      return new arrow2.Float16();
     case "float32":
-      return new arrow.Float32();
+      return new arrow2.Float32();
     case "float64":
-      return new arrow.Float64();
+      return new arrow2.Float64();
     case "utf8":
-      return makeVariableWidthArrowType("Utf8View", new arrow.Utf8(), options);
+      return makeVariableWidthArrowType("Utf8View", new arrow2.Utf8(), options);
     case "utf8-view":
       return makeRequiredArrowViewType("Utf8View");
     case "date-day":
-      return new arrow.DateDay();
+      return new arrow2.DateDay();
     case "date-millisecond":
-      return new arrow.DateMillisecond();
+      return new arrow2.DateMillisecond();
     case "time-second":
-      return new arrow.TimeSecond();
+      return new arrow2.TimeSecond();
     case "time-millisecond":
-      return new arrow.TimeMillisecond();
+      return new arrow2.TimeMillisecond();
     case "time-microsecond":
-      return new arrow.TimeMicrosecond();
+      return new arrow2.TimeMicrosecond();
     case "time-nanosecond":
-      return new arrow.TimeNanosecond();
+      return new arrow2.TimeNanosecond();
     case "timestamp-second":
-      return new arrow.TimestampSecond();
+      return new arrow2.TimestampSecond();
     case "timestamp-millisecond":
-      return new arrow.TimestampMillisecond();
+      return new arrow2.TimestampMillisecond();
     case "timestamp-microsecond":
-      return new arrow.TimestampMicrosecond();
+      return new arrow2.TimestampMicrosecond();
     case "timestamp-nanosecond":
-      return new arrow.TimestampNanosecond();
+      return new arrow2.TimestampNanosecond();
     case "interval-daytime":
-      return new arrow.IntervalDayTime();
+      return new arrow2.IntervalDayTime();
     case "interval-yearmonth":
-      return new arrow.IntervalYearMonth();
+      return new arrow2.IntervalYearMonth();
     default:
       throw new Error("array type not supported");
   }
 }
 function getArrowViewConstructors() {
-  return arrow;
+  return arrow2;
 }
 function isArrowViewType(arrowType, viewTypeName) {
   const constructor = getArrowViewConstructors()[viewTypeName];
   if (constructor && arrowType instanceof constructor) {
     return true;
   }
-  const guards = arrow.DataType;
+  const guards = arrow2.DataType;
   const guard = viewTypeName === "BinaryView" ? guards.isBinaryView : guards.isUtf8View;
   return Boolean(guard == null ? void 0 : guard(arrowType));
 }
@@ -1483,7 +1578,7 @@ function makeRequiredArrowViewType(viewTypeName) {
   return new constructor();
 }
 function serializeArrowDictionaryKeyType(arrowType) {
-  if (arrowType instanceof arrow.Int) {
+  if (arrowType instanceof arrow2.Int) {
     const prefix = arrowType.isSigned ? "int" : "uint";
     const keyType = `${prefix}${arrowType.bitWidth}`;
     if (isSchemaDictionaryKeyType(keyType)) {
@@ -1491,17 +1586,17 @@ function serializeArrowDictionaryKeyType(arrowType) {
     }
   }
   switch (arrowType.constructor) {
-    case arrow.Int8:
+    case arrow2.Int8:
       return "int8";
-    case arrow.Int16:
+    case arrow2.Int16:
       return "int16";
-    case arrow.Int32:
+    case arrow2.Int32:
       return "int32";
-    case arrow.Uint8:
+    case arrow2.Uint8:
       return "uint8";
-    case arrow.Uint16:
+    case arrow2.Uint16:
       return "uint16";
-    case arrow.Uint32:
+    case arrow2.Uint32:
       return "uint32";
     default:
       throw new Error(`arrow dictionary index type not supported: ${arrowType.constructor.name}`);
@@ -1513,26 +1608,26 @@ function isSchemaDictionaryKeyType(keyType) {
 function deserializeArrowDictionaryKeyType(keyType) {
   switch (keyType) {
     case "int8":
-      return new arrow.Int8();
+      return new arrow2.Int8();
     case "int16":
-      return new arrow.Int16();
+      return new arrow2.Int16();
     case "int32":
-      return new arrow.Int32();
+      return new arrow2.Int32();
     case "uint8":
-      return new arrow.Uint8();
+      return new arrow2.Uint8();
     case "uint16":
-      return new arrow.Uint16();
+      return new arrow2.Uint16();
     case "uint32":
-      return new arrow.Uint32();
+      return new arrow2.Uint32();
     default:
       throw new Error(`schema dictionary index type not supported: ${keyType}`);
   }
 }
-var arrow;
+var arrow2;
 var init_convert_arrow_schema = __esm({
   "../schema-utils/src/lib/schema/convert-arrow-schema.ts"() {
     "use strict";
-    arrow = __toESM(require("apache-arrow"), 1);
+    arrow2 = __toESM(require("apache-arrow"), 1);
   }
 });
 
@@ -1622,38 +1717,6 @@ var init_mesh_utils = __esm({
   }
 });
 
-// ../schema/src/categories/category-mesh.ts
-var arrow2, meshArrowSchema, indexedMeshArrowSchema;
-var init_category_mesh = __esm({
-  "../schema/src/categories/category-mesh.ts"() {
-    "use strict";
-    arrow2 = __toESM(require("apache-arrow"), 1);
-    meshArrowSchema = new arrow2.Schema([
-      new arrow2.Field(
-        "POSITION",
-        new arrow2.FixedSizeList(3, new arrow2.Field("value", new arrow2.Float32(), false)),
-        false
-      )
-    ]);
-    indexedMeshArrowSchema = new arrow2.Schema([
-      ...meshArrowSchema.fields,
-      new arrow2.Field(
-        "indices",
-        new arrow2.List(new arrow2.Field("item", new arrow2.Int32(), false)),
-        true
-      )
-    ]);
-  }
-});
-
-// ../schema/src/index.ts
-var init_src = __esm({
-  "../schema/src/index.ts"() {
-    "use strict";
-    init_category_mesh();
-  }
-});
-
 // ../schema-utils/src/lib/arrow-utils/arrow-fixed-size-list-utils.ts
 function getFixedSizeListVector(typedArray, stride) {
   const data = getFixedSizeListData(typedArray, stride);