@loaders.gl/gis 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/index.cjs

@@ -0,0 +1,708 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  binaryToGeojson: () => binaryToGeojson,
+  binaryToGeometry: () => binaryToGeometry,
+  flatGeojsonToBinary: () => flatGeojsonToBinary,
+  geojsonToBinary: () => geojsonToBinary,
+  geojsonToFlatGeojson: () => geojsonToFlatGeojson,
+  transformBinaryCoords: () => transformBinaryCoords,
+  transformGeoJsonCoords: () => transformGeoJsonCoords
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/lib/flat-geojson-to-binary.ts
+var import_polygon = require("@math.gl/polygon");
+function flatGeojsonToBinary(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_polygon.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 = {
+    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;
+}
+
+// src/lib/extract-geometry-info.ts
+function extractGeometryInfo(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
+  };
+}
+
+// src/lib/geojson-to-flat-geojson.ts
+var import_polygon2 = require("@math.gl/polygon");
+function geojsonToFlatGeojson(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_polygon2.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 } };
+}
+
+// src/lib/geojson-to-binary.ts
+function geojsonToBinary(features, options = { fixRingWinding: true, triangulate: true }) {
+  const geometryInfo = extractGeometryInfo(features);
+  const coordLength = geometryInfo.coordLength;
+  const { fixRingWinding } = options;
+  const flatFeatures = geojsonToFlatGeojson(features, { coordLength, fixRingWinding });
+  return flatGeojsonToBinary(flatFeatures, geometryInfo, {
+    numericPropKeys: options.numericPropKeys,
+    PositionDataType: options.PositionDataType || Float32Array,
+    triangulate: options.triangulate
+  });
+}
+
+// src/lib/binary-to-geojson.ts
+function binaryToGeojson(data, options) {
+  const globalFeatureId = options == null ? void 0 : options.globalFeatureId;
+  if (globalFeatureId !== void 0) {
+    return getSingleFeature(data, globalFeatureId);
+  }
+  return parseFeatures(data, options == null ? void 0 : options.type);
+}
+function getSingleFeature(data, globalFeatureId) {
+  const dataArray = normalizeInput(data);
+  for (const data2 of dataArray) {
+    let lastIndex = 0;
+    let lastValue = data2.featureIds.value[0];
+    for (let i = 0; i < data2.featureIds.value.length; i++) {
+      const currValue = data2.featureIds.value[i];
+      if (currValue === lastValue) {
+        continue;
+      }
+      if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
+        return parseFeature(data2, lastIndex, i);
+      }
+      lastIndex = i;
+      lastValue = currValue;
+    }
+    if (globalFeatureId === data2.globalFeatureIds.value[lastIndex]) {
+      return parseFeature(data2, lastIndex, data2.featureIds.value.length);
+    }
+  }
+  throw new Error(`featureId:${globalFeatureId} not found`);
+}
+function parseFeatures(data, type) {
+  const dataArray = normalizeInput(data, type);
+  return parseFeatureCollection(dataArray);
+}
+function binaryToGeometry(data, startIndex, endIndex) {
+  switch (data.type) {
+    case "Point":
+      return pointToGeoJson(data, startIndex, endIndex);
+    case "LineString":
+      return lineStringToGeoJson(data, startIndex, endIndex);
+    case "Polygon":
+      return polygonToGeoJson(data, startIndex, endIndex);
+    default:
+      const unexpectedInput = data;
+      throw new Error(`Unsupported geometry type: ${unexpectedInput == null ? void 0 : unexpectedInput.type}`);
+  }
+}
+function normalizeInput(data, type) {
+  const features = [];
+  if (data.points) {
+    data.points.type = "Point";
+    features.push(data.points);
+  }
+  if (data.lines) {
+    data.lines.type = "LineString";
+    features.push(data.lines);
+  }
+  if (data.polygons) {
+    data.polygons.type = "Polygon";
+    features.push(data.polygons);
+  }
+  return features;
+}
+function parseFeatureCollection(dataArray) {
+  const features = [];
+  for (const data of dataArray) {
+    if (data.featureIds.value.length === 0) {
+      continue;
+    }
+    let lastIndex = 0;
+    let lastValue = data.featureIds.value[0];
+    for (let i = 0; i < data.featureIds.value.length; i++) {
+      const currValue = data.featureIds.value[i];
+      if (currValue === lastValue) {
+        continue;
+      }
+      features.push(parseFeature(data, lastIndex, i));
+      lastIndex = i;
+      lastValue = currValue;
+    }
+    features.push(parseFeature(data, lastIndex, data.featureIds.value.length));
+  }
+  return features;
+}
+function parseFeature(data, startIndex, endIndex) {
+  const geometry = binaryToGeometry(data, startIndex, endIndex);
+  const properties = parseProperties(data, startIndex, endIndex);
+  const fields = parseFields(data, startIndex, endIndex);
+  return { type: "Feature", geometry, properties, ...fields };
+}
+function parseFields(data, startIndex = 0, endIndex) {
+  return data.fields && data.fields[data.featureIds.value[startIndex]];
+}
+function parseProperties(data, startIndex = 0, endIndex) {
+  const properties = Object.assign({}, data.properties[data.featureIds.value[startIndex]]);
+  for (const key in data.numericProps) {
+    properties[key] = data.numericProps[key].value[startIndex];
+  }
+  return properties;
+}
+function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+  const { positions } = data;
+  const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+  const primitivePolygonIndices = data.primitivePolygonIndices.value.filter(
+    (x) => x >= startIndex && x <= endIndex
+  );
+  const multi = polygonIndices.length > 2;
+  if (!multi) {
+    const coordinates2 = [];
+    for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
+      const startRingIndex = primitivePolygonIndices[i];
+      const endRingIndex = primitivePolygonIndices[i + 1];
+      const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
+      coordinates2.push(ringCoordinates);
+    }
+    return { type: "Polygon", coordinates: coordinates2 };
+  }
+  const coordinates = [];
+  for (let i = 0; i < polygonIndices.length - 1; i++) {
+    const startPolygonIndex = polygonIndices[i];
+    const endPolygonIndex = polygonIndices[i + 1];
+    const polygonCoordinates = polygonToGeoJson(
+      data,
+      startPolygonIndex,
+      endPolygonIndex
+    ).coordinates;
+    coordinates.push(polygonCoordinates);
+  }
+  return { type: "MultiPolygon", coordinates };
+}
+function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+  const { positions } = data;
+  const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+  const multi = pathIndices.length > 2;
+  if (!multi) {
+    const coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
+    return { type: "LineString", coordinates: coordinates2 };
+  }
+  const coordinates = [];
+  for (let i = 0; i < pathIndices.length - 1; i++) {
+    const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
+    coordinates.push(ringCoordinates);
+  }
+  return { type: "MultiLineString", coordinates };
+}
+function pointToGeoJson(data, startIndex, endIndex) {
+  const { positions } = data;
+  const coordinates = ringToGeoJson(positions, startIndex, endIndex);
+  const multi = coordinates.length > 1;
+  if (multi) {
+    return { type: "MultiPoint", coordinates };
+  }
+  return { type: "Point", coordinates: coordinates[0] };
+}
+function ringToGeoJson(positions, startIndex, endIndex) {
+  startIndex = startIndex || 0;
+  endIndex = endIndex || positions.value.length / positions.size;
+  const ringCoordinates = [];
+  for (let j = startIndex; j < endIndex; j++) {
+    const coord = Array();
+    for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
+      coord.push(Number(positions.value[k]));
+    }
+    ringCoordinates.push(coord);
+  }
+  return ringCoordinates;
+}
+
+// src/lib/transform.ts
+function transformBinaryCoords(binaryFeatures, transformCoordinate) {
+  if (binaryFeatures.points) {
+    transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);
+  }
+  if (binaryFeatures.lines) {
+    transformBinaryGeometryPositions(binaryFeatures.lines, transformCoordinate);
+  }
+  if (binaryFeatures.polygons) {
+    transformBinaryGeometryPositions(binaryFeatures.polygons, transformCoordinate);
+  }
+  return binaryFeatures;
+}
+function transformBinaryGeometryPositions(binaryGeometry, fn) {
+  const { positions } = binaryGeometry;
+  for (let i = 0; i < positions.value.length; i += positions.size) {
+    const coord = Array.from(positions.value.subarray(i, i + positions.size));
+    const transformedCoord = fn(coord);
+    positions.value.set(transformedCoord, i);
+  }
+}
+function transformGeoJsonCoords(features, fn) {
+  for (const feature of features) {
+    feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
+  }
+  return features;
+}
+function coordMap(array, fn) {
+  if (isCoord(array)) {
+    return fn(array);
+  }
+  return array.map((item) => {
+    return coordMap(item, fn);
+  });
+}
+function isCoord(array) {
+  return Array.isArray(array) && Number.isFinite(array[0]) && Number.isFinite(array[1]);
+}