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

package/dist/mlt/index.cjs

@@ -0,0 +1,3701 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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);
+
+// dist/mlt/mlt-format.js
+var MLTFormat;
+var init_mlt_format = __esm({
+  "dist/mlt/mlt-format.js"() {
+    "use strict";
+    MLTFormat = {
+      name: "MapLibre Tile",
+      id: "mlt",
+      module: "tiles",
+      encoding: "binary",
+      format: "mlt",
+      extensions: ["mlt"],
+      mimeTypes: ["application/vnd.maplibre-tile"],
+      category: "geometry"
+    };
+  }
+});
+
+// ../arrow-geometry/src/legacy-binary/geometry-info.ts
+function getGeometryInfo(features) {
+  let pointPositionsCount = 0;
+  let pointFeaturesCount = 0;
+  let linePositionsCount = 0;
+  let linePathsCount = 0;
+  let lineFeaturesCount = 0;
+  let polygonPositionsCount = 0;
+  let polygonObjectsCount = 0;
+  let polygonRingsCount = 0;
+  let polygonFeaturesCount = 0;
+  const coordLengths = /* @__PURE__ */ new Set();
+  for (const feature of features) {
+    const geometry = feature.geometry;
+    switch (geometry.type) {
+      case "Point":
+        pointFeaturesCount++;
+        pointPositionsCount++;
+        coordLengths.add(geometry.coordinates.length);
+        break;
+      case "MultiPoint":
+        pointFeaturesCount++;
+        pointPositionsCount += geometry.coordinates.length;
+        for (const point of geometry.coordinates) {
+          coordLengths.add(point.length);
+        }
+        break;
+      case "LineString":
+        lineFeaturesCount++;
+        linePositionsCount += geometry.coordinates.length;
+        linePathsCount++;
+        for (const coord of geometry.coordinates) {
+          coordLengths.add(coord.length);
+        }
+        break;
+      case "MultiLineString":
+        lineFeaturesCount++;
+        for (const line of geometry.coordinates) {
+          linePositionsCount += line.length;
+          linePathsCount++;
+          for (const coord of line) {
+            coordLengths.add(coord.length);
+          }
+        }
+        break;
+      case "Polygon":
+        polygonFeaturesCount++;
+        polygonObjectsCount++;
+        polygonRingsCount += geometry.coordinates.length;
+        const flattened = geometry.coordinates.flat();
+        polygonPositionsCount += flattened.length;
+        for (const coord of flattened) {
+          coordLengths.add(coord.length);
+        }
+        break;
+      case "MultiPolygon":
+        polygonFeaturesCount++;
+        for (const polygon of geometry.coordinates) {
+          polygonObjectsCount++;
+          polygonRingsCount += polygon.length;
+          const flattened2 = polygon.flat();
+          polygonPositionsCount += flattened2.length;
+          for (const coord of flattened2) {
+            coordLengths.add(coord.length);
+          }
+        }
+        break;
+      default:
+        throw new Error(`Unsupported geometry type: ${geometry.type}`);
+    }
+  }
+  return {
+    coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,
+    pointPositionsCount,
+    pointFeaturesCount,
+    linePositionsCount,
+    linePathsCount,
+    lineFeaturesCount,
+    polygonPositionsCount,
+    polygonObjectsCount,
+    polygonRingsCount,
+    polygonFeaturesCount
+  };
+}
+var init_geometry_info = __esm({
+  "../arrow-geometry/src/legacy-binary/geometry-info.ts"() {
+    "use strict";
+  }
+});
+
+// ../arrow-geometry/src/legacy-binary/convert-geojson-to-flat-geojson.ts
+function convertGeojsonToFlatGeojson(features, options = { coordLength: 2, fixRingWinding: true }) {
+  return features.map((feature) => flattenFeature(feature, options));
+}
+function flattenPoint(coordinates, data, indices, options) {
+  indices.push(data.length);
+  data.push(...coordinates);
+  for (let i = coordinates.length; i < options.coordLength; i++) {
+    data.push(0);
+  }
+}
+function flattenLineString(coordinates, data, indices, options) {
+  indices.push(data.length);
+  for (const c of coordinates) {
+    data.push(...c);
+    for (let i = c.length; i < options.coordLength; i++) {
+      data.push(0);
+    }
+  }
+}
+function flattenPolygon(coordinates, data, indices, areas, options) {
+  let count = 0;
+  const ringAreas = [];
+  const polygons = [];
+  for (const lineString of coordinates) {
+    const lineString2d = lineString.map((p) => p.slice(0, 2));
+    let area = (0, import_polygon.getPolygonSignedArea)(lineString2d.flat());
+    const ccw = area < 0;
+    if (options.fixRingWinding && (count === 0 && !ccw || count > 0 && ccw)) {
+      lineString.reverse();
+      area = -area;
+    }
+    ringAreas.push(area);
+    flattenLineString(lineString, data, polygons, options);
+    count++;
+  }
+  if (count > 0) {
+    areas.push(ringAreas);
+    indices.push(polygons);
+  }
+}
+function flattenFeature(feature, options) {
+  const { geometry } = feature;
+  if (geometry.type === "GeometryCollection") {
+    throw new Error("GeometryCollection type not supported");
+  }
+  const data = [];
+  const indices = [];
+  let areas;
+  let type;
+  switch (geometry.type) {
+    case "Point":
+      type = "Point";
+      flattenPoint(geometry.coordinates, data, indices, options);
+      break;
+    case "MultiPoint":
+      type = "Point";
+      geometry.coordinates.map((c) => flattenPoint(c, data, indices, options));
+      break;
+    case "LineString":
+      type = "LineString";
+      flattenLineString(geometry.coordinates, data, indices, options);
+      break;
+    case "MultiLineString":
+      type = "LineString";
+      geometry.coordinates.map((c) => flattenLineString(c, data, indices, options));
+      break;
+    case "Polygon":
+      type = "Polygon";
+      areas = [];
+      flattenPolygon(geometry.coordinates, data, indices, areas, options);
+      break;
+    case "MultiPolygon":
+      type = "Polygon";
+      areas = [];
+      geometry.coordinates.map((c) => flattenPolygon(c, data, indices, areas, options));
+      break;
+    default:
+      throw new Error(`Unknown type: ${type}`);
+  }
+  return { ...feature, geometry: { type, indices, data, areas } };
+}
+var import_polygon;
+var init_convert_geojson_to_flat_geojson = __esm({
+  "../arrow-geometry/src/legacy-binary/convert-geojson-to-flat-geojson.ts"() {
+    "use strict";
+    import_polygon = require("@math.gl/geometry/polygon");
+  }
+});
+
+// ../arrow-geometry/src/legacy-binary/convert-flat-geojson-to-binary-features.ts
+function convertFlatGeojsonToBinaryFeatureCollection(features, geometryInfo, options) {
+  const propArrayTypes = extractNumericPropTypes(features);
+  const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
+  return fillArrays(
+    features,
+    {
+      propArrayTypes,
+      ...geometryInfo
+    },
+    {
+      numericPropKeys: options && options.numericPropKeys || numericPropKeys,
+      PositionDataType: options ? options.PositionDataType : Float32Array,
+      triangulate: options ? options.triangulate : true
+    }
+  );
+}
+function extractNumericPropTypes(features) {
+  const propArrayTypes = {};
+  for (const feature of features) {
+    if (feature.properties) {
+      for (const key in feature.properties) {
+        const val = feature.properties[key];
+        propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);
+      }
+    }
+  }
+  return propArrayTypes;
+}
+function fillArrays(features, geometryInfo, options) {
+  const {
+    pointPositionsCount,
+    pointFeaturesCount,
+    linePositionsCount,
+    linePathsCount,
+    lineFeaturesCount,
+    polygonPositionsCount,
+    polygonObjectsCount,
+    polygonRingsCount,
+    polygonFeaturesCount,
+    propArrayTypes,
+    coordLength
+  } = geometryInfo;
+  const { numericPropKeys = [], PositionDataType = Float32Array, triangulate = true } = options;
+  const hasGlobalId = features[0] && "id" in features[0];
+  const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
+  const points = {
+    type: "Point",
+    positions: new PositionDataType(pointPositionsCount * coordLength),
+    globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
+    featureIds: pointFeaturesCount > 65535 ? new Uint32Array(pointPositionsCount) : new Uint16Array(pointPositionsCount),
+    numericProps: {},
+    properties: [],
+    fields: []
+  };
+  const lines = {
+    type: "LineString",
+    pathIndices: linePositionsCount > 65535 ? new Uint32Array(linePathsCount + 1) : new Uint16Array(linePathsCount + 1),
+    positions: new PositionDataType(linePositionsCount * coordLength),
+    globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
+    featureIds: lineFeaturesCount > 65535 ? new Uint32Array(linePositionsCount) : new Uint16Array(linePositionsCount),
+    numericProps: {},
+    properties: [],
+    fields: []
+  };
+  const polygons = {
+    type: "Polygon",
+    polygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonObjectsCount + 1) : new Uint16Array(polygonObjectsCount + 1),
+    primitivePolygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonRingsCount + 1) : new Uint16Array(polygonRingsCount + 1),
+    positions: new PositionDataType(polygonPositionsCount * coordLength),
+    globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
+    featureIds: polygonFeaturesCount > 65535 ? new Uint32Array(polygonPositionsCount) : new Uint16Array(polygonPositionsCount),
+    numericProps: {},
+    properties: [],
+    fields: []
+  };
+  if (triangulate) {
+    polygons.triangles = [];
+  }
+  for (const object of [points, lines, polygons]) {
+    for (const propName of numericPropKeys) {
+      const T = propArrayTypes[propName];
+      object.numericProps[propName] = new T(object.positions.length / coordLength);
+    }
+  }
+  lines.pathIndices[linePathsCount] = linePositionsCount;
+  polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;
+  polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;
+  const indexMap = {
+    pointPosition: 0,
+    pointFeature: 0,
+    linePosition: 0,
+    linePath: 0,
+    lineFeature: 0,
+    polygonPosition: 0,
+    polygonObject: 0,
+    polygonRing: 0,
+    polygonFeature: 0,
+    feature: 0
+  };
+  for (const feature of features) {
+    const geometry = feature.geometry;
+    const properties = feature.properties || {};
+    switch (geometry.type) {
+      case "Point":
+        handlePoint(geometry, points, indexMap, coordLength, properties);
+        points.properties.push(keepStringProperties(properties, numericPropKeys));
+        if (hasGlobalId) {
+          points.fields.push({ id: feature.id });
+        }
+        indexMap.pointFeature++;
+        break;
+      case "LineString":
+        handleLineString(geometry, lines, indexMap, coordLength, properties);
+        lines.properties.push(keepStringProperties(properties, numericPropKeys));
+        if (hasGlobalId) {
+          lines.fields.push({ id: feature.id });
+        }
+        indexMap.lineFeature++;
+        break;
+      case "Polygon":
+        handlePolygon(geometry, polygons, indexMap, coordLength, properties);
+        polygons.properties.push(keepStringProperties(properties, numericPropKeys));
+        if (hasGlobalId) {
+          polygons.fields.push({ id: feature.id });
+        }
+        indexMap.polygonFeature++;
+        break;
+      default:
+        throw new Error("Invalid geometry type");
+    }
+    indexMap.feature++;
+  }
+  return makeAccessorObjects(points, lines, polygons, coordLength);
+}
+function handlePoint(geometry, points, indexMap, coordLength, properties) {
+  points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
+  const nPositions = geometry.data.length / coordLength;
+  fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);
+  points.globalFeatureIds.fill(
+    indexMap.feature,
+    indexMap.pointPosition,
+    indexMap.pointPosition + nPositions
+  );
+  points.featureIds.fill(
+    indexMap.pointFeature,
+    indexMap.pointPosition,
+    indexMap.pointPosition + nPositions
+  );
+  indexMap.pointPosition += nPositions;
+}
+function handleLineString(geometry, lines, indexMap, coordLength, properties) {
+  lines.positions.set(geometry.data, indexMap.linePosition * coordLength);
+  const nPositions = geometry.data.length / coordLength;
+  fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
+  lines.globalFeatureIds.fill(
+    indexMap.feature,
+    indexMap.linePosition,
+    indexMap.linePosition + nPositions
+  );
+  lines.featureIds.fill(
+    indexMap.lineFeature,
+    indexMap.linePosition,
+    indexMap.linePosition + nPositions
+  );
+  for (let i = 0, il = geometry.indices.length; i < il; ++i) {
+    const start = geometry.indices[i];
+    const end = i === il - 1 ? geometry.data.length : geometry.indices[i + 1];
+    lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
+    indexMap.linePosition += (end - start) / coordLength;
+  }
+}
+function handlePolygon(geometry, polygons, indexMap, coordLength, properties) {
+  polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);
+  const nPositions = geometry.data.length / coordLength;
+  fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
+  polygons.globalFeatureIds.fill(
+    indexMap.feature,
+    indexMap.polygonPosition,
+    indexMap.polygonPosition + nPositions
+  );
+  polygons.featureIds.fill(
+    indexMap.polygonFeature,
+    indexMap.polygonPosition,
+    indexMap.polygonPosition + nPositions
+  );
+  for (let l = 0, ll = geometry.indices.length; l < ll; ++l) {
+    const startPosition = indexMap.polygonPosition;
+    polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
+    const areas = geometry.areas[l];
+    const indices = geometry.indices[l];
+    const nextIndices = geometry.indices[l + 1];
+    for (let i = 0, il = indices.length; i < il; ++i) {
+      const start = indices[i];
+      const end = i === il - 1 ? (
+        // last line, so either read to:
+        nextIndices === void 0 ? geometry.data.length : nextIndices[0]
+      ) : indices[i + 1];
+      polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
+      indexMap.polygonPosition += (end - start) / coordLength;
+    }
+    const endPosition = indexMap.polygonPosition;
+    triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength });
+  }
+}
+function triangulatePolygon(polygons, areas, indices, {
+  startPosition,
+  endPosition,
+  coordLength
+}) {
+  if (!polygons.triangles) {
+    return;
+  }
+  const start = startPosition * coordLength;
+  const end = endPosition * coordLength;
+  const polygonPositions = polygons.positions.subarray(start, end);
+  const offset = indices[0];
+  const holes = indices.slice(1).map((n) => (n - offset) / coordLength);
+  const triangles = (0, import_polygon2.earcut)(polygonPositions, holes, coordLength, areas);
+  for (let t = 0, tl = triangles.length; t < tl; ++t) {
+    polygons.triangles.push(startPosition + triangles[t]);
+  }
+}
+function wrapProps(obj, size) {
+  const returnObj = {};
+  for (const key in obj) {
+    returnObj[key] = { value: obj[key], size };
+  }
+  return returnObj;
+}
+function makeAccessorObjects(points, lines, polygons, coordLength) {
+  const binaryFeatures = {
+    shape: "binary-feature-collection",
+    points: {
+      ...points,
+      positions: { value: points.positions, size: coordLength },
+      globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
+      featureIds: { value: points.featureIds, size: 1 },
+      numericProps: wrapProps(points.numericProps, 1)
+    },
+    lines: {
+      ...lines,
+      positions: { value: lines.positions, size: coordLength },
+      pathIndices: { value: lines.pathIndices, size: 1 },
+      globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
+      featureIds: { value: lines.featureIds, size: 1 },
+      numericProps: wrapProps(lines.numericProps, 1)
+    },
+    polygons: {
+      ...polygons,
+      positions: { value: polygons.positions, size: coordLength },
+      polygonIndices: { value: polygons.polygonIndices, size: 1 },
+      primitivePolygonIndices: { value: polygons.primitivePolygonIndices, size: 1 },
+      globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
+      featureIds: { value: polygons.featureIds, size: 1 },
+      numericProps: wrapProps(polygons.numericProps, 1)
+    }
+    // triangles not expected
+  };
+  if (binaryFeatures.polygons && polygons.triangles) {
+    binaryFeatures.polygons.triangles = { value: new Uint32Array(polygons.triangles), size: 1 };
+  }
+  return binaryFeatures;
+}
+function fillNumericProperties(object, properties, index, length) {
+  for (const numericPropName in object.numericProps) {
+    if (numericPropName in properties) {
+      const value = properties[numericPropName];
+      object.numericProps[numericPropName].fill(value, index, index + length);
+    }
+  }
+}
+function keepStringProperties(properties, numericKeys) {
+  const props = {};
+  for (const key in properties) {
+    if (!numericKeys.includes(key)) {
+      props[key] = properties[key];
+    }
+  }
+  return props;
+}
+function deduceArrayType(x, constructor) {
+  if (constructor === Array || !Number.isFinite(x)) {
+    return Array;
+  }
+  return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;
+}
+var import_polygon2;
+var init_convert_flat_geojson_to_binary_features = __esm({
+  "../arrow-geometry/src/legacy-binary/convert-flat-geojson-to-binary-features.ts"() {
+    "use strict";
+    import_polygon2 = require("@math.gl/geometry/polygon");
+  }
+});
+
+// ../arrow-geometry/src/legacy-binary/convert-geojson-to-binary-features.ts
+function convertGeojsonToBinaryFeatureCollection(features, options = { fixRingWinding: true, triangulate: true }) {
+  const geometryInfo = getGeometryInfo(features);
+  const coordLength = geometryInfo.coordLength;
+  const { fixRingWinding } = options;
+  const flatFeatures = convertGeojsonToFlatGeojson(features, { coordLength, fixRingWinding });
+  return convertFlatGeojsonToBinaryFeatureCollection(flatFeatures, geometryInfo, {
+    numericPropKeys: options.numericPropKeys,
+    PositionDataType: options.PositionDataType || Float32Array,
+    triangulate: options.triangulate
+  });
+}
+var init_convert_geojson_to_binary_features = __esm({
+  "../arrow-geometry/src/legacy-binary/convert-geojson-to-binary-features.ts"() {
+    "use strict";
+    init_geometry_info();
+    init_convert_geojson_to_flat_geojson();
+    init_convert_flat_geojson_to_binary_features();
+  }
+});
+
+// ../arrow-geometry/src/legacy-binary.ts
+var init_legacy_binary = __esm({
+  "../arrow-geometry/src/legacy-binary.ts"() {
+    "use strict";
+    init_convert_geojson_to_binary_features();
+  }
+});
+
+// ../arrow-geometry/src/geometry-utils.ts
+function normalizeEmptyPoints(geometry) {
+  if (geometry.type === "Point") {
+    return geometry.coordinates.length > 0 && geometry.coordinates.every(Number.isNaN) ? { ...geometry, coordinates: [] } : geometry;
+  }
+  if (geometry.type === "MultiPoint") {
+    const coordinates = geometry.coordinates.map(
+      (coordinate) => coordinate.length > 0 && coordinate.every(Number.isNaN) ? [] : coordinate
+    );
+    return coordinates.some((coordinate, index) => coordinate !== geometry.coordinates[index]) ? { ...geometry, coordinates } : geometry;
+  }
+  if (geometry.type === "GeometryCollection") {
+    const geometries = geometry.geometries.map(normalizeEmptyPoints);
+    return geometries.some((child, index) => child !== geometry.geometries[index]) ? { ...geometry, geometries } : geometry;
+  }
+  return geometry;
+}
+var init_geometry_utils = __esm({
+  "../arrow-geometry/src/geometry-utils.ts"() {
+    "use strict";
+  }
+});
+
+// ../arrow-geometry/src/geometry-codecs.ts
+function convertWKBToGeometry(input) {
+  const bytes = ArrayBuffer.isView(input) ? new Uint8Array(input.buffer, input.byteOffset, input.byteLength) : new Uint8Array(input);
+  return normalizeEmptyPoints((0, import_wkb.parseWKB)(bytes).geometry);
+}
+var import_wkb;
+var init_geometry_codecs = __esm({
+  "../arrow-geometry/src/geometry-codecs.ts"() {
+    "use strict";
+    import_wkb = require("@math.gl/geospatial/wkb");
+    init_geometry_utils();
+  }
+});
+
+// ../core/src/schema/metadata.ts
+function getMetadataValue(metadata, key) {
+  return metadata instanceof Map ? metadata.get(key) || null : metadata[key] || null;
+}
+function setMetadataValue(metadata, key, value) {
+  if (metadata instanceof Map) {
+    metadata.set(key, value);
+  } else {
+    metadata[key] = value;
+  }
+}
+function getGeoMetadata(metadata) {
+  if (!metadata) {
+    return null;
+  }
+  const stringifiedGeoMetadata = getMetadataValue(metadata, "geo");
+  const geoMetadata = stringifiedGeoMetadata && parseJSONStringMetadata(stringifiedGeoMetadata);
+  if (!geoMetadata) {
+    return null;
+  }
+  for (const column of Object.values(geoMetadata.columns || {})) {
+    if (column && typeof column === "object" && typeof column.encoding === "string") {
+      column.encoding = column.encoding.toLowerCase();
+    }
+  }
+  return geoMetadata;
+}
+function setGeoMetadata(metadata, geoMetadata) {
+  setMetadataValue(metadata, "geo", JSON.stringify(geoMetadata));
+}
+function parseJSONStringMetadata(stringifiedMetadata) {
+  if (!stringifiedMetadata) {
+    return null;
+  }
+  try {
+    const metadata = JSON.parse(stringifiedMetadata);
+    return metadata && typeof metadata === "object" ? metadata : null;
+  } catch {
+    return null;
+  }
+}
+var init_metadata = __esm({
+  "../core/src/schema/metadata.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/schema/index.ts
+var init_schema = __esm({
+  "../core/src/schema/index.ts"() {
+    "use strict";
+    init_metadata();
+  }
+});
+
+// ../arrow-geometry/src/geometry-field.ts
+function makeWKBGeometryField(geometryColumnName = "geometry", nullable = true) {
+  return {
+    name: geometryColumnName,
+    type: "binary",
+    nullable,
+    metadata: {
+      "ARROW:extension:name": "geoarrow.wkb"
+    }
+  };
+}
+function setWKBGeometryColumnMetadata(metadata, options = {}) {
+  const geometryColumnName = options.geometryColumnName || "geometry";
+  const primaryColumnName = options.primaryColumnName || geometryColumnName;
+  const geometryTypes = options.geometryTypes || [];
+  const nextGeoMetadata = getGeoMetadata(metadata) || { columns: {} };
+  nextGeoMetadata.version = options.version || nextGeoMetadata.version || DEFAULT_GEO_METADATA_VERSION;
+  nextGeoMetadata.primary_column = primaryColumnName;
+  nextGeoMetadata.columns ||= {};
+  nextGeoMetadata.columns[geometryColumnName] = {
+    ...nextGeoMetadata.columns[geometryColumnName],
+    ...options.columnMetadata,
+    encoding: "wkb",
+    geometry_types: geometryTypes
+  };
+  setGeoMetadata(metadata, nextGeoMetadata);
+}
+function setWKBGeometrySchemaMetadata(schema, options = {}) {
+  schema.metadata ||= {};
+  setWKBGeometryColumnMetadata(schema.metadata, options);
+  return schema;
+}
+var DEFAULT_GEO_METADATA_VERSION;
+var init_geometry_field = __esm({
+  "../arrow-geometry/src/geometry-field.ts"() {
+    "use strict";
+    init_schema();
+    DEFAULT_GEO_METADATA_VERSION = "1.1.0";
+  }
+});
+
+// ../core/src/schema-utils/lib/schema/data-type.ts
+function getDataTypeFromValue(value, defaultNumberType = "float32") {
+  if (value instanceof Date) {
+    return "date-millisecond";
+  }
+  if (typeof value === "number") {
+    return defaultNumberType;
+  }
+  if (typeof value === "boolean") {
+    return "bool";
+  }
+  if (typeof value === "string") {
+    return "utf8";
+  }
+  if (value === null || value === "undefined") {
+    return "null";
+  }
+  return "null";
+}
+function getDataTypeFromArray(array) {
+  let type = getDataTypeFromTypedArray(array);
+  if (type !== "null") {
+    return { type, nullable: false };
+  }
+  if (array.length > 0) {
+    type = getDataTypeFromValue(array[0]);
+    return { type, nullable: true };
+  }
+  return { type: "null", nullable: true };
+}
+function getDataTypeFromTypedArray(array) {
+  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";
+  }
+}
+var import_types;
+var init_data_type = __esm({
+  "../core/src/schema-utils/lib/schema/data-type.ts"() {
+    "use strict";
+    import_types = require("@math.gl/core/types");
+  }
+});
+
+// ../core/src/schema-utils/lib/schema/convert-arrow-schema.ts
+function convertArrowToSchema(arrowSchema) {
+  return serializeArrowSchema(arrowSchema);
+}
+function convertSchemaToArrow(schema, options) {
+  return deserializeArrowSchema(schema, options);
+}
+function serializeArrowSchema(arrowSchema) {
+  return {
+    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+    metadata: serializeArrowMetadata(arrowSchema.metadata)
+  };
+}
+function deserializeArrowSchema(schema, options) {
+  return new arrow.Schema(
+    schema.fields.map((field) => deserializeArrowField(field, options)),
+    deserializeArrowMetadata(schema.metadata)
+  );
+}
+function serializeArrowMetadata(arrowMetadata) {
+  return Object.fromEntries(arrowMetadata);
+}
+function deserializeArrowMetadata(metadata) {
+  return metadata ? new Map(Object.entries(metadata)) : /* @__PURE__ */ new Map();
+}
+function serializeArrowField(field) {
+  return {
+    name: field.name,
+    type: serializeArrowType(field.type),
+    nullable: field.nullable,
+    metadata: serializeArrowMetadata(field.metadata)
+  };
+}
+function deserializeArrowField(field, options) {
+  return new arrow.Field(
+    field.name,
+    deserializeArrowType(field.type, options),
+    field.nullable,
+    deserializeArrowMetadata(field.metadata)
+  );
+}
+function serializeArrowType(arrowType) {
+  if (isArrowViewType(arrowType, "BinaryView")) {
+    return "binary-view";
+  }
+  if (isArrowViewType(arrowType, "Utf8View")) {
+    return "utf8-view";
+  }
+  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 == null ? void 0 : guard(arrowType));
+}
+function isOptionalArrowType(arrowType, typeName) {
+  const constructor = getOptionalArrowConstructor(typeName);
+  return Boolean(constructor && arrowType instanceof constructor);
+}
+function makeVariableWidthArrowType(viewTypeName, fallbackType, options) {
+  const viewTypeMode = (options == null ? void 0 : 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}`);
+  }
+}
+var arrow;
+var init_convert_arrow_schema = __esm({
+  "../core/src/schema-utils/lib/schema/convert-arrow-schema.ts"() {
+    "use strict";
+    arrow = __toESM(require("apache-arrow"), 1);
+  }
+});
+
+// ../core/src/schema-utils/lib/table/batch-builder/arrow-table-builder.ts
+var arrow2, ArrowTableBuilder;
+var init_arrow_table_builder = __esm({
+  "../core/src/schema-utils/lib/table/batch-builder/arrow-table-builder.ts"() {
+    "use strict";
+    arrow2 = __toESM(require("apache-arrow"), 1);
+    init_convert_arrow_schema();
+    ArrowTableBuilder = class {
+      schema;
+      arrowSchema;
+      arrowBuilders;
+      length;
+      constructor(schema, options) {
+        this.arrowSchema = convertSchemaToArrow(schema, options);
+        this.schema = (options == null ? void 0 : options.viewTypes) && options.viewTypes !== "never" ? convertArrowToSchema(this.arrowSchema) : schema;
+        this.arrowBuilders = this.arrowSchema.fields.map(
+          (field) => arrow2.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 arrow2.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 arrow2.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 arrow2.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 arrow2.Table(arrowRecordBatch)
+        };
+      }
+      /** Extract a record batch flushing the currently accumulated data in the builders */
+      _getArrowRecordBatch() {
+        var _a;
+        const { arrowBuilders, arrowSchema } = this;
+        const arrowDatas = arrowBuilders.map((builder) => builder.flush());
+        const length = ((_a = arrowDatas[0]) == null ? void 0 : _a.length) || this.length;
+        this.length = 0;
+        const structField = new arrow2.Struct(arrowSchema.fields);
+        const arrowStructData = new arrow2.Data(structField, 0, length, 0, void 0, arrowDatas);
+        const arrowRecordBatch = new arrow2.RecordBatch(arrowSchema, arrowStructData);
+        return arrowRecordBatch;
+      }
+    };
+  }
+});
+
+// ../core/src/schema-utils/index.ts
+var init_schema_utils = __esm({
+  "../core/src/schema-utils/index.ts"() {
+    "use strict";
+    init_convert_arrow_schema();
+    init_data_type();
+    init_arrow_table_builder();
+  }
+});
+
+// ../arrow-geometry/src/wkb-types.ts
+var WKBGeometryType;
+var init_wkb_types = __esm({
+  "../arrow-geometry/src/wkb-types.ts"() {
+    "use strict";
+    WKBGeometryType = /* @__PURE__ */ ((WKBGeometryType2) => {
+      WKBGeometryType2[WKBGeometryType2["Point"] = 1] = "Point";
+      WKBGeometryType2[WKBGeometryType2["LineString"] = 2] = "LineString";
+      WKBGeometryType2[WKBGeometryType2["Polygon"] = 3] = "Polygon";
+      WKBGeometryType2[WKBGeometryType2["MultiPoint"] = 4] = "MultiPoint";
+      WKBGeometryType2[WKBGeometryType2["MultiLineString"] = 5] = "MultiLineString";
+      WKBGeometryType2[WKBGeometryType2["MultiPolygon"] = 6] = "MultiPolygon";
+      WKBGeometryType2[WKBGeometryType2["GeometryCollection"] = 7] = "GeometryCollection";
+      return WKBGeometryType2;
+    })(WKBGeometryType || {});
+  }
+});
+
+// ../arrow-geometry/src/wkb-builder.ts
+function getDimension(hasZ, hasM) {
+  return hasZ && hasM ? "xyzm" : hasZ ? "xyz" : hasM ? "xym" : "xy";
+}
+function getGeometryTypeName(type) {
+  return typeof type === "number" ? WKBGeometryType[type] : type;
+}
+var import_wkb2, WKBBuilder2;
+var init_wkb_builder = __esm({
+  "../arrow-geometry/src/wkb-builder.ts"() {
+    "use strict";
+    import_wkb2 = require("@math.gl/geospatial/wkb");
+    init_wkb_types();
+    WKBBuilder2 = class _WKBBuilder {
+      mode;
+      hasZ;
+      hasM;
+      transform;
+      builder;
+      constructor(options) {
+        this.mode = options.mode;
+        this.hasZ = Boolean(options.hasZ);
+        this.hasM = Boolean(options.hasM);
+        this.transform = options.transform;
+        const dimension = getDimension(this.hasZ, this.hasM);
+        const transform = options.transform ? (coordinate) => {
+          const transformed = options.transform([coordinate[0], coordinate[1]]);
+          return [transformed[0], transformed[1], ...coordinate.slice(2)];
+        } : void 0;
+        this.builder = options.mode === "write" ? new import_wkb2.WKBBuilder({
+          mode: "write",
+          target: options.target,
+          byteOffset: options.byteOffset,
+          dimension,
+          transform
+        }) : new import_wkb2.WKBBuilder({ mode: "measure", dimension, transform });
+      }
+      /** Begins a geometry by type, optionally writing its count field. */
+      beginGeometry(type, count) {
+        const geometryTypeName = getGeometryTypeName(type);
+        if (!geometryTypeName) {
+          throw new Error("Unsupported WKB geometry type");
+        }
+        this.callBuilder(() => this.builder.beginGeometry(geometryTypeName, count));
+      }
+      /** Begins one point geometry. */
+      beginPoint() {
+        this.callBuilder(() => this.builder.beginPoint());
+      }
+      /** Begins one linestring geometry. */
+      beginLineString(pointCount) {
+        this.callBuilder(() => this.builder.beginLineString(pointCount));
+      }
+      /** Begins one polygon geometry. */
+      beginPolygon(ringCount) {
+        this.callBuilder(() => this.builder.beginPolygon(ringCount));
+      }
+      /** Begins one linear ring inside a polygon. */
+      beginLinearRing(pointCount) {
+        this.callBuilder(() => this.builder.beginLinearRing(pointCount));
+      }
+      /** Begins one multipoint geometry. */
+      beginMultiPoint(pointCount) {
+        this.callBuilder(() => this.builder.beginMultiPoint(pointCount));
+      }
+      /** Begins one multilinestring geometry. */
+      beginMultiLineString(lineCount) {
+        this.callBuilder(() => this.builder.beginMultiLineString(lineCount));
+      }
+      /** Begins one multipolygon geometry. */
+      beginMultiPolygon(polygonCount) {
+        this.callBuilder(() => this.builder.beginMultiPolygon(polygonCount));
+      }
+      /** Writes one coordinate using the builder's dimensional options. */
+      writeCoordinate(x, y, z, m) {
+        this.callBuilder(() => this.builder.writeCoordinate(x, y, z, m));
+      }
+      /** Finishes the current geometry and returns its byte length. */
+      finishGeometry() {
+        return this.callBuilder(() => this.builder.finishGeometry());
+      }
+      /** Returns the number of bytes measured or written by this builder. */
+      getByteLength() {
+        return this.callBuilder(() => this.builder.finishGeometry());
+      }
+      /** Runs a math.gl builder operation while preserving the legacy facade error text. */
+      callBuilder(callback) {
+        try {
+          return callback();
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("target buffer overflow")) {
+            throw new Error("WKBBuilder overflow");
+          }
+          throw error;
+        }
+      }
+      /** Measures geometry writer callbacks and returns Arrow Binary offsets. */
+      static measureGeometryArray(geometryWriters, options = {}) {
+        const valueOffsets = new Int32Array(geometryWriters.length + 1);
+        for (let index = 0; index < geometryWriters.length; index++) {
+          const writer = geometryWriters[index];
+          if (writer) {
+            const builder = new _WKBBuilder({ mode: "measure", ...options });
+            writer(builder);
+            valueOffsets[index + 1] = valueOffsets[index] + builder.finishGeometry();
+          } else {
+            valueOffsets[index + 1] = valueOffsets[index];
+          }
+        }
+        return valueOffsets;
+      }
+      /** Writes geometry writer callbacks into an existing contiguous values buffer. */
+      static writeGeometryArray(geometryWriters, valueOffsets, values, options = {}) {
+        for (let index = 0; index < geometryWriters.length; index++) {
+          const writer = geometryWriters[index];
+          if (writer) {
+            const builder = new _WKBBuilder({
+              mode: "write",
+              target: values,
+              byteOffset: valueOffsets[index],
+              ...options
+            });
+            writer(builder);
+            builder.finishGeometry();
+          }
+        }
+        return values;
+      }
+      /** Builds Arrow-style offsets, values, and validity buffers in two passes. */
+      static buildGeometryArray(geometryWriters, options = {}) {
+        const valueOffsets = _WKBBuilder.measureGeometryArray(geometryWriters, options);
+        const values = new Uint8Array(valueOffsets[valueOffsets.length - 1]);
+        _WKBBuilder.writeGeometryArray(geometryWriters, valueOffsets, values, options);
+        const nullBitmap = new Uint8Array(Math.ceil(geometryWriters.length / 8));
+        let nullCount = 0;
+        for (let index = 0; index < geometryWriters.length; index++) {
+          if (geometryWriters[index]) nullBitmap[index >> 3] |= 1 << (index & 7);
+          else nullCount++;
+        }
+        return { valueOffsets, values, nullBitmap: nullCount ? nullBitmap : void 0, nullCount };
+      }
+    };
+  }
+});
+
+// ../arrow-geometry/src/wkb-arrow-utils.ts
+function makeWKBGeometryDataFromWriters(geometryWriters, options = {}) {
+  return makeWKBGeometryDataFromArray(
+    WKBBuilder2.buildGeometryArray(normalizeGeometryWriters(geometryWriters), options)
+  );
+}
+function makeWKBGeometryDataFromArray(geometryArray) {
+  return new arrow3.Data(
+    new arrow3.Binary(),
+    0,
+    geometryArray.valueOffsets.length - 1,
+    geometryArray.nullCount,
+    [
+      geometryArray.valueOffsets,
+      geometryArray.values,
+      geometryArray.nullCount > 0 ? geometryArray.nullBitmap : void 0
+    ]
+  );
+}
+function normalizeGeometryWriters(geometryWriters) {
+  return geometryWriters.map((geometryWriter) => geometryWriter || null);
+}
+var arrow3;
+var init_wkb_arrow_utils = __esm({
+  "../arrow-geometry/src/wkb-arrow-utils.ts"() {
+    "use strict";
+    arrow3 = __toESM(require("apache-arrow"), 1);
+    init_wkb_builder();
+  }
+});
+
+// ../arrow-geometry/src/geoarrow-builder.ts
+function makePrimitiveData(values) {
+  return arrow4.makeData({ type: new arrow4.Float64(), data: values });
+}
+function getBoxFieldNames(dimension) {
+  const minimumNames = dimension === "xy" ? ["xmin", "ymin"] : dimension === "xyz" ? ["xmin", "ymin", "zmin"] : dimension === "xym" ? ["xmin", "ymin", "mmin"] : ["xmin", "ymin", "zmin", "mmin"];
+  const maximumNames = dimension === "xy" ? ["xmax", "ymax"] : dimension === "xyz" ? ["xmax", "ymax", "zmax"] : dimension === "xym" ? ["xmax", "ymax", "mmax"] : ["xmax", "ymax", "zmax", "mmax"];
+  return [...minimumNames, ...maximumNames];
+}
+function getCoordinateSize(dimension) {
+  return dimension === "xy" ? 2 : dimension === "xyzm" ? 4 : 3;
+}
+function makeCoordinateData(values, dimension, coordinateLayout) {
+  if (coordinateLayout === "separated") {
+    const coordinateBuffers = values;
+    const coordinateNames = getCoordinateNames(dimension);
+    return arrow4.makeData({
+      type: new arrow4.Struct(
+        coordinateNames.map((name) => new arrow4.Field(name, new arrow4.Float64(), false))
+      ),
+      children: coordinateNames.map((name) => makePrimitiveData(coordinateBuffers[name]))
+    });
+  }
+  return arrow4.makeData({
+    type: new arrow4.FixedSizeList(
+      getCoordinateSize(dimension),
+      new arrow4.Field(dimension, new arrow4.Float64(), false)
+    ),
+    child: makePrimitiveData(values)
+  });
+}
+function makeBoxData(values, dimension) {
+  const names = getBoxFieldNames(dimension);
+  const children = names.map((name, index) => {
+    if (values instanceof Float64Array) {
+      const boxSize = names.length;
+      return makePrimitiveData(
+        Float64Array.from(
+          { length: values.length / boxSize },
+          (_, rowIndex) => values[rowIndex * boxSize + index]
+        )
+      );
+    }
+    return makePrimitiveData(values[name]);
+  });
+  return arrow4.makeData({
+    type: new arrow4.Struct(names.map((name) => new arrow4.Field(name, new arrow4.Float64(), false))),
+    children
+  });
+}
+function makeListData(child, offsets, fieldName, offsetType) {
+  return arrow4.makeData({
+    type: offsetType === "int64" ? makeLargeListType(new arrow4.Field(fieldName, child.type, false)) : new arrow4.List(new arrow4.Field(fieldName, child.type, false)),
+    valueOffsets: offsets,
+    child
+  });
+}
+function makeLargeListType(field) {
+  const LargeList = getOptionalArrowConstructor2("LargeList");
+  if (!LargeList) {
+    throw new Error(
+      "64-bit GeoArrow offsets require an Apache Arrow runtime that exports LargeList"
+    );
+  }
+  return new LargeList(field);
+}
+function getOptionalArrowConstructor2(typeName) {
+  return arrow4[typeName];
+}
+function makeCoordinateBuffers(coordinateCount, dimension, coordinateLayout) {
+  if (coordinateLayout === "interleaved") {
+    return new Float64Array(coordinateCount * getCoordinateSize(dimension));
+  }
+  const coordinateNames = getCoordinateNames(dimension);
+  const buffers = {
+    x: new Float64Array(coordinateCount),
+    y: new Float64Array(coordinateCount)
+  };
+  for (const name of coordinateNames.slice(2)) buffers[name] = new Float64Array(coordinateCount);
+  return buffers;
+}
+function makeBoxBuffers(boxCount, dimension, coordinateLayout) {
+  const names = getBoxFieldNames(dimension);
+  if (coordinateLayout === "interleaved") {
+    return new Float64Array(boxCount * names.length);
+  }
+  const buffers = {};
+  for (const name of names) {
+    buffers[name] = new Float64Array(boxCount);
+  }
+  return buffers;
+}
+function getBoxValues(dimension, xmin, ymin, xmax, ymax, zmin, zmax, mmin, mmax) {
+  switch (dimension) {
+    case "xy":
+      return [xmin, ymin, xmax, ymax];
+    case "xyz":
+      return [xmin, ymin, zmin ?? Number.NaN, xmax, ymax, zmax ?? Number.NaN];
+    case "xym":
+      return [xmin, ymin, mmin ?? Number.NaN, xmax, ymax, mmax ?? Number.NaN];
+    case "xyzm":
+      return [
+        xmin,
+        ymin,
+        zmin ?? Number.NaN,
+        mmin ?? Number.NaN,
+        xmax,
+        ymax,
+        zmax ?? Number.NaN,
+        mmax ?? Number.NaN
+      ];
+  }
+}
+function getCoordinateNames(dimension) {
+  switch (dimension) {
+    case "xy":
+      return ["x", "y"];
+    case "xyz":
+      return ["x", "y", "z"];
+    case "xym":
+      return ["x", "y", "m"];
+    case "xyzm":
+      return ["x", "y", "z", "m"];
+  }
+}
+function withNulls(data, geometryArray) {
+  return new arrow4.Data(
+    data.type,
+    0,
+    geometryArray.length,
+    geometryArray.nullCount,
+    [
+      data.valueOffsets,
+      data.values,
+      geometryArray.nullCount > 0 ? geometryArray.nullBitmap : void 0
+    ],
+    data.children
+  );
+}
+var arrow4, GeoArrowBuilder;
+var init_geoarrow_builder = __esm({
+  "../arrow-geometry/src/geoarrow-builder.ts"() {
+    "use strict";
+    arrow4 = __toESM(require("apache-arrow"), 1);
+    GeoArrowBuilder = class _GeoArrowBuilder {
+      /** GeoArrow extension encoding emitted by this builder. */
+      encoding;
+      /** Whether coordinate tuples include Z. */
+      hasZ;
+      /** Whether coordinate tuples include M. */
+      hasM;
+      /** Exact coordinate dimension emitted by this builder. */
+      dimension;
+      state;
+      /** Creates a GeoArrow builder in measure or write mode. */
+      constructor(options) {
+        this.encoding = options.encoding;
+        this.dimension = options.dimension || (options.hasZ && options.hasM ? "xyzm" : options.hasZ ? "xyz" : options.hasM ? "xym" : "xy");
+        this.hasZ = this.dimension === "xyz" || this.dimension === "xyzm";
+        this.hasM = this.dimension === "xym" || this.dimension === "xyzm";
+        const coordinateLayout = options.coordinateLayout || "interleaved";
+        const offsetType = options.offsetType || "int32";
+        this.state = {
+          mode: options.mode,
+          encoding: options.encoding,
+          coordinateSize: getCoordinateSize(this.dimension),
+          coordinateLayout,
+          offsetType,
+          transform: options.transform,
+          length: 0,
+          nullCount: 0,
+          coordinateCount: 0,
+          geometryChildCount: 0,
+          partChildCount: 0,
+          geometryOffsetCount: 1,
+          partOffsetCount: 1,
+          ringOffsetCount: 1,
+          target: options.mode === "write" ? options.target : void 0
+        };
+        this.initializeOffsets();
+      }
+      /** Emits one null geometry row. */
+      writeNullGeometry() {
+        this.state.length++;
+        this.state.nullCount++;
+        if (this.encoding !== "geoarrow.point" && this.encoding !== "geoarrow.box") {
+          this.writeGeometryOffset();
+        }
+        if (this.encoding === "geoarrow.point") this.state.coordinateCount++;
+      }
+      /** Begins one top-level geometry. */
+      beginGeometry(_type, _count) {
+        this.setValid(this.state.length);
+        this.state.length++;
+      }
+      /** Begins one point geometry or nested point. */
+      beginPoint() {
+        if (this.encoding === "geoarrow.point") this.beginGeometry();
+      }
+      /** Begins one axis-aligned GeoArrow box row. */
+      beginBox() {
+        if (this.encoding !== "geoarrow.box") {
+          throw new Error(`Cannot write Box into ${this.encoding}`);
+        }
+        this.beginGeometry();
+      }
+      /** Writes one axis-aligned box in canonical minimum-then-maximum ordinate order. */
+      writeBox(xmin, ymin, xmax, ymax, zmin, zmax, mmin, mmax) {
+        if (this.encoding !== "geoarrow.box") {
+          throw new Error(`Cannot write Box into ${this.encoding}`);
+        }
+        const coordinateIndex = this.state.coordinateCount;
+        const values = getBoxValues(this.dimension, xmin, ymin, xmax, ymax, zmin, zmax, mmin, mmax);
+        if (this.state.mode === "write") {
+          this.writeBoxValues(this.getTarget().coordinates, coordinateIndex, values);
+        }
+        this.state.coordinateCount++;
+      }
+      /** Begins one line string geometry or nested line string. */
+      beginLineString(pointCount) {
+        if (this.encoding === "geoarrow.linestring") {
+          this.beginGeometry();
+          this.writeGeometryOffset(pointCount);
+          return;
+        }
+        if (this.encoding === "geoarrow.multilinestring") {
+          this.writePartOffset(pointCount);
+          return;
+        }
+        throw new Error(`Cannot write LineString into ${this.encoding}`);
+      }
+      /** Begins one polygon geometry or nested polygon. */
+      beginPolygon(ringCount) {
+        if (this.encoding === "geoarrow.polygon") {
+          this.beginGeometry();
+          this.writeGeometryOffset(ringCount);
+          return;
+        }
+        if (this.encoding === "geoarrow.multipolygon") {
+          this.writePartOffset(ringCount);
+          return;
+        }
+        throw new Error(`Cannot write Polygon into ${this.encoding}`);
+      }
+      /** Begins one polygon linear ring. */
+      beginLinearRing(pointCount) {
+        if (this.encoding === "geoarrow.polygon") {
+          this.writePartOffset(pointCount);
+          return;
+        }
+        if (this.encoding === "geoarrow.multipolygon") {
+          this.writeRingOffset(pointCount);
+          return;
+        }
+        throw new Error(`Cannot write LinearRing into ${this.encoding}`);
+      }
+      /** Begins one multipoint geometry. */
+      beginMultiPoint(pointCount) {
+        if (this.encoding !== "geoarrow.multipoint") {
+          throw new Error(`Cannot write MultiPoint into ${this.encoding}`);
+        }
+        this.beginGeometry();
+        this.writeGeometryOffset(pointCount);
+      }
+      /** Begins one multilinestring geometry. */
+      beginMultiLineString(lineCount) {
+        if (this.encoding !== "geoarrow.multilinestring") {
+          throw new Error(`Cannot write MultiLineString into ${this.encoding}`);
+        }
+        this.beginGeometry();
+        this.writeGeometryOffset(lineCount);
+      }
+      /** Begins one multipolygon geometry. */
+      beginMultiPolygon(polygonCount) {
+        if (this.encoding !== "geoarrow.multipolygon") {
+          throw new Error(`Cannot write MultiPolygon into ${this.encoding}`);
+        }
+        this.beginGeometry();
+        this.writeGeometryOffset(polygonCount);
+      }
+      /** Writes one coordinate tuple. The third ordinate is M for an XYM builder. */
+      writeCoordinate(x, y, z, m) {
+        const coordinateIndex = this.state.coordinateCount;
+        if (this.state.mode === "write") {
+          const target = this.getTarget();
+          const coordinate = this.getCoordinateValuesForWrite(x, y, z, m);
+          const transformedCoordinate = this.state.transform ? this.state.transform(coordinate) : coordinate;
+          this.writeCoordinateValues(
+            target.coordinates,
+            coordinateIndex,
+            transformedCoordinate,
+            coordinate
+          );
+        }
+        this.state.coordinateCount++;
+      }
+      /** Completes the current geometry array and returns its row count. */
+      finishGeometry() {
+        return this.state.length;
+      }
+      /** Returns current measured or written array metadata. */
+      getGeometryArray() {
+        return {
+          encoding: this.encoding,
+          coordinateSize: this.state.coordinateSize,
+          dimension: this.dimension,
+          coordinateLayout: this.state.coordinateLayout,
+          offsetType: this.state.offsetType,
+          length: this.state.length,
+          nullCount: this.state.nullCount,
+          nullBitmap: this.getNullBitmap(),
+          coordinates: this.getCoordinateValues(),
+          geometryOffsets: this.getGeometryOffsets(),
+          partOffsets: this.getPartOffsets(),
+          ringOffsets: this.getRingOffsets()
+        };
+      }
+      /** Measures geometry callbacks and returns allocated offsets. */
+      static measureGeometryArray(writers, options) {
+        const builder = new _GeoArrowBuilder({ mode: "measure", ...options });
+        for (const writer of writers) writer ? writer(builder) : builder.writeNullGeometry();
+        builder.finishGeometry();
+        return builder.getGeometryArray();
+      }
+      /** Writes geometry callbacks into a measured target. */
+      static writeGeometryArray(writers, measured, options) {
+        const builder = new _GeoArrowBuilder({ mode: "write", target: measured, ...options });
+        for (const writer of writers) writer ? writer(builder) : builder.writeNullGeometry();
+        builder.finishGeometry();
+        return builder.getGeometryArray();
+      }
+      /** Builds GeoArrow buffers from callbacks in two passes. */
+      static buildGeometryArray(writers, options) {
+        const measured = _GeoArrowBuilder.measureGeometryArray(writers, options);
+        return _GeoArrowBuilder.writeGeometryArray(writers, measured, options);
+      }
+      /** Wraps GeoArrow buffers in an Apache Arrow Data instance. */
+      static makeGeometryData(geometryArray) {
+        if (geometryArray.encoding === "geoarrow.box") {
+          return withNulls(
+            makeBoxData(geometryArray.coordinates, geometryArray.dimension),
+            geometryArray
+          );
+        }
+        const coordinateData = makeCoordinateData(
+          geometryArray.coordinates,
+          geometryArray.dimension,
+          geometryArray.coordinateLayout
+        );
+        let data = coordinateData;
+        switch (geometryArray.encoding) {
+          case "geoarrow.point":
+            return withNulls(data, geometryArray);
+          case "geoarrow.linestring":
+          case "geoarrow.multipoint":
+            data = makeListData(
+              coordinateData,
+              geometryArray.geometryOffsets,
+              "vertices",
+              geometryArray.offsetType
+            );
+            return withNulls(data, geometryArray);
+          case "geoarrow.polygon":
+          case "geoarrow.multilinestring":
+            data = makeListData(
+              coordinateData,
+              geometryArray.partOffsets,
+              "vertices",
+              geometryArray.offsetType
+            );
+            data = makeListData(
+              data,
+              geometryArray.geometryOffsets,
+              "rings",
+              geometryArray.offsetType
+            );
+            return withNulls(data, geometryArray);
+          case "geoarrow.multipolygon":
+            data = makeListData(
+              coordinateData,
+              geometryArray.ringOffsets,
+              "vertices",
+              geometryArray.offsetType
+            );
+            data = makeListData(data, geometryArray.partOffsets, "rings", geometryArray.offsetType);
+            data = makeListData(
+              data,
+              geometryArray.geometryOffsets,
+              "polygons",
+              geometryArray.offsetType
+            );
+            return withNulls(data, geometryArray);
+          default:
+            throw new Error(`Unsupported GeoArrow encoding ${geometryArray.encoding}`);
+        }
+      }
+      initializeOffsets() {
+        if (this.state.mode !== "measure") return;
+        const target = {
+          nullBitmap: new Uint8Array(0),
+          coordinates: makeCoordinateBuffers(0, this.dimension, this.state.coordinateLayout)
+        };
+        if (this.encoding !== "geoarrow.point" && this.encoding !== "geoarrow.box") {
+          target.geometryOffsets = this.makeOffsets(1);
+        }
+        if (this.encoding === "geoarrow.polygon" || this.encoding === "geoarrow.multilinestring" || this.encoding === "geoarrow.multipolygon") {
+          target.partOffsets = this.makeOffsets(1);
+        }
+        if (this.encoding === "geoarrow.multipolygon") target.ringOffsets = this.makeOffsets(1);
+        this.state.target = target;
+      }
+      getCoordinateValuesForWrite(x, y, z, m) {
+        if (this.dimension === "xy") return [x, y];
+        if (this.dimension === "xyz") return [x, y, z ?? Number.NaN];
+        if (this.dimension === "xym") return [x, y, m ?? z ?? Number.NaN];
+        return [x, y, z ?? Number.NaN, m ?? Number.NaN];
+      }
+      writeGeometryOffset(childCount = 0) {
+        if (this.encoding === "geoarrow.point") return;
+        this.state.geometryChildCount += childCount;
+        this.appendOffset("geometryOffsets", this.state.geometryChildCount);
+      }
+      writePartOffset(childCount = 0) {
+        this.state.partChildCount += childCount;
+        this.appendOffset("partOffsets", this.state.partChildCount);
+      }
+      writeRingOffset(childCount = 0) {
+        this.appendOffset("ringOffsets", this.state.coordinateCount + childCount);
+      }
+      appendOffset(name, value) {
+        const target = this.getTarget();
+        const offsets = target[name];
+        if (!offsets) return;
+        if (this.state.mode === "measure") {
+          this.incrementOffsetCount(name);
+          return;
+        }
+        const index = this.getOffsetCount(name);
+        if (index >= offsets.length) throw new Error(`GeoArrowBuilder target ${name} overflow`);
+        offsets[index] = offsets instanceof BigInt64Array ? BigInt(value) : value;
+        this.incrementOffsetCount(name);
+      }
+      getOffsetCount(name) {
+        switch (name) {
+          case "geometryOffsets":
+            return this.state.geometryOffsetCount;
+          case "partOffsets":
+            return this.state.partOffsetCount;
+          case "ringOffsets":
+            return this.state.ringOffsetCount;
+          default:
+            throw new Error(`Unexpected offset buffer ${name}`);
+        }
+      }
+      incrementOffsetCount(name) {
+        switch (name) {
+          case "geometryOffsets":
+            this.state.geometryOffsetCount++;
+            return;
+          case "partOffsets":
+            this.state.partOffsetCount++;
+            return;
+          case "ringOffsets":
+            this.state.ringOffsetCount++;
+            return;
+          default:
+            throw new Error(`Unexpected offset buffer ${name}`);
+        }
+      }
+      setValid(rowIndex) {
+        if (this.state.mode !== "write") return;
+        const bitmap = this.getTarget().nullBitmap;
+        bitmap[rowIndex >> 3] |= 1 << (rowIndex & 7);
+      }
+      getTarget() {
+        if (!this.state.target) throw new Error("GeoArrowBuilder target is not initialized");
+        return this.state.target;
+      }
+      getNullBitmap() {
+        return this.state.mode === "measure" ? new Uint8Array(Math.ceil(this.state.length / 8)) : this.getTarget().nullBitmap;
+      }
+      getCoordinateValues() {
+        return this.state.mode === "measure" ? this.encoding === "geoarrow.box" ? makeBoxBuffers(this.state.coordinateCount, this.dimension, this.state.coordinateLayout) : makeCoordinateBuffers(
+          this.state.coordinateCount,
+          this.dimension,
+          this.state.coordinateLayout
+        ) : this.getTarget().coordinates;
+      }
+      getGeometryOffsets() {
+        return this.state.mode === "measure" && this.encoding !== "geoarrow.point" && this.encoding !== "geoarrow.box" ? this.makeOffsets(this.state.geometryOffsetCount) : this.getTarget().geometryOffsets;
+      }
+      getPartOffsets() {
+        return this.state.mode === "measure" && (this.encoding === "geoarrow.polygon" || this.encoding === "geoarrow.multilinestring" || this.encoding === "geoarrow.multipolygon") ? this.makeOffsets(this.state.partOffsetCount) : this.getTarget().partOffsets;
+      }
+      getRingOffsets() {
+        return this.state.mode === "measure" && this.encoding === "geoarrow.multipolygon" ? this.makeOffsets(this.state.ringOffsetCount) : this.getTarget().ringOffsets;
+      }
+      makeOffsets(length) {
+        return this.state.offsetType === "int64" ? new BigInt64Array(length) : new Int32Array(length);
+      }
+      writeCoordinateValues(coordinates, coordinateIndex, transformedCoordinate, originalCoordinate) {
+        if (coordinates instanceof Float64Array) {
+          if (coordinateIndex >= coordinates.length / this.state.coordinateSize) {
+            throw new Error("GeoArrowBuilder target coordinate buffer overflow");
+          }
+          const valueOffset = coordinateIndex * this.state.coordinateSize;
+          for (let dimensionIndex = 0; dimensionIndex < this.state.coordinateSize; dimensionIndex++) {
+            coordinates[valueOffset + dimensionIndex] = transformedCoordinate[dimensionIndex] ?? originalCoordinate[dimensionIndex] ?? Number.NaN;
+          }
+          return;
+        }
+        const coordinateNames = getCoordinateNames(this.dimension);
+        for (let dimensionIndex = 0; dimensionIndex < coordinateNames.length; dimensionIndex++) {
+          const coordinateValues = coordinates[coordinateNames[dimensionIndex]];
+          if (!coordinateValues || coordinateIndex >= coordinateValues.length) {
+            throw new Error("GeoArrowBuilder target coordinate buffer overflow");
+          }
+          coordinateValues[coordinateIndex] = transformedCoordinate[dimensionIndex] ?? originalCoordinate[dimensionIndex] ?? Number.NaN;
+        }
+      }
+      writeBoxValues(coordinates, coordinateIndex, values) {
+        if (coordinates instanceof Float64Array) {
+          const valueOffset = coordinateIndex * values.length;
+          if (valueOffset + values.length > coordinates.length) {
+            throw new Error("GeoArrowBuilder target box buffer overflow");
+          }
+          coordinates.set(values, valueOffset);
+          return;
+        }
+        const boxCoordinates = coordinates;
+        const names = getBoxFieldNames(this.dimension);
+        for (let index = 0; index < names.length; index++) {
+          const valuesBuffer = boxCoordinates[names[index]];
+          if (!(valuesBuffer instanceof Float64Array) || coordinateIndex >= valuesBuffer.length) {
+            throw new Error("GeoArrowBuilder target box buffer overflow");
+          }
+          valuesBuffer[coordinateIndex] = values[index];
+        }
+      }
+    };
+  }
+});
+
+// ../arrow-geometry/src/index.ts
+var init_src = __esm({
+  "../arrow-geometry/src/index.ts"() {
+    "use strict";
+    init_geoarrow_builder();
+  }
+});
+
+// dist/mlt/lib/parse-mlt.js
+function parseMLT(arrayBuffer, options) {
+  const mltOptions = checkOptions(options);
+  const shape = mltOptions.shape;
+  switch (shape) {
+    case "geojson-table": {
+      const table = {
+        shape: "geojson-table",
+        type: "FeatureCollection",
+        features: parseToGeojsonFeatures(arrayBuffer, mltOptions)
+      };
+      return table;
+    }
+    case "binary-geometry": {
+      const geojsonFeatures = parseToGeojsonFeatures(arrayBuffer, mltOptions);
+      const binaryData = convertGeojsonToBinaryFeatureCollection(geojsonFeatures);
+      binaryData.byteLength = arrayBuffer.byteLength;
+      return binaryData;
+    }
+    case "arrow-table":
+      return parseToArrowTable(arrayBuffer, mltOptions);
+    default:
+      throw new Error(shape || "undefined shape");
+  }
+}
+function parseToArrowTable(arrayBuffer, options) {
+  var _a;
+  if (arrayBuffer.byteLength <= 0) {
+    return makeWKBArrowTable([], [], []);
+  }
+  const tile = new Uint8Array(arrayBuffer);
+  const featureTables = getFeatureTables(decodeTile(tile));
+  const selectedLayers = options.layers && options.layers.length > 0 ? options.layers : featureTables.map((ft) => ft.name).filter(Boolean);
+  const propertyRows = [];
+  const geometryWriters = [];
+  const geometries = [];
+  for (const featureTable of featureTables) {
+    const layerName = featureTable.name;
+    if (!layerName || !selectedLayers.includes(layerName)) {
+      continue;
+    }
+    const geometryVector = featureTable.geometryVector;
+    if (!geometryVector) {
+      continue;
+    }
+    const tableGeometries = geometryVector.getGeometries();
+    const featureCount = Math.min(geometryVector.numGeometries, tableGeometries.length);
+    const propertyVectors = featureTable.propertyVectors || [];
+    const extent = featureTable.extent ?? 4096;
+    for (let featureIndex = 0; featureIndex < featureCount; featureIndex++) {
+      const geometry = {
+        type: geometryVector.geometryType(featureIndex),
+        coordinates: tableGeometries[featureIndex],
+        extent
+      };
+      const properties = {};
+      for (const propertyVector of propertyVectors) {
+        properties[propertyVector.name] = normalizePropertyValue(propertyVector.getValue(featureIndex));
+      }
+      if (options.layerProperty) {
+        properties[options.layerProperty] = layerName;
+      }
+      propertyRows.push(properties);
+      geometries.push(geometry);
+      geometryWriters.push(createWKBGeometryWriter(geometry, options, extent));
+    }
+  }
+  const encodingPreference = (_a = options.geoarrow) == null ? void 0 : _a.encodingPreference;
+  if (encodingPreference && encodingPreference !== "geoarrow.wkb") {
+    return makeNativeArrowTable(propertyRows, geometries, options, encodingPreference);
+  }
+  return makeWKBArrowTable(propertyRows, geometryWriters, geometries);
+}
+function makeWKBArrowTable(propertyRows, geometryWriters, geometries) {
+  const propertySchema = getPropertySchema(propertyRows);
+  const schema = {
+    fields: [...propertySchema.fields, makeWKBGeometryField("geometry")],
+    metadata: { ...propertySchema.metadata || {} }
+  };
+  setWKBGeometrySchemaMetadata(schema, {
+    geometryColumnName: "geometry",
+    geometryTypes: [
+      ...new Set(geometries.map((geometry) => geometryTypeToGeoJSONType(geometry.type)))
+    ].filter(Boolean).map((type) => type)
+  });
+  const propertyBuilder = new ArrowTableBuilder(propertySchema);
+  for (const propertyRow of propertyRows) {
+    propertyBuilder.addObjectRow(propertyRow);
+  }
+  const propertyData = propertyBuilder.finishTable().data;
+  const propertyBatch = propertyData.batches[0];
+  const geometryData = makeWKBGeometryDataFromWriters(geometryWriters);
+  const arrowSchema = convertSchemaToArrow(schema);
+  const children = [...(propertyBatch == null ? void 0 : propertyBatch.data.children) || [], geometryData];
+  const structData = arrow5.makeData({
+    type: new arrow5.Struct(arrowSchema.fields),
+    length: propertyRows.length,
+    nullCount: 0,
+    children
+  });
+  return {
+    shape: "arrow-table",
+    schema,
+    data: new arrow5.Table(new arrow5.RecordBatch(arrowSchema, structData))
+  };
+}
+function makeNativeArrowTable(propertyRows, geometries, options, encodingPreference) {
+  const dimension = "xy";
+  const encoding = selectGeoArrowEncoding(geometries, encodingPreference);
+  const geometryVector = encoding === "geoarrow.geometry" ? makeGeoArrowUnionVector(geometries, options, dimension) : makeGeoArrowVector(geometries, encoding, options, dimension);
+  const propertySchema = getPropertySchema(propertyRows);
+  const propertyTableBuilder = new ArrowTableBuilder(propertySchema);
+  for (const propertyRow of propertyRows) {
+    propertyTableBuilder.addObjectRow(propertyRow);
+  }
+  const propertyBatch = propertyTableBuilder.finishTable().data.batches[0];
+  const propertyArrowSchema = convertSchemaToArrow(propertySchema);
+  const geometryTypes = [
+    ...new Set(geometries.map((geometry) => geometryTypeToGeoJSONType(geometry.type)))
+  ].filter(Boolean).map((type) => type);
+  const geometryField = new arrow5.Field("geometry", geometryVector.type, true, /* @__PURE__ */ new Map([
+    ["ARROW:extension:name", encoding],
+    ["ARROW:extension:metadata", JSON.stringify({ encoding, geometry_types: geometryTypes })]
+  ]));
+  const fields = [...propertyArrowSchema.fields, geometryField];
+  const metadata = new Map(propertyArrowSchema.metadata || []);
+  metadata.set("geo", JSON.stringify({
+    version: "1.1.0",
+    primary_column: "geometry",
+    columns: { geometry: { encoding, geometry_types: geometryTypes } }
+  }));
+  const arrowSchema = new arrow5.Schema(fields, metadata);
+  const children = [...(propertyBatch == null ? void 0 : propertyBatch.data.children) || [], geometryVector.data[0]];
+  const structData = arrow5.makeData({
+    type: new arrow5.Struct(fields),
+    length: propertyRows.length,
+    nullCount: 0,
+    children
+  });
+  return {
+    shape: "arrow-table",
+    schema: convertArrowToSchema(arrowSchema),
+    data: new arrow5.Table(new arrow5.RecordBatch(arrowSchema, structData))
+  };
+}
+function selectGeoArrowEncoding(geometries, preference) {
+  const geometryTypes = new Set(geometries.map((geometry) => geometryTypeToGeoJSONType(geometry.type)));
+  if (preference === "geoarrow.geometry" || geometryTypes.size === 0) {
+    return "geoarrow.geometry";
+  }
+  if (geometryTypes.size === 1) {
+    return getNativeGeoArrowEncoding([...geometryTypes][0]);
+  }
+  if (geometryTypes.size === 2) {
+    if (geometryTypes.has("Point") && geometryTypes.has("MultiPoint")) {
+      return "geoarrow.multipoint";
+    }
+    if (geometryTypes.has("LineString") && geometryTypes.has("MultiLineString")) {
+      return "geoarrow.multilinestring";
+    }
+    if (geometryTypes.has("Polygon") && geometryTypes.has("MultiPolygon")) {
+      return "geoarrow.multipolygon";
+    }
+  }
+  return "geoarrow.geometry";
+}
+function makeGeoArrowVector(geometries, encoding, options, dimension) {
+  const writers = geometries.map((geometry) => createGeoArrowGeometryWriter(geometry, encoding, options));
+  const geometryArray = GeoArrowBuilder.buildGeometryArray(writers, { encoding, dimension });
+  return arrow5.makeVector(GeoArrowBuilder.makeGeometryData(geometryArray));
+}
+function makeGeoArrowUnionVector(geometries, options, dimension) {
+  const geometryGroups = /* @__PURE__ */ new Map();
+  const supportedGeometryTypes = [
+    "Point",
+    "LineString",
+    "Polygon",
+    "MultiPoint",
+    "MultiLineString",
+    "MultiPolygon"
+  ];
+  for (const geometryType of supportedGeometryTypes) {
+    geometryGroups.set(geometryType, []);
+  }
+  const typeIds = [];
+  const valueOffsets = [];
+  for (const geometry of geometries) {
+    const geometryType = geometryTypeToGeoJSONType(geometry.type) || "Point";
+    const group = geometryGroups.get(geometryType) || [];
+    valueOffsets.push(group.length);
+    typeIds.push(getUnionTypeId(geometryType, dimension));
+    group.push(geometry);
+    geometryGroups.set(geometryType, group);
+  }
+  const orderedGeometryTypes = [...geometryGroups.keys()].sort((left, right) => getUnionTypeId(left, dimension) - getUnionTypeId(right, dimension));
+  const childVectors = orderedGeometryTypes.map((geometryType) => {
+    const encoding = getNativeGeoArrowEncoding(geometryType);
+    return makeGeoArrowVector(geometryGroups.get(geometryType), encoding, options, dimension);
+  });
+  const fields = orderedGeometryTypes.map((geometryType) => new arrow5.Field(getUnionFieldName(geometryType, dimension), childVectors[orderedGeometryTypes.indexOf(geometryType)].type, true));
+  const unionType = new arrow5.DenseUnion(orderedGeometryTypes.map((geometryType) => getUnionTypeId(geometryType, dimension)), fields);
+  return arrow5.makeVector(arrow5.makeData({
+    type: unionType,
+    length: geometries.length,
+    nullCount: 0,
+    typeIds: Int8Array.from(typeIds),
+    valueOffsets: Int32Array.from(valueOffsets),
+    children: childVectors.map((vector) => vector.data[0])
+  }));
+}
+function createGeoArrowGeometryWriter(geometry, encoding, options) {
+  return (builder) => {
+    var _a;
+    const coordinates = geometry.coordinates;
+    switch (geometryTypeToGeoJSONType(geometry.type)) {
+      case "Point":
+        if (encoding === "geoarrow.multipoint")
+          builder.beginMultiPoint(1);
+        builder.beginPoint();
+        writeGeoArrowPoint(builder, (_a = coordinates[0]) == null ? void 0 : _a[0], options, geometry.extent);
+        return;
+      case "MultiPoint":
+        builder.beginMultiPoint(coordinates.length);
+        for (const [point] of coordinates) {
+          builder.beginPoint();
+          writeGeoArrowPoint(builder, point, options, geometry.extent);
+        }
+        return;
+      case "LineString":
+        if (encoding === "geoarrow.multilinestring")
+          builder.beginMultiLineString(1);
+        writeGeoArrowLineString(builder, coordinates[0] || [], options, geometry.extent);
+        return;
+      case "MultiLineString":
+        builder.beginMultiLineString(coordinates.length);
+        for (const line of coordinates)
+          writeGeoArrowLineString(builder, line, options, geometry.extent);
+        return;
+      case "Polygon":
+        if (encoding === "geoarrow.multipolygon")
+          builder.beginMultiPolygon(1);
+        writeGeoArrowPolygon(builder, coordinates, options, geometry.extent);
+        return;
+      case "MultiPolygon":
+        builder.beginMultiPolygon(coordinates.length);
+        for (const ring of coordinates) {
+          builder.beginPolygon(1);
+          builder.beginLinearRing(ring.length);
+          for (const point of ring)
+            writeGeoArrowPoint(builder, point, options, geometry.extent);
+        }
+        return;
+      default:
+        return;
+    }
+  };
+}
+function writeGeoArrowPoint(builder, point, options, extent) {
+  const [x, y] = projectPoint((point == null ? void 0 : point.x) ?? Number.NaN, (point == null ? void 0 : point.y) ?? Number.NaN, options, extent);
+  builder.writeCoordinate(x, y);
+}
+function writeGeoArrowLineString(builder, line, options, extent) {
+  builder.beginLineString(line.length);
+  for (const point of line)
+    writeGeoArrowPoint(builder, point, options, extent);
+}
+function writeGeoArrowPolygon(builder, rings, options, extent) {
+  builder.beginPolygon(rings.length);
+  for (const ring of rings) {
+    builder.beginLinearRing(ring.length);
+    for (const point of ring)
+      writeGeoArrowPoint(builder, point, options, extent);
+  }
+}
+function getNativeGeoArrowEncoding(geometryType) {
+  switch (geometryType) {
+    case "Point":
+      return "geoarrow.point";
+    case "LineString":
+      return "geoarrow.linestring";
+    case "Polygon":
+      return "geoarrow.polygon";
+    case "MultiPoint":
+      return "geoarrow.multipoint";
+    case "MultiLineString":
+      return "geoarrow.multilinestring";
+    case "MultiPolygon":
+      return "geoarrow.multipolygon";
+    default:
+      throw new Error(`MLT Loader: unsupported GeoArrow geometry type ${geometryType}`);
+  }
+}
+function getUnionTypeId(geometryType, dimension) {
+  const baseTypeIds = {
+    Point: 1,
+    LineString: 2,
+    Polygon: 3,
+    MultiPoint: 4,
+    MultiLineString: 5,
+    MultiPolygon: 6
+  };
+  const dimensionOffset = dimension === "xyz" ? 10 : dimension === "xym" ? 20 : dimension === "xyzm" ? 30 : 0;
+  return (baseTypeIds[geometryType] || baseTypeIds.Point) + dimensionOffset;
+}
+function getUnionFieldName(geometryType, dimension) {
+  return dimension === "xy" ? geometryType : `${geometryType} ${dimension.slice(1).toUpperCase()}`;
+}
+function getPropertySchema(propertyRows) {
+  const fieldNames = /* @__PURE__ */ new Set();
+  for (const propertyRow of propertyRows) {
+    for (const fieldName of Object.keys(propertyRow)) {
+      fieldNames.add(fieldName);
+    }
+  }
+  return {
+    metadata: {},
+    fields: [...fieldNames].map((fieldName) => {
+      const inferredType = getDataTypeFromArray(propertyRows.map((propertyRow) => propertyRow[fieldName]));
+      return {
+        name: fieldName,
+        type: inferredType.type === "float32" ? "float64" : inferredType.type,
+        nullable: inferredType.nullable
+      };
+    })
+  };
+}
+function normalizePropertyValue(propertyValue) {
+  if (propertyValue === null || propertyValue === void 0 || typeof propertyValue === "string" || typeof propertyValue === "number" || typeof propertyValue === "boolean") {
+    return propertyValue ?? null;
+  }
+  return JSON.stringify(propertyValue);
+}
+function createWKBGeometryWriter(geometry, options, extent) {
+  const geometryType = geometryTypeToGeoJSONType(geometry.type);
+  if (!geometryType || !geometry.coordinates) {
+    return null;
+  }
+  const transform = (coordinate) => projectPoint(coordinate[0], coordinate[1], options, extent);
+  return (builder) => {
+    var _a, _b;
+    const coordinates = geometry.coordinates;
+    switch (geometryType) {
+      case "Point":
+        if (!((_a = coordinates[0]) == null ? void 0 : _a[0]))
+          return;
+        builder.beginPoint();
+        writePoint(builder, coordinates[0][0], transform);
+        return;
+      case "MultiPoint":
+        builder.beginMultiPoint(coordinates.length);
+        for (const [point] of coordinates)
+          writePoint(builder, point, transform);
+        return;
+      case "LineString":
+        builder.beginLineString(((_b = coordinates[0]) == null ? void 0 : _b.length) || 0);
+        for (const point of coordinates[0] || [])
+          writePoint(builder, point, transform);
+        return;
+      case "MultiLineString":
+        builder.beginMultiLineString(coordinates.length);
+        for (const line of coordinates) {
+          builder.beginLineString(line.length);
+          for (const point of line)
+            writePoint(builder, point, transform);
+        }
+        return;
+      case "Polygon":
+        builder.beginPolygon(coordinates.length);
+        for (const ring of coordinates) {
+          builder.beginLinearRing(ring.length);
+          for (const point of ring)
+            writePoint(builder, point, transform);
+        }
+        return;
+      case "MultiPolygon":
+        builder.beginMultiPolygon(coordinates.length);
+        for (const ring of coordinates) {
+          builder.beginPolygon(1);
+          builder.beginLinearRing(ring.length);
+          for (const point of ring)
+            writePoint(builder, point, transform);
+        }
+        return;
+      default:
+        return;
+    }
+  };
+}
+function writePoint(builder, point, transform) {
+  if (!point) {
+    builder.writeCoordinate(Number.NaN, Number.NaN);
+    return;
+  }
+  const [x, y] = transform([point.x, point.y]);
+  builder.writeCoordinate(x, y);
+}
+function geometryTypeToGeoJSONType(type) {
+  for (const [name, value] of Object.entries(GEOMETRY_TYPE)) {
+    if (value === type) {
+      const normalizedName = name.toLowerCase();
+      return normalizedName === "point" ? "Point" : normalizedName === "linestring" ? "LineString" : normalizedName === "polygon" ? "Polygon" : normalizedName === "multipoint" ? "MultiPoint" : normalizedName === "multilinestring" ? "MultiLineString" : normalizedName === "multipolygon" ? "MultiPolygon" : null;
+    }
+  }
+  return null;
+}
+function parseToGeojsonFeatures(arrayBuffer, options) {
+  if (arrayBuffer.byteLength <= 0) {
+    return [];
+  }
+  const tile = new Uint8Array(arrayBuffer);
+  const featureTables = getFeatureTables(decodeTile(tile));
+  const features = [];
+  const selectedLayers = options.layers && options.layers.length > 0 ? options.layers : featureTables.map((ft) => ft.name).filter(Boolean);
+  for (const featureTable of featureTables) {
+    const layerName = featureTable.name;
+    if (!layerName || !selectedLayers.includes(layerName)) {
+      continue;
+    }
+    const extent = featureTable.extent ?? 4096;
+    for (const mltFeature of getTableFeatures(featureTable)) {
+      const geoJSONFeature = convertFeatureToGeoJSON(mltFeature, options, layerName, extent);
+      if (geoJSONFeature) {
+        features.push(geoJSONFeature);
+      }
+    }
+  }
+  return features;
+}
+function getFeatureTables(decodedTile) {
+  if (Array.isArray(decodedTile)) {
+    return decodedTile.filter((candidate) => isFeatureTable(candidate));
+  }
+  if (!decodedTile || typeof decodedTile !== "object") {
+    return [];
+  }
+  return Object.values(decodedTile).filter((candidate) => isFeatureTable(candidate));
+}
+function isFeatureTable(candidate) {
+  if (!candidate || typeof candidate !== "object") {
+    return false;
+  }
+  return typeof candidate.name === "string" && (typeof candidate.getFeatures === "function" || Array.isArray(candidate.features) || typeof candidate[Symbol.iterator] === "function");
+}
+function getTableFeatures(featureTable) {
+  var _a;
+  if (typeof featureTable.getFeatures === "function") {
+    const features = featureTable.getFeatures();
+    if (Array.isArray(features)) {
+      return features;
+    }
+  }
+  if (Array.isArray(featureTable.features)) {
+    return featureTable.features;
+  }
+  if (typeof featureTable[Symbol.iterator] === "function") {
+    const iterableFeatures = (_a = featureTable[Symbol.iterator]) == null ? void 0 : _a.call(featureTable);
+    if (!iterableFeatures) {
+      return [];
+    }
+    return Array.isArray(iterableFeatures) ? iterableFeatures : Array.from(iterableFeatures);
+  }
+  return [];
+}
+function convertFeatureToGeoJSON(feature, options, layerName, extent) {
+  const { geometry, properties, id } = feature;
+  if (!geometry) {
+    return null;
+  }
+  const geojsonGeometry = convertGeometryToGeoJSON(geometry, options, extent);
+  if (!geojsonGeometry) {
+    return null;
+  }
+  const featureProperties = { ...properties };
+  if (options.layerProperty) {
+    featureProperties[options.layerProperty] = layerName;
+  }
+  const geojsonFeature = {
+    type: "Feature",
+    geometry: geojsonGeometry,
+    properties: featureProperties
+  };
+  if (id !== void 0 && id !== null) {
+    geojsonFeature.id = typeof id === "bigint" && id >= 0n && id <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(id) : id;
+  }
+  return geojsonFeature;
+}
+function convertGeometryToGeoJSON(geometry, options, extent) {
+  if (!geometry) {
+    return null;
+  }
+  const { type, coordinates } = geometry;
+  switch (type) {
+    case GEOMETRY_TYPE.POINT: {
+      const ring = coordinates == null ? void 0 : coordinates[0];
+      const point = ring == null ? void 0 : ring[0];
+      if (!point || typeof point.x !== "number" || typeof point.y !== "number") {
+        return null;
+      }
+      return {
+        type: "Point",
+        coordinates: projectPoint(point.x, point.y, options, extent)
+      };
+    }
+    case GEOMETRY_TYPE.MULTIPOINT: {
+      return {
+        type: "MultiPoint",
+        coordinates: coordinates.map(([p]) => projectPoint(p.x, p.y, options, extent))
+      };
+    }
+    case GEOMETRY_TYPE.LINESTRING: {
+      return {
+        type: "LineString",
+        coordinates: coordinates[0].map((p) => projectPoint(p.x, p.y, options, extent))
+      };
+    }
+    case GEOMETRY_TYPE.MULTILINESTRING: {
+      return {
+        type: "MultiLineString",
+        coordinates: coordinates.map((ring) => ring.map((p) => projectPoint(p.x, p.y, options, extent)))
+      };
+    }
+    case GEOMETRY_TYPE.POLYGON: {
+      return {
+        type: "Polygon",
+        coordinates: coordinates.map((ring) => ring.map((p) => projectPoint(p.x, p.y, options, extent)))
+      };
+    }
+    case GEOMETRY_TYPE.MULTIPOLYGON: {
+      return {
+        type: "MultiPolygon",
+        coordinates: coordinates.map((ring) => [
+          ring.map((p) => projectPoint(p.x, p.y, options, extent))
+        ])
+      };
+    }
+    default:
+      return null;
+  }
+}
+function projectPoint(x, y, options, extent) {
+  if (options.coordinates === "wgs84" && options.tileIndex) {
+    const { x: tx, y: ty, z } = options.tileIndex;
+    const size = extent * Math.pow(2, z);
+    const x0 = extent * tx;
+    const y0 = extent * ty;
+    const lng = (x + x0) * 360 / size - 180;
+    const y2 = 180 - (y + y0) * 360 / size;
+    const lat = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+    return [lng, lat];
+  }
+  return [x / extent, y / extent];
+}
+function checkOptions(options) {
+  var _a;
+  const mltOptions = {
+    ...MLT_DEFAULT_OPTIONS,
+    ...(options == null ? void 0 : options.mlt) ?? {},
+    geoarrow: ((_a = options == null ? void 0 : options.mlt) == null ? void 0 : _a.geoarrow) ?? (options == null ? void 0 : options.geoarrow)
+  };
+  if (mltOptions.coordinates === "wgs84" && !mltOptions.tileIndex) {
+    throw new Error("MLT Loader: WGS84 coordinates require a tileIndex option");
+  }
+  return mltOptions;
+}
+var arrow5, maplibreMLT, decodeTile, GEOMETRY_TYPE;
+var init_parse_mlt = __esm({
+  "dist/mlt/lib/parse-mlt.js"() {
+    "use strict";
+    arrow5 = __toESM(require("apache-arrow"), 1);
+    init_legacy_binary();
+    init_geometry_field();
+    init_wkb_arrow_utils();
+    init_src();
+    init_schema_utils();
+    maplibreMLT = __toESM(require("@maplibre/mlt"), 1);
+    init_mlt_loader();
+    decodeTile = (() => {
+      var _a;
+      const mltModule = maplibreMLT;
+      const decodedTile = mltModule.decodeTile ?? ((_a = mltModule.default) == null ? void 0 : _a.decodeTile);
+      if (!decodedTile) {
+        throw new Error("MLT Loader: decodeTile export missing from @maplibre/mlt");
+      }
+      return (tile) => decodedTile(tile, void 0, false);
+    })();
+    GEOMETRY_TYPE = (() => {
+      var _a;
+      const mltModule = maplibreMLT;
+      return mltModule.GEOMETRY_TYPE || ((_a = mltModule.default) == null ? void 0 : _a.GEOMETRY_TYPE) || {
+        POINT: 0,
+        LINESTRING: 1,
+        POLYGON: 2,
+        MULTIPOINT: 3,
+        MULTILINESTRING: 4,
+        MULTIPOLYGON: 5
+      };
+    })();
+  }
+});
+
+// dist/mlt/mlt-loader-with-parser.js
+var mlt_loader_with_parser_exports = {};
+__export(mlt_loader_with_parser_exports, {
+  MLTLoaderWithParser: () => MLTLoaderWithParser,
+  MLTWorkerLoaderWithParser: () => MLTWorkerLoaderWithParser,
+  MLT_DEFAULT_OPTIONS: () => MLT_DEFAULT_OPTIONS2
+});
+var _MLTWorkerLoaderPreload, MLTWorkerLoaderMetadataWithoutPreload, _MLTLoaderPreload, MLTLoaderMetadataWithoutPreload, MLT_DEFAULT_OPTIONS2, MLTWorkerLoaderWithParser, MLTLoaderWithParser;
+var init_mlt_loader_with_parser = __esm({
+  "dist/mlt/mlt-loader-with-parser.js"() {
+    "use strict";
+    init_parse_mlt();
+    init_mlt_loader();
+    init_mlt_loader();
+    ({ preload: _MLTWorkerLoaderPreload, ...MLTWorkerLoaderMetadataWithoutPreload } = MLTWorkerLoader);
+    ({ preload: _MLTLoaderPreload, ...MLTLoaderMetadataWithoutPreload } = MLTLoader);
+    MLT_DEFAULT_OPTIONS2 = {
+      shape: "arrow-table",
+      coordinates: "local",
+      layerProperty: "layerName"
+    };
+    MLTWorkerLoaderWithParser = {
+      ...MLTWorkerLoaderMetadataWithoutPreload
+    };
+    MLTLoaderWithParser = {
+      ...MLTLoaderMetadataWithoutPreload,
+      parse: async (arrayBuffer, options) => parseMLT(arrayBuffer, options),
+      parseSync: (arrayBuffer, options) => parseMLT(arrayBuffer, options)
+    };
+  }
+});
+
+// dist/mlt/mlt-loader.js
+async function preload() {
+  const { MLTLoaderWithParser: MLTLoaderWithParser2 } = await Promise.resolve().then(() => (init_mlt_loader_with_parser(), mlt_loader_with_parser_exports));
+  return MLTLoaderWithParser2;
+}
+var VERSION, MLT_DEFAULT_OPTIONS, MLTLoader, MLTWorkerLoader;
+var init_mlt_loader = __esm({
+  "dist/mlt/mlt-loader.js"() {
+    "use strict";
+    init_mlt_format();
+    VERSION = true ? "5.0.0-alpha.13" : "latest";
+    MLT_DEFAULT_OPTIONS = {
+      shape: "arrow-table",
+      coordinates: "local",
+      layerProperty: "layerName"
+    };
+    MLTLoader = {
+      ...MLTFormat,
+      dataType: null,
+      batchType: null,
+      version: VERSION,
+      worker: false,
+      binary: true,
+      options: {
+        mlt: {
+          ...MLT_DEFAULT_OPTIONS,
+          layers: void 0,
+          tileIndex: void 0
+        }
+      },
+      preload
+    };
+    MLTWorkerLoader = MLTLoader;
+  }
+});
+
+// dist/mlt/index.js
+var index_exports = {};
+__export(index_exports, {
+  MLTFormat: () => MLTFormat,
+  MLTLoader: () => MLTLoader,
+  MLTSourceLoader: () => MLTSourceLoader,
+  MLTWorkerLoader: () => MLTWorkerLoader,
+  MLTWriter: () => MLTWriter
+});
+module.exports = __toCommonJS(index_exports);
+init_mlt_format();
+init_mlt_loader();
+
+// ../core/src/loader-utils/lib/log-utils/log.ts
+var import_log = require("probe.gl/log");
+var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var version = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : "";
+function createLog() {
+  const log2 = new import_log.Log({ id: "loaders.gl" });
+  globalThis.loaders ||= {};
+  globalThis.loaders.log = log2;
+  globalThis.loaders.version = version;
+  globalThis.probe ||= {};
+  globalThis.probe.loaders = log2;
+  return log2;
+}
+var log = createLog();
+
+// ../core/src/loader-utils/lib/javascript-utils/is-type.ts
+var isObject = (value) => value !== null && typeof value === "object";
+var isPureObject = (value) => isObject(value) && value.constructor === {}.constructor;
+
+// ../core/src/loader-utils/lib/option-utils/merge-options.ts
+function mergeOptions(baseOptions, newOptions) {
+  return mergeOptionsRecursively(baseOptions || {}, newOptions);
+}
+function mergeOptionsRecursively(baseOptions, newOptions, level = 0) {
+  if (level > 3) {
+    return newOptions;
+  }
+  const options = { ...baseOptions };
+  for (const [key, newValue] of Object.entries(newOptions)) {
+    if (isPureObject(newValue)) {
+      options[key] = mergeOptionsRecursively(
+        options[key] || {},
+        newOptions[key],
+        level + 1
+      );
+    } else {
+      options[key] = newOptions[key];
+    }
+  }
+  return options;
+}
+
+// ../core/src/loader-utils/lib/request-utils/authentication.ts
+function resolveCredentials(credentials, authentications = []) {
+  if (credentials.every(isAuthentication)) return credentials;
+  return credentials.map((credential, index) => {
+    if (isAuthentication(credential)) return credential;
+    const AuthenticationClass = authentications.find(
+      (authentication2) => authentication2.type === (credential == null ? void 0 : credential.type)
+    );
+    if (!AuthenticationClass) {
+      throw new Error(`No authentication class registered for credential at index ${index}.`);
+    }
+    let authentication;
+    try {
+      authentication = new AuthenticationClass(credential);
+    } catch {
+      throw new Error(`Invalid authentication configuration at index ${index}.`);
+    }
+    if (!isAuthentication(authentication)) {
+      throw new Error(`Authentication class returned an invalid credential at index ${index}.`);
+    }
+    return authentication;
+  });
+}
+function resolveAuthenticationOptions(options) {
+  var _a, _b;
+  if (!((_b = (_a = options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length)) return options;
+  const credentials = resolveCredentials(options.core.credentials, options.core.authentications);
+  if (credentials === options.core.credentials) return options;
+  return { ...options, core: { ...options.core, credentials } };
+}
+function isAuthentication(credential) {
+  if (!credential || typeof credential !== "object") return false;
+  if (typeof credential.id !== "string" || !Array.isArray(credential.origins)) return false;
+  if (credential.type === "request") return typeof credential.authenticate === "function";
+  return (credential.type === "header" || credential.type === "query-parameter") && typeof credential.name === "string" && (typeof credential.token === "string" || typeof credential.token === "function") && Array.isArray(credential.refreshStatusCodes);
+}
+
+// ../core/src/loader-utils/lib/request-utils/request-credentials.ts
+var AUTHENTICATED_FETCH = /* @__PURE__ */ Symbol("loaders.gl.authenticated-fetch");
+var refreshPromises = /* @__PURE__ */ new WeakMap();
+function createAuthenticatedFetch(options) {
+  const suppliedFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
+  const existingMetadata = suppliedFetch[AUTHENTICATED_FETCH];
+  const credentialResolutions = new Map(existingMetadata == null ? void 0 : existingMetadata.credentialResolutions);
+  const resolvedCredentials = resolveCredentials(
+    options.credentials.map((credential) => credentialResolutions.get(credential) || credential),
+    options.authentications
+  );
+  options.credentials.forEach((credential, index) => {
+    credentialResolutions.set(credential, resolvedCredentials[index]);
+  });
+  if (!options.fetchOptions && (!resolvedCredentials.length || (existingMetadata == null ? void 0 : existingMetadata.credentials.length) === resolvedCredentials.length && resolvedCredentials.every(
+    (credential, index) => credential === existingMetadata.credentials[index]
+  )))
+    return suppliedFetch;
+  const baseFetch = (existingMetadata == null ? void 0 : existingMetadata.fetch) || suppliedFetch;
+  const credentials = existingMetadata ? [.../* @__PURE__ */ new Set([...resolvedCredentials, ...existingMetadata.credentials])] : resolvedCredentials;
+  const fetchOptions = mergeFetchOptions(
+    (existingMetadata == null ? void 0 : existingMetadata.fetchOptions) || {},
+    options.fetchOptions
+  );
+  const tokenCredentials = credentials.filter(
+    (credential) => credential.type !== "request"
+  );
+  const requestCredentials = credentials.filter(
+    (credential) => credential.type === "request"
+  );
+  for (const credential of requestCredentials) normalizeRequestOrigins(credential.origins);
+  const authenticatedFetch = async (url, requestOptions = {}) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    requestOptions = mergeFetchOptions(fetchOptions, requestOptions);
+    if ((_a = requestOptions.signal) == null ? void 0 : _a.aborted) throw createAbortError();
+    if (!credentials.length) return baseFetch(url, requestOptions);
+    const resolvedURL = parseHTTPURL(url);
+    const authorization = resolvedURL ? await authorizeRequest(resolvedURL, requestOptions, tokenCredentials) : { url, options: requestOptions, credentials: [] };
+    const signedRequest = await authenticateRequest(authorization, requestCredentials, "request");
+    const response = await baseFetch(signedRequest.url, signedRequest.options);
+    const refreshableCredentials = [];
+    for (const resolvedCredential of authorization.credentials) {
+      const { credential } = resolvedCredential;
+      if (typeof credential.token === "function" && (isReplayableRequest(requestOptions) || ((_b = credential.canReplayRequest) == null ? void 0 : _b.call(credential, url, requestOptions))) && (isReplayableRequest(signedRequest.options) || ((_c = credential.canReplayRequest) == null ? void 0 : _c.call(credential, signedRequest.url, signedRequest.options))) && (credential.refreshStatusCodes.includes(response.status) || await ((_d = credential.shouldRefresh) == null ? void 0 : _d.call(credential, response))))
+        refreshableCredentials.push(resolvedCredential);
+    }
+    const shouldRetrySignature = isReplayableRequest(requestOptions) && isReplayableRequest(signedRequest.options) && signedRequest.credentials.some(
+      (credential) => {
+        var _a2;
+        return (_a2 = credential.refreshStatusCodes) == null ? void 0 : _a2.includes(response.status);
+      }
+    );
+    if (!refreshableCredentials.length && !shouldRetrySignature) return response;
+    if ((_e = requestOptions.signal) == null ? void 0 : _e.aborted) throw createAbortError();
+    const refreshedTokens = /* @__PURE__ */ new Map();
+    await Promise.all(
+      refreshableCredentials.map(async ({ credential }) => {
+        const token = await refreshCredential(credential, url, response);
+        if (token) refreshedTokens.set(credential, token);
+      })
+    );
+    if (!refreshedTokens.size && !shouldRetrySignature) return response;
+    await ((_f = response.body) == null ? void 0 : _f.cancel().catch(() => {
+    }));
+    if ((_g = requestOptions.signal) == null ? void 0 : _g.aborted) throw createAbortError();
+    const replayAuthorization = resolvedURL ? await authorizeRequest(
+      resolvedURL,
+      requestOptions,
+      tokenCredentials,
+      refreshedTokens,
+      authorization.credentials
+    ) : { url, options: requestOptions };
+    const replayRequest = await authenticateRequest(
+      replayAuthorization,
+      requestCredentials,
+      "retry",
+      response
+    );
+    return baseFetch(replayRequest.url, replayRequest.options);
+  };
+  Object.defineProperty(authenticatedFetch, AUTHENTICATED_FETCH, {
+    value: {
+      fetch: baseFetch,
+      credentials,
+      credentialResolutions,
+      fetchOptions
+    }
+  });
+  return authenticatedFetch;
+}
+function getAuthenticatedFetch(options = {}) {
+  var _a, _b, _c;
+  const fetchOption = options.fetch ?? ((_a = options.core) == null ? void 0 : _a.fetch);
+  let fetchFunction;
+  if (typeof fetchOption === "function") {
+    fetchFunction = fetchOption;
+  } else {
+    fetchFunction = (url, requestOptions) => fetch(url, requestOptions);
+  }
+  return createAuthenticatedFetch({
+    fetch: fetchFunction,
+    fetchOptions: typeof fetchOption === "object" && fetchOption ? fetchOption : void 0,
+    credentials: ((_b = options.core) == null ? void 0 : _b.credentials) || [],
+    authentications: (_c = options.core) == null ? void 0 : _c.authentications
+  });
+}
+function mergeFetchOptions(defaultOptions, requestOptions) {
+  const mergedOptions = { ...defaultOptions, ...requestOptions };
+  if (defaultOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
+    const headers = new Headers(defaultOptions.headers);
+    new Headers(requestOptions == null ? void 0 : requestOptions.headers).forEach((value, key) => headers.set(key, value));
+    mergedOptions.headers = headers;
+  }
+  return mergedOptions;
+}
+async function authenticateRequest(request, credentials, reason, response) {
+  const appliedCredentials = [];
+  const signal = request.options.signal;
+  for (const credential of credentials) {
+    const origin = getRequestOrigin(request.url);
+    if (!origin || !normalizeRequestOrigins(credential.origins).includes(origin)) continue;
+    if (signal == null ? void 0 : signal.aborted) throw createAbortError();
+    const authenticatedRequest = await credential.authenticate({
+      url: request.url,
+      options: { ...request.options, headers: new Headers(request.options.headers) },
+      reason,
+      response: response ? { status: response.status, headers: new Headers(response.headers) } : void 0
+    });
+    if (!authenticatedRequest || typeof authenticatedRequest.url !== "string" || !authenticatedRequest.options || typeof authenticatedRequest.options !== "object") {
+      throw new Error("Authentication callback returned an invalid request.");
+    }
+    request = {
+      url: authenticatedRequest.url,
+      options: { ...authenticatedRequest.options, ...signal ? { signal } : {} }
+    };
+    appliedCredentials.push(credential);
+  }
+  if (signal == null ? void 0 : signal.aborted) throw createAbortError();
+  return { ...request, credentials: appliedCredentials };
+}
+function getRequestOrigin(url) {
+  try {
+    const parsedURL = new URL(url);
+    if (!parsedURL.host || parsedURL.username || parsedURL.password) return null;
+    return parsedURL.origin !== "null" ? parsedURL.origin : `${parsedURL.protocol}//${parsedURL.host}`;
+  } catch {
+    return null;
+  }
+}
+function normalizeRequestOrigins(origins) {
+  if (!origins.length)
+    throw new Error("Request authentication requires at least one exact origin.");
+  return origins.map((origin) => {
+    const resolvedOrigin = getRequestOrigin(origin);
+    let url;
+    try {
+      url = new URL(origin);
+    } catch {
+      throw new Error("Invalid request authentication origin.");
+    }
+    if (!resolvedOrigin || url.pathname && url.pathname !== "/" || url.search || url.hash) {
+      throw new Error("Invalid request authentication origin.");
+    }
+    return resolvedOrigin;
+  });
+}
+async function authorizeRequest(sourceURL, requestOptions, credentials, tokenOverrides = /* @__PURE__ */ new Map(), previousCredentials = []) {
+  const url = new URL(sourceURL);
+  const headers = new Headers(requestOptions.headers);
+  const resolvedCredentials = [];
+  const previousTokens = new Map(
+    previousCredentials.map(({ credential, token }) => [credential, token])
+  );
+  for (const credential of credentials) {
+    if (!credential.origins.includes(url.origin)) continue;
+    const overrideToken = tokenOverrides.get(credential);
+    const previousToken = previousTokens.get(credential);
+    const ownsQueryParameter = credential.type === "query-parameter" && previousToken !== void 0;
+    const ownsHeader = credential.type === "header" && previousToken !== void 0;
+    if (credential.type === "query-parameter" && url.searchParams.has(credential.name) && !ownsQueryParameter || credential.type === "header" && headers.has(credential.name) && !ownsHeader) {
+      continue;
+    }
+    const token = overrideToken ?? previousToken ?? await resolveToken(credential.token, { url: sourceURL.toString(), reason: "request" });
+    if (!token) continue;
+    if (credential.type === "query-parameter") {
+      url.searchParams.set(credential.name, token);
+    } else {
+      headers.set(credential.name, `${credential.prefix || ""}${token}`);
+    }
+    resolvedCredentials.push({ credential, token });
+  }
+  return {
+    url: url.toString(),
+    options: { ...requestOptions, headers },
+    credentials: resolvedCredentials
+  };
+}
+async function refreshCredential(credential, url, response) {
+  const existingPromise = refreshPromises.get(credential);
+  if (existingPromise) return existingPromise;
+  const tokenProvider = credential.token;
+  const promise = Promise.resolve(
+    tokenProvider({
+      url,
+      reason: "refresh",
+      response: { status: response.status, headers: response.headers }
+    })
+  ).finally(() => refreshPromises.delete(credential));
+  refreshPromises.set(credential, promise);
+  return promise;
+}
+async function resolveToken(token, context) {
+  return typeof token === "function" ? token(context) : token;
+}
+function parseHTTPURL(url) {
+  try {
+    const parsedURL = new URL(url);
+    return ["http:", "https:"].includes(parsedURL.protocol) ? parsedURL : null;
+  } catch {
+    return null;
+  }
+}
+function isReplayableRequest(options) {
+  const method = (options.method || "GET").toUpperCase();
+  if (!["GET", "HEAD", "OPTIONS", "PUT", "DELETE"].includes(method)) return false;
+  return !(options.body && typeof ReadableStream !== "undefined" && options.body instanceof ReadableStream);
+}
+function createAbortError() {
+  return new DOMException("The operation was aborted.", "AbortError");
+}
+
+// ../core/src/loader-utils/lib/path-utils/file-aliases.ts
+var pathPrefix = "";
+var fileAliases = {};
+function resolvePath(filename) {
+  for (const alias in fileAliases) {
+    if (filename.startsWith(alias)) {
+      const replacement = fileAliases[alias];
+      filename = filename.replace(alias, replacement);
+    }
+  }
+  if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
+    filename = `${pathPrefix}${filename}`;
+  }
+  return filename;
+}
+
+// ../core/src/loader-utils/lib/sources/data-source.ts
+var UNAVAILABLE_CORE_API = {
+  fetchFile: unavailableCoreApiMethod("fetchFile"),
+  parse: unavailableCoreApiMethod("parse"),
+  parseFile: unavailableCoreApiMethod("parseFile"),
+  parseSync: unavailableCoreApiMethod("parseSync"),
+  parseInBatches: unavailableCoreApiMethod("parseInBatches"),
+  load: unavailableCoreApiMethod("load"),
+  loadInBatches: unavailableCoreApiMethod("loadInBatches")
+};
+var DataSource = class _DataSource {
+  static defaultOptions = {
+    core: {
+      type: "auto",
+      attributions: [],
+      loaders: [],
+      onError: void 0
+    }
+  };
+  optionsType;
+  options;
+  data;
+  url;
+  /** Shared parser options derived from the source options, excluding source-only core controls. */
+  loadOptions;
+  /** A resolved fetch function extracted from the shared core options. */
+  fetch;
+  /** Shared source-level runtime hooks, when supplied by the source factory. */
+  coreApi;
+  /** Whether a real CoreAPI instance was injected by the integration layer. */
+  hasCoreApi;
+  _needsRefresh = true;
+  constructor(data, options, defaultOptions, coreApi) {
+    this.options = mergeOptions(
+      mergeOptions(_DataSource.defaultOptions, defaultOptions || {}),
+      options
+    );
+    this.data = data;
+    this.url = typeof data === "string" ? resolvePath(data) : "";
+    const loadOptions = resolveAuthenticationOptions(getSourceLoaderOptions(this.options));
+    this.loadOptions = loadOptions;
+    const fetch2 = getFetchFunction(loadOptions);
+    this.coreApi = coreApi || UNAVAILABLE_CORE_API;
+    this.hasCoreApi = Boolean(coreApi);
+    this.fetch = fetch2;
+  }
+  setProps(options) {
+    const mergedOptions = mergeOptions(this.options, options);
+    const loadOptions = resolveAuthenticationOptions(getSourceLoaderOptions(mergedOptions));
+    this.options = mergedOptions;
+    this.loadOptions = loadOptions;
+    this.fetch = getFetchFunction(loadOptions);
+    this.setNeedsRefresh();
+  }
+  /** Mark this data source as needing a refresh (redraw) */
+  setNeedsRefresh() {
+    this._needsRefresh = true;
+  }
+  /**
+   * Does this data source need refreshing?
+   * @note The specifics of the refresh mechanism depends on type of data source
+   */
+  getNeedsRefresh(clear = true) {
+    const needsRefresh = this._needsRefresh;
+    if (clear) {
+      this._needsRefresh = false;
+    }
+    return needsRefresh;
+  }
+  /** Reports a source-level failure through the configured callback or the shared logger. */
+  reportError(error, message) {
+    var _a;
+    const normalizedError = normalizeError(error, message);
+    const callback = (_a = this.options.core) == null ? void 0 : _a.onError;
+    if (callback) {
+      callback(normalizedError, this);
+    } else {
+      log.warn(`${this.constructor.name}: ${normalizedError.message}`)();
+    }
+    return normalizedError;
+  }
+};
+function getFetchFunction(options) {
+  return getAuthenticatedFetch(options);
+}
+function getSourceLoaderOptions(options) {
+  var _a;
+  if (options.loadOptions !== void 0 || ((_a = options.core) == null ? void 0 : _a.loadOptions) !== void 0) {
+    throw new Error(
+      "Source loadOptions and core.loadOptions were removed. Use core and root loader namespaces directly."
+    );
+  }
+  const loadOptions = { ...options };
+  if (options == null ? void 0 : options.core) {
+    loadOptions.core = { ...options.core };
+    const parserCore = loadOptions.core;
+    for (const key of ["type", "attributions", "loaders", "onError", "loadOptions"]) {
+      delete parserCore[key];
+    }
+    if (Object.keys(parserCore).length === 0) {
+      delete loadOptions.core;
+    }
+  }
+  const topLevelBaseUri = typeof loadOptions.baseUri === "string" ? loadOptions.baseUri : void 0;
+  const topLevelBaseUrl = typeof loadOptions.baseUrl === "string" ? loadOptions.baseUrl : void 0;
+  if (topLevelBaseUri !== void 0 || topLevelBaseUrl !== void 0) {
+    loadOptions.core ||= {};
+    if (loadOptions.core.baseUrl === void 0) {
+      loadOptions.core.baseUrl = topLevelBaseUrl ?? topLevelBaseUri;
+    }
+    delete loadOptions.baseUri;
+    delete loadOptions.baseUrl;
+  }
+  return loadOptions;
+}
+function normalizeError(error, message) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  return new Error(message);
+}
+function unavailableCoreApiMethod(methodName) {
+  return () => {
+    throw new Error(
+      `CoreAPI.${methodName} is unavailable. Use @loaders.gl/core.createDataSource().`
+    );
+  };
+}
+
+// dist/mlt/mlt-source-loader.js
+init_mlt_format();
+var MLTSourceLoader = {
+  dataType: null,
+  batchType: null,
+  ...MLTFormat,
+  name: "MLTTileSource",
+  version: "0.0.0",
+  type: "mlt",
+  fromUrl: true,
+  fromBlob: false,
+  options: {
+    mlt: {
+      extension: ".mlt",
+      metadataUrl: null,
+      coordinates: "wgs84",
+      shape: "arrow-table",
+      layers: void 0
+    }
+  },
+  defaultOptions: {
+    mlt: {
+      extension: ".mlt",
+      metadataUrl: null,
+      coordinates: "wgs84",
+      shape: "arrow-table",
+      layers: void 0
+    }
+  },
+  testURL: (url) => url.endsWith(".mlt") || url.endsWith("/plain") || isURLTemplate(url),
+  createDataSource: (url, options, coreApi) => new MLTTileSource(url, options, coreApi)
+};
+var MLTTileSource = class extends DataSource {
+  metadataUrl;
+  schema = "tms";
+  metadata;
+  extension;
+  mimeType = "application/vnd.maplibre-tile";
+  constructor(url, options, coreApi) {
+    var _a, _b;
+    super(url, options, MLTSourceLoader.defaultOptions, coreApi);
+    this.metadataUrl = ((_a = this.options.mlt) == null ? void 0 : _a.metadataUrl) || null;
+    this.extension = ((_b = this.options.mlt) == null ? void 0 : _b.extension) || ".mlt";
+    this.getTileData = this.getTileData.bind(this);
+    this.metadata = this.getMetadata();
+    if (isURLTemplate(this.url)) {
+      this.schema = "template";
+    }
+  }
+  async getSchema() {
+    return { fields: [], metadata: {} };
+  }
+  async getMetadata() {
+    var _a;
+    const attributions = ((_a = this.options.core) == null ? void 0 : _a.attributions) || [];
+    if (!this.metadataUrl) {
+      return { minZoom: 0, maxZoom: 30, attributions };
+    }
+    try {
+      const response = await this.fetch(this.metadataUrl);
+      if (!response.ok) {
+        this.reportError(new Error(`${response.status} ${response.statusText}`), `Failed to fetch metadata from ${this.metadataUrl}`);
+        return { minZoom: 0, maxZoom: 30, attributions };
+      }
+      const metadataText = await response.text();
+      const metadataJson = JSON.parse(metadataText);
+      const minZoom = Number.isFinite(metadataJson == null ? void 0 : metadataJson.minZoom) ? metadataJson.minZoom : Number.isFinite(metadataJson == null ? void 0 : metadataJson.minzoom) ? metadataJson.minzoom : 0;
+      const maxZoom = Number.isFinite(metadataJson == null ? void 0 : metadataJson.maxZoom) ? metadataJson.maxZoom : Number.isFinite(metadataJson == null ? void 0 : metadataJson.maxzoom) ? metadataJson.maxzoom : 30;
+      return {
+        ...metadataJson,
+        minZoom,
+        maxZoom,
+        attributions: [...attributions, ...(metadataJson == null ? void 0 : metadataJson.attributions) || []]
+      };
+    } catch (error) {
+      this.reportError(error, `Failed to fetch metadata from ${this.metadataUrl}`);
+      return { minZoom: 0, maxZoom: 30, attributions };
+    }
+  }
+  async getTile(parameters) {
+    const tileUrl = this.getTileURL(parameters.x, parameters.y, parameters.z);
+    const response = await this.fetch(tileUrl);
+    if (!response.ok) {
+      this.reportError(new Error(`${response.status} ${response.statusText}`), `Failed to fetch tile ${tileUrl} ${JSON.stringify(parameters)}`);
+      return null;
+    }
+    return response.arrayBuffer();
+  }
+  async getTileData(parameters) {
+    const { index } = parameters;
+    return this.getVectorTile({ x: index.x, y: index.y, z: index.z, layers: [] });
+  }
+  async getVectorTile(tileParameters) {
+    const tileData = await this.getTile(tileParameters);
+    return tileData ? this._parseTile(tileData, tileParameters) : null;
+  }
+  async _parseTile(arrayBuffer, tileParameters) {
+    var _a, _b, _c;
+    const options = this.options;
+    const coordinates = ((_a = options.mlt) == null ? void 0 : _a.coordinates) || "wgs84";
+    const shape = ((_b = options.mlt) == null ? void 0 : _b.shape) || "arrow-table";
+    const tileIndex = coordinates === "wgs84" ? { x: tileParameters.x, y: tileParameters.y, z: tileParameters.z } : void 0;
+    const loadOptions = {
+      ...this.loadOptions,
+      mlt: {
+        ...this.loadOptions.mlt,
+        shape,
+        coordinates,
+        layers: (_c = options.mlt) == null ? void 0 : _c.layers,
+        tileIndex
+      },
+      geoarrow: options.geoarrow ?? this.loadOptions.geoarrow
+    };
+    const { MLTLoaderWithParser: MLTLoaderWithParser2 } = await Promise.resolve().then(() => (init_mlt_loader_with_parser(), mlt_loader_with_parser_exports));
+    const parsed = await MLTLoaderWithParser2.parse(arrayBuffer, loadOptions);
+    if (shape === "geojson-table") {
+      return parsed.features || null;
+    }
+    if (shape === "binary-geometry" || shape === "arrow-table") {
+      return parsed;
+    }
+    return parsed.features || null;
+  }
+  getTileURL(x, y, z) {
+    switch (this.schema) {
+      case "xyz":
+        return `${this.url}/${x}/${y}/${z}${this.extension}`;
+      case "tms":
+        return `${this.url}/${z}/${x}/${y}${this.extension}`;
+      case "template":
+        return getURLFromTemplate(this.url, x, y, z, this.extension);
+      default:
+        throw new Error(`Unknown tile schema: ${this.schema}`);
+    }
+  }
+};
+function isURLTemplate(s) {
+  return /(?=.*\{z\})(?=.*\{x\})(?=.*(\{y\}|\{\-y\}))|(?=.*\{x\})(?=.*(\{y\}|\{\-y\})(?=.*\{z\}))/i.test(s);
+}
+function getURLFromTemplate(template, x, y, z, extension = "") {
+  const id = `${x}-${y}-${z}`;
+  const url = template.replace(/\{x\}/g, x.toString()).replace(/\{-y\}/g, String((1 << z) - 1 - y)).replace(/\{y\}/g, y.toString()).replace(/\{z\}/g, z.toString()).replace(/\{id\}/g, id);
+  if (!extension || url.endsWith(extension)) {
+    return url;
+  }
+  const separatorIndex = url.search(/[?#]/);
+  const path = separatorIndex < 0 ? url : url.slice(0, separatorIndex);
+  const suffix = separatorIndex < 0 ? "" : url.slice(separatorIndex);
+  const file = path.split("/").pop() || "";
+  if (/\.[a-z0-9]+$/i.test(file)) {
+    return url;
+  }
+  return `${path}${extension}${suffix}`;
+}
+
+// dist/mlt/index.js
+init_mlt_loader();
+
+// dist/mlt/lib/encode-mlt.js
+var arrow6 = __toESM(require("apache-arrow"), 1);
+init_schema();
+init_geometry_codecs();
+
+// dist/mlt/lib/encode-mlt-streams.js
+function concatenateBytes(chunks) {
+  const result = new Uint8Array(chunks.reduce((length, chunk) => length + chunk.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+function encodeVarints(values) {
+  const bytes = [];
+  for (let value of values) {
+    do {
+      const remainder = value % 128;
+      value = Math.floor(value / 128);
+      bytes.push(remainder + (value ? 128 : 0));
+    } while (value);
+  }
+  return Uint8Array.from(bytes);
+}
+function encodeString(value) {
+  const bytes = new TextEncoder().encode(value);
+  return concatenateBytes([encodeVarints([bytes.length]), bytes]);
+}
+function encodeStream(type, encoding, count, bytes) {
+  return concatenateBytes([
+    Uint8Array.of(type, encoding),
+    encodeVarints([count, bytes.length]),
+    bytes
+  ]);
+}
+function encodeIntegerStream(type, values) {
+  return encodeStream(type, 2, values.length, encodeVarints(values));
+}
+function encodeBooleanStream(type, values) {
+  const packed = new Uint8Array(Math.ceil(values.length / 8));
+  for (let index = 0; index < values.length; index++)
+    if (values[index])
+      packed[index >> 3] |= 1 << index % 8;
+  const chunks = [];
+  for (let offset = 0; offset < packed.length; offset += 128) {
+    const chunk = packed.subarray(offset, offset + 128);
+    chunks.push(Uint8Array.of(256 - chunk.length), chunk);
+  }
+  return encodeStream(type, 96, values.length, concatenateBytes(chunks));
+}
+
+// dist/mlt/lib/encode-mlt-geometry.js
+function quantizeGeometry(geometry, scale) {
+  function projectPoint2(point) {
+    if (point.length !== 2 || !point.every(Number.isFinite))
+      throw new Error("MLT requires finite XY coordinates");
+    const result = point.map((value) => Math.round(value * scale));
+    if (result.some((value) => Math.abs(value) > 1073741823))
+      throw new Error("MLT quantized coordinate limit exceeded");
+    return result;
+  }
+  function projectLine(line) {
+    return line.map(projectPoint2).filter((point, index, points) => !index || point[0] !== points[index - 1][0] || point[1] !== points[index - 1][1]);
+  }
+  function projectPolygon(polygon) {
+    const rings = [];
+    for (let index = 0; index < polygon.length; index++) {
+      const ring = projectLine(polygon[index]);
+      if (ring.length && ring[0][0] === ring[ring.length - 1][0] && ring[0][1] === ring[ring.length - 1][1])
+        ring.pop();
+      let area = 0;
+      for (let vertex = 1; vertex + 1 < ring.length; vertex++)
+        area += (ring[vertex][0] - ring[0][0]) * (ring[vertex + 1][1] - ring[0][1]) - (ring[vertex + 1][0] - ring[0][0]) * (ring[vertex][1] - ring[0][1]);
+      if (ring.length < 3 || !area) {
+        if (!index)
+          return [];
+        continue;
+      }
+      rings.push(ring);
+    }
+    return rings;
+  }
+  switch (geometry.type) {
+    case "Point":
+      return geometry.coordinates.length ? { type: "Point", coordinates: projectPoint2(geometry.coordinates) } : null;
+    case "MultiPoint":
+      return geometry.coordinates.length ? { type: "MultiPoint", coordinates: geometry.coordinates.map(projectPoint2) } : null;
+    case "LineString": {
+      const coordinates = projectLine(geometry.coordinates);
+      return coordinates.length > 1 ? { type: "LineString", coordinates } : null;
+    }
+    case "MultiLineString": {
+      const coordinates = geometry.coordinates.map(projectLine).filter((line) => line.length > 1);
+      return coordinates.length ? { type: "MultiLineString", coordinates } : null;
+    }
+    case "Polygon": {
+      const coordinates = projectPolygon(geometry.coordinates);
+      return coordinates.length ? { type: "Polygon", coordinates } : null;
+    }
+    case "MultiPolygon": {
+      const coordinates = geometry.coordinates.map(projectPolygon).filter((polygon) => polygon.length);
+      return coordinates.length ? { type: "MultiPolygon", coordinates } : null;
+    }
+    default:
+      throw new Error(`Unsupported MLT geometry: ${geometry.type}`);
+  }
+}
+function encodeGeometryColumn(geometries) {
+  const types = [];
+  const geometryLengths = [];
+  const partLengths = [];
+  const ringLengths = [];
+  const vertices = [];
+  const hasPolygons = geometries.some((geometry) => geometry.type.includes("Polygon"));
+  let previousX = 0;
+  let previousY = 0;
+  function writePoints(points) {
+    for (const [x, y] of points) {
+      const deltaX = x - previousX;
+      const deltaY = y - previousY;
+      vertices.push(deltaX < 0 ? -2 * deltaX - 1 : 2 * deltaX, deltaY < 0 ? -2 * deltaY - 1 : 2 * deltaY);
+      previousX = x;
+      previousY = y;
+    }
+  }
+  function writeLine(line) {
+    (hasPolygons ? ringLengths : partLengths).push(line.length);
+    writePoints(line);
+  }
+  function writePolygon(polygon) {
+    partLengths.push(polygon.length);
+    for (const ring of polygon) {
+      ringLengths.push(ring.length);
+      writePoints(ring);
+    }
+  }
+  for (const geometry of geometries) {
+    switch (geometry.type) {
+      case "Point":
+        types.push(0);
+        writePoints([geometry.coordinates]);
+        break;
+      case "LineString":
+        types.push(1);
+        writeLine(geometry.coordinates);
+        break;
+      case "Polygon":
+        types.push(2);
+        writePolygon(geometry.coordinates);
+        break;
+      case "MultiPoint":
+        types.push(3);
+        geometryLengths.push(geometry.coordinates.length);
+        writePoints(geometry.coordinates);
+        break;
+      case "MultiLineString":
+        types.push(4);
+        geometryLengths.push(geometry.coordinates.length);
+        geometry.coordinates.forEach(writeLine);
+        break;
+      case "MultiPolygon":
+        types.push(5);
+        geometryLengths.push(geometry.coordinates.length);
+        geometry.coordinates.forEach(writePolygon);
+        break;
+    }
+  }
+  const streams = [encodeIntegerStream(16, types)];
+  if (geometryLengths.length)
+    streams.push(encodeIntegerStream(49, geometryLengths));
+  if (partLengths.length)
+    streams.push(encodeIntegerStream(50, partLengths));
+  if (ringLengths.length)
+    streams.push(encodeIntegerStream(51, ringLengths));
+  streams.push(encodeStream(19, 66, vertices.length, encodeVarints(vertices)));
+  return concatenateBytes([encodeVarints([streams.length]), ...streams]);
+}
+
+// dist/mlt/lib/encode-mlt.js
+function encodeMLT(input, options = {}) {
+  const table = input instanceof arrow6.Table ? input : input.data;
+  const configuration = options.mlt ?? {};
+  const extent = configuration.extent ?? 4096;
+  const coordinates = configuration.coordinates ?? "local";
+  const layerName = configuration.layerName ?? "features";
+  const maximum = configuration.maxFeatures ?? 1e5;
+  if (!Number.isInteger(extent) || extent < 1 || extent > 65536)
+    throw new Error("Invalid MLT extent");
+  if (!["local", "tile"].includes(coordinates))
+    throw new Error("Invalid MLT coordinates");
+  if (!layerName)
+    throw new Error("MLT layerName must be nonempty");
+  if (!Number.isSafeInteger(maximum) || maximum < 1 || table.numRows > maximum)
+    throw new Error("MLT feature limit exceeded or invalid");
+  const geoMetadata = getGeoMetadata(table.schema.metadata);
+  const geometryName = configuration.geometryColumn ?? (geoMetadata == null ? void 0 : geoMetadata.primary_column);
+  const candidates = table.schema.fields.filter((field) => geometryName ? field.name === geometryName : field.metadata.get("ARROW:extension:name") === "geoarrow.wkb");
+  if (candidates.length !== 1)
+    throw new Error("Select one GeoArrow WKB column with mlt.geometryColumn");
+  const geometryField = candidates[0];
+  const columnMetadata = geoMetadata == null ? void 0 : geoMetadata.columns[geometryField.name];
+  if (geometryField.metadata.get("ARROW:extension:name") !== "geoarrow.wkb" && (columnMetadata == null ? void 0 : columnMetadata.encoding) !== "wkb")
+    throw new Error("MLT requires GeoArrow WKB; tile native input with the Arrow tiler first");
+  const extensionMetadata = JSON.parse(geometryField.metadata.get("ARROW:extension:metadata") || "{}");
+  const coordinateSystem = extensionMetadata.crs ?? (columnMetadata == null ? void 0 : columnMetadata.crs) ?? (columnMetadata && !Object.hasOwn(columnMetadata, "crs") ? "OGC:CRS84" : null);
+  if (coordinateSystem != null)
+    throw new Error("MLT requires tile-local geometry; use the Arrow tiler for geographic input");
+  const geometryColumn = table.getChild(geometryField.name);
+  const propertyNames = configuration.propertyColumns ?? table.schema.fields.filter((field) => {
+    var _a;
+    return field.name !== geometryField.name && !((_a = field.metadata.get("ARROW:extension:name")) == null ? void 0 : _a.startsWith("geoarrow.")) && !(geoMetadata == null ? void 0 : geoMetadata.columns[field.name]);
+  }).map((field) => field.name);
+  if (new Set(propertyNames).size !== propertyNames.length)
+    throw new Error("Duplicate MLT property column");
+  const properties = propertyNames.map((name) => {
+    const column = table.getChild(name);
+    if (!column || name === geometryField.name)
+      throw new Error(`Unknown MLT property column: ${name}`);
+    return { name, column, type: getColumnType(column.type) };
+  });
+  const identifier = configuration.idColumn ? table.getChild(configuration.idColumn) : null;
+  if (configuration.idColumn && !identifier)
+    throw new Error("Unknown MLT idColumn");
+  const rows = [];
+  const geometries = [];
+  const identifiers = [];
+  for (let row = 0; row < table.numRows; row++) {
+    if (!geometryColumn.isValid(row))
+      continue;
+    const geometry = quantizeGeometry(convertWKBToGeometry(geometryColumn.get(row)), coordinates === "local" ? extent : 1);
+    if (!geometry)
+      continue;
+    const value = identifier == null ? void 0 : identifier.get(row);
+    const numericId = value == null ? null : getScalar(value);
+    if (numericId !== null && (typeof numericId !== "number" || !Number.isSafeInteger(numericId) || numericId < 0))
+      throw new Error("MLT feature IDs must be nonnegative safe integers");
+    rows.push(row);
+    geometries.push(geometry);
+    identifiers.push(numericId);
+  }
+  if (!rows.length)
+    return new ArrayBuffer(0);
+  const metadata = [];
+  const columns = [];
+  if (identifier) {
+    const nullable = identifiers.some((value) => value === null);
+    const longId = identifiers.some((value) => value !== null && value > 4294967295);
+    metadata.push(Uint8Array.of((longId ? 2 : 0) + Number(nullable)));
+    columns.push(concatenateBytes([
+      ...nullable ? [
+        encodeBooleanStream(0, identifiers.map((value) => value !== null))
+      ] : [],
+      encodeIntegerStream(16, identifiers.filter((value) => value !== null))
+    ]));
+  }
+  metadata.push(Uint8Array.of(4));
+  columns.push(encodeGeometryColumn(geometries));
+  for (const { name, column, type } of properties) {
+    const values = rows.map((row) => column.get(row)).map((value) => value == null ? null : getScalar(value));
+    const nullable = values.some((value) => value === null);
+    const present = values.filter((value) => value !== null);
+    const streams = nullable ? [
+      encodeBooleanStream(0, values.map((value) => value !== null))
+    ] : [];
+    metadata.push(concatenateBytes([Uint8Array.of(type + Number(nullable)), encodeString(name)]));
+    switch (type) {
+      case 10:
+        streams.push(encodeBooleanStream(16, present));
+        break;
+      case 28: {
+        const strings = present.map((value) => new TextEncoder().encode(value));
+        streams.push(encodeIntegerStream(48, strings.map((value) => value.length)));
+        const bytes = concatenateBytes(strings);
+        streams.push(encodeStream(16, 0, bytes.length, bytes));
+        break;
+      }
+      default: {
+        const bytes = new Uint8Array(present.length * 8);
+        const view = new DataView(bytes.buffer);
+        for (let index = 0; index < present.length; index++)
+          view.setFloat64(index * 8, present[index], true);
+        streams.push(encodeStream(16, 0, present.length, bytes));
+      }
+    }
+    columns.push(concatenateBytes([...type === 28 ? [encodeVarints([streams.length])] : [], ...streams]));
+  }
+  const body = concatenateBytes([
+    Uint8Array.of(1),
+    encodeString(layerName),
+    encodeVarints([extent, metadata.length]),
+    ...metadata,
+    ...columns
+  ]);
+  return concatenateBytes([encodeVarints([body.length]), body]).buffer;
+}
+function getColumnType(type) {
+  if (arrow6.DataType.isDictionary(type))
+    return getColumnType(type.dictionary);
+  switch (type.typeId) {
+    case arrow6.Type.Bool:
+      return 10;
+    case arrow6.Type.Utf8:
+      return 28;
+    case arrow6.Type.Null:
+    case arrow6.Type.Int:
+    case arrow6.Type.Float:
+      return 26;
+    default:
+      throw new Error("Unsupported MLT attribute type; select scalar mlt.propertyColumns");
+  }
+}
+function getScalar(value) {
+  if (typeof value === "bigint") {
+    if (value < BigInt(Number.MIN_SAFE_INTEGER) || value > BigInt(Number.MAX_SAFE_INTEGER))
+      throw new Error("MLT integer exceeds the supported safe integer range");
+    return Number(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || Number.isInteger(value) && !Number.isSafeInteger(value))
+      throw new Error("Invalid or unsafe MLT number");
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "boolean")
+    return value;
+  throw new Error("Unsupported MLT scalar value");
+}
+
+// dist/mlt/mlt-writer.js
+init_mlt_format();
+var VERSION3 = true ? "5.0.0-alpha.13" : "latest";
+var MLTWriter = {
+  ...MLTFormat,
+  name: "MLT Writer",
+  version: VERSION3,
+  binary: true,
+  options: { mlt: {} },
+  /** Encodes a materialized tile asynchronously for the core writer API. */
+  encode: async (data, options) => encodeMLT(data, options),
+  /** Encodes one tile synchronously. */
+  encodeSync: encodeMLT
+};
+//# sourceMappingURL=index.cjs.map