@loaders.gl/gis 4.0.0-alpha.9 → 4.0.0-beta.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@loaders.gl/gis",
   "description": "Helpers for GIS category data",
-  "version": "4.0.0-alpha.9",
+  "version": "4.0.0-beta.2",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -24,8 +24,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@loaders.gl/loader-utils": "4.0.0-alpha.9",
-    "@loaders.gl/schema": "4.0.0-alpha.9",
+    "@loaders.gl/loader-utils": "4.0.0-beta.2",
+    "@loaders.gl/schema": "4.0.0-beta.2",
     "@mapbox/vector-tile": "^1.3.1",
     "@math.gl/polygon": "^3.5.1",
     "pbf": "^3.2.1"
@@ -33,5 +33,5 @@
   "devDependencies": {
     "@math.gl/proj4": "^3.5.1"
   },
-  "gitHead": "03ff81ab468f20f3bddeec787aa88d477a7e1c72"
+  "gitHead": "79c2033f755e88e11bc30a04428e3666b177b8fc"
 }

package/src/index.ts

@@ -4,5 +4,5 @@
 export {flatGeojsonToBinary} from './lib/flat-geojson-to-binary';
 export {geojsonToBinary} from './lib/geojson-to-binary';
 export {geojsonToFlatGeojson} from './lib/geojson-to-flat-geojson';
-export {binaryToGeojson, binaryToGeoJson, binaryToGeometry} from './lib/binary-to-geojson';
+export {binaryToGeojson, binaryToGeometry} from './lib/binary-to-geojson';
 export {transformBinaryCoords, transformGeoJsonCoords} from './lib/transform';

package/src/lib/binary-to-geojson.ts

@@ -1,10 +1,16 @@
+// loaders.gl, MIT license
+
 import type {
   BinaryGeometry,
-  BinaryFeatures,
   BinaryGeometryType,
-  BinaryPointFeatures,
-  BinaryLineFeatures,
-  BinaryPolygonFeatures,
+  BinaryPointGeometry,
+  BinaryLineGeometry,
+  BinaryPolygonGeometry,
+  BinaryFeatureCollection,
+  BinaryFeature,
+  // BinaryPointFeature,
+  // BinaryLineFeature,
+  // BinaryPolygonFeature,
   BinaryAttribute
 } from '@loaders.gl/schema';
 import type {Feature, Geometry, Position, GeoJsonProperties} from '@loaders.gl/schema';
@@ -34,7 +40,7 @@ type BinaryToGeoJsonOptions = {
  * @return GeoJSON objects
  */
 export function binaryToGeojson(
-  data: BinaryFeatures,
+  data: BinaryFeatureCollection,
   options?: BinaryToGeoJsonOptions
 ): Feature[] | Feature {
   const globalFeatureId = options?.globalFeatureId;
@@ -44,28 +50,29 @@ export function binaryToGeojson(
   return parseFeatures(data, options?.type);
 }
 
-/** @deprecated use `binaryToGeojson` or `binaryToGeometry` instead */
+/** @deprecated use `binaryToGeojson` or `binaryToGeometry` instead *
 export function binaryToGeoJson(
-  data: BinaryGeometry | BinaryFeatures,
+  data: BinaryGeometry | BinaryFeatureCollection,
   type?: BinaryGeometryType,
   format: 'feature' | 'geometry' = 'feature'
 ): Geometry | Feature[] {
   switch (format) {
     case 'feature':
-      return parseFeatures(data as BinaryFeatures, type);
+      return parseFeatures(data as BinaryFeatureCollection, type);
     case 'geometry':
-      return binaryToGeometry(data as BinaryGeometry);
+      return binaryToGeometry(data as any);
     default:
       throw new Error(format);
   }
 }
+*/
 
 /**
  * Return a single feature from a binary geometry representation as GeoJSON
  * @param data   geometry data in binary representation
  * @return GeoJSON feature
  */
-function getSingleFeature(data: BinaryFeatures, globalFeatureId: number): Feature {
+function getSingleFeature(data: BinaryFeatureCollection, globalFeatureId: number): Feature {
   const dataArray = normalizeInput(data);
   for (const data of dataArray) {
     let lastIndex = 0;
@@ -93,7 +100,7 @@ function getSingleFeature(data: BinaryFeatures, globalFeatureId: number): Featur
   throw new Error(`featureId:${globalFeatureId} not found`);
 }
 
-function parseFeatures(data: BinaryFeatures, type?: BinaryGeometryType): Feature[] {
+function parseFeatures(data: BinaryFeatureCollection, type?: BinaryGeometryType): Feature[] {
   const dataArray = normalizeInput(data, type);
   return parseFeatureCollection(dataArray);
 }
@@ -117,22 +124,10 @@ export function binaryToGeometry(
   }
 }
 
-type BinaryFeature = BinaryPointFeatures | BinaryLineFeatures | BinaryPolygonFeatures;
-type BinaryFeaturesArray = BinaryFeature[];
-
 // Normalize features
 // Return an array of data objects, each of which have a type key
-function normalizeInput(data: BinaryFeatures, type?: BinaryGeometryType): BinaryFeaturesArray {
-  const isHeterogeneousType = Boolean(data.points || data.lines || data.polygons);
-
-  if (!isHeterogeneousType) {
-    // @ts-expect-error This is a legacy check which allowed `data` to be an instance of the values
-    // here. Aka the new data.points, data.lines, or data.polygons.
-    data.type = type || parseType(data);
-    return [data] as BinaryFeaturesArray;
-  }
-
-  const features: BinaryFeaturesArray = [];
+function normalizeInput(data: BinaryFeatureCollection, type?: BinaryGeometryType): BinaryFeature[] {
+  const features: BinaryFeature[] = [];
   if (data.points) {
     data.points.type = 'Point';
     features.push(data.points);
@@ -150,7 +145,7 @@ function normalizeInput(data: BinaryFeatures, type?: BinaryGeometryType): Binary
 }
 
 /** Parse input binary data and return an array of GeoJSON Features */
-function parseFeatureCollection(dataArray): Feature[] {
+function parseFeatureCollection(dataArray: BinaryFeature[]): Feature[] {
   const features: Feature[] = [];
   for (const data of dataArray) {
     if (data.featureIds.value.length === 0) {
@@ -180,7 +175,7 @@ function parseFeatureCollection(dataArray): Feature[] {
 }
 
 /** Parse input binary data and return a single GeoJSON Feature */
-function parseFeature(data, startIndex?: number, endIndex?: number): Feature {
+function parseFeature(data: BinaryFeature, startIndex?: number, endIndex?: number): Feature {
   const geometry = binaryToGeometry(data, startIndex, endIndex);
   const properties = parseProperties(data, startIndex, endIndex);
   const fields = parseFields(data, startIndex, endIndex);
@@ -203,7 +198,7 @@ function parseProperties(data, startIndex: number = 0, endIndex?: number): GeoJs
 
 /** Parse binary data of type Polygon */
 function polygonToGeoJson(
-  data,
+  data: BinaryPolygonGeometry,
   startIndex: number = -Infinity,
   endIndex: number = Infinity
 ): Polygon | MultiPolygon {
@@ -245,7 +240,7 @@ function polygonToGeoJson(
 
 /** Parse binary data of type LineString */
 function lineStringToGeoJson(
-  data,
+  data: BinaryLineGeometry,
   startIndex: number = -Infinity,
   endIndex: number = Infinity
 ): LineString | MultiLineString {
@@ -268,7 +263,7 @@ function lineStringToGeoJson(
 }
 
 /** Parse binary data of type Point */
-function pointToGeoJson(data, startIndex, endIndex): Point | MultiPoint {
+function pointToGeoJson(data: BinaryPointGeometry, startIndex, endIndex): Point | MultiPoint {
   const {positions} = data;
   const coordinates = ringToGeoJson(positions, startIndex, endIndex);
   const multi = coordinates.length > 1;
@@ -306,16 +301,3 @@ function ringToGeoJson(
   }
   return ringCoordinates;
 }
-
-// Deduce geometry type of data object
-function parseType(data) {
-  if (data.pathIndices) {
-    return 'LineString';
-  }
-
-  if (data.polygonIndices) {
-    return 'Polygon';
-  }
-
-  return 'Point';
-}

package/src/lib/flat-geojson-to-binary-types.ts

@@ -47,7 +47,7 @@ export type Polygons = {
   positions: Float32Array | Float64Array;
   polygonIndices: Uint16Array | Uint32Array;
   primitivePolygonIndices: Uint16Array | Uint32Array;
-  triangles: number[];
+  triangles?: number[];
   globalFeatureIds: Uint16Array | Uint32Array;
   featureIds: Uint16Array | Uint32Array;
   numericProps: {[key: string]: TypedArray};

package/src/lib/flat-geojson-to-binary.ts

@@ -2,7 +2,8 @@
 import {earcut} from '@math.gl/polygon';
 import type {
   BinaryAttribute,
-  BinaryFeatures,
+  BinaryFeatureCollection,
+  BinaryPolygonFeature,
   FlatFeature,
   FlatPoint,
   FlatLineString,
@@ -40,7 +41,8 @@ export function flatGeojsonToBinary(
     },
     {
       numericPropKeys: (options && options.numericPropKeys) || numericPropKeys,
-      PositionDataType: options ? options.PositionDataType : Float32Array
+      PositionDataType: options ? options.PositionDataType : Float32Array,
+      triangulate: options ? options.triangulate : true
     }
   );
 }
@@ -51,6 +53,7 @@ export function flatGeojsonToBinary(
 export type FlatGeojsonToBinaryOptions = {
   numericPropKeys?: string[];
   PositionDataType?: Float32ArrayConstructor | Float64ArrayConstructor;
+  triangulate?: boolean;
 };
 
 export const TEST_EXPORTS = {
@@ -91,7 +94,7 @@ function extractNumericPropTypes(features: FlatFeature[]): {
  * @param options
  * @returns an accessor object with value and size keys
  */
-// eslint-disable-next-line complexity
+// eslint-disable-next-line complexity, max-statements
 function fillArrays(
   features: FlatFeature[],
   geometryInfo: GeojsonGeometryInfo & {
@@ -112,7 +115,7 @@ function fillArrays(
     propArrayTypes,
     coordLength
   } = geometryInfo;
-  const {numericPropKeys = [], PositionDataType = Float32Array} = options;
+  const {numericPropKeys = [], PositionDataType = Float32Array, triangulate = true} = options;
   const hasGlobalId = features[0] && 'id' in features[0];
   const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
   const points: Points = {
@@ -154,7 +157,6 @@ function fillArrays(
         ? new Uint32Array(polygonRingsCount + 1)
         : new Uint16Array(polygonRingsCount + 1),
     positions: new PositionDataType(polygonPositionsCount * coordLength),
-    triangles: [],
     globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
     featureIds:
       polygonFeaturesCount > 65535
@@ -165,6 +167,10 @@ function fillArrays(
     fields: []
   };
 
+  if (triangulate) {
+    polygons.triangles = [];
+  }
+
   // Instantiate numeric properties arrays; one value per vertex
   for (const object of [points, lines, polygons]) {
     for (const propName of numericPropKeys) {
@@ -423,6 +429,10 @@ function triangulatePolygon(
     coordLength
   }: {startPosition: number; endPosition: number; coordLength: number}
 ): void {
+  if (!polygons.triangles) {
+    return;
+  }
+
   const start = startPosition * coordLength;
   const end = endPosition * coordLength;
 
@@ -475,8 +485,8 @@ function makeAccessorObjects(
   lines: Lines,
   polygons: Polygons,
   coordLength: number
-): BinaryFeatures {
-  return {
+): BinaryFeatureCollection {
+  const binaryFeatures: BinaryFeatureCollection = {
     points: {
       ...points,
       positions: {value: points.positions, size: coordLength},
@@ -497,12 +507,17 @@ function makeAccessorObjects(
       positions: {value: polygons.positions, size: coordLength},
       polygonIndices: {value: polygons.polygonIndices, size: 1},
       primitivePolygonIndices: {value: polygons.primitivePolygonIndices, size: 1},
-      triangles: {value: new Uint32Array(polygons.triangles), size: 1},
       globalFeatureIds: {value: polygons.globalFeatureIds, size: 1},
       featureIds: {value: polygons.featureIds, size: 1},
       numericProps: wrapProps(polygons.numericProps, 1)
-    }
+    } as BinaryPolygonFeature // triangles not expected
   };
+
+  if (binaryFeatures.polygons && polygons.triangles) {
+    binaryFeatures.polygons.triangles = {value: new Uint32Array(polygons.triangles), size: 1};
+  }
+
+  return binaryFeatures;
 }
 
 /**

package/src/lib/geojson-to-binary.ts

@@ -1,5 +1,5 @@
 import type {Feature} from '@loaders.gl/schema';
-import type {BinaryFeatures} from '@loaders.gl/schema';
+import type {BinaryFeatureCollection} from '@loaders.gl/schema';
 
 import {extractGeometryInfo} from './extract-geometry-info';
 import {geojsonToFlatGeojson} from './geojson-to-flat-geojson';
@@ -12,6 +12,7 @@ export type GeojsonToBinaryOptions = {
   fixRingWinding: boolean;
   numericPropKeys?: string[];
   PositionDataType?: Float32ArrayConstructor | Float64ArrayConstructor;
+  triangulate?: boolean;
 };
 
 /**
@@ -23,14 +24,15 @@ export type GeojsonToBinaryOptions = {
  */
 export function geojsonToBinary(
   features: Feature[],
-  options: GeojsonToBinaryOptions = {fixRingWinding: true}
-): BinaryFeatures {
+  options: GeojsonToBinaryOptions = {fixRingWinding: true, triangulate: true}
+): BinaryFeatureCollection {
   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
+    PositionDataType: options.PositionDataType || Float32Array,
+    triangulate: options.triangulate
   });
 }

package/src/lib/transform.ts

@@ -1,4 +1,4 @@
-import type {BinaryFeatures, BinaryGeometry} from '@loaders.gl/schema';
+import type {BinaryFeatureCollection, BinaryGeometry, Feature} from '@loaders.gl/schema';
 
 type TransformCoordinate = (coord: number[]) => number[];
 
@@ -9,9 +9,9 @@ type TransformCoordinate = (coord: number[]) => number[];
  * @return Transformed binary features
  */
 export function transformBinaryCoords(
-  binaryFeatures: BinaryFeatures,
+  binaryFeatures: BinaryFeatureCollection,
   transformCoordinate: TransformCoordinate
-): BinaryFeatures {
+): BinaryFeatureCollection {
   if (binaryFeatures.points) {
     transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);
   }
@@ -44,9 +44,9 @@ function transformBinaryGeometryPositions(binaryGeometry: BinaryGeometry, fn: Tr
  * @return          Transformed GeoJSON features
  */
 export function transformGeoJsonCoords(
-  features: object[],
+  features: Feature[],
   fn: (coord: number[]) => number[]
-): object[] {
+): Feature[] {
   for (const feature of features) {
     // @ts-ignore
     feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
@@ -54,16 +54,16 @@ export function transformGeoJsonCoords(
   return features;
 }
 
-function coordMap(array, fn) {
+function coordMap(array: unknown, fn: (coord: number[]) => number[]): unknown[] {
   if (isCoord(array)) {
-    return fn(array);
+    return fn(array as number[]);
   }
 
-  return array.map((item) => {
+  return (array as unknown[]).map((item) => {
     return coordMap(item, fn);
   });
 }
 
-function isCoord(array) {
-  return Number.isFinite(array[0]) && Number.isFinite(array[1]);
+function isCoord(array: unknown) {
+  return Array.isArray(array) && Number.isFinite(array[0]) && Number.isFinite(array[1]);
 }

package/dist/bundle.js

@@ -1,5 +0,0 @@
-"use strict";
-// @ts-nocheck
-const moduleExports = require('./index');
-globalThis.loaders = globalThis.loaders || {};
-module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/index.js

@@ -1,18 +0,0 @@
-"use strict";
-// Types from `@loaders.gl/schema`
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformGeoJsonCoords = exports.transformBinaryCoords = exports.binaryToGeometry = exports.binaryToGeoJson = exports.binaryToGeojson = exports.geojsonToFlatGeojson = exports.geojsonToBinary = exports.flatGeojsonToBinary = void 0;
-// Functions
-var flat_geojson_to_binary_1 = require("./lib/flat-geojson-to-binary");
-Object.defineProperty(exports, "flatGeojsonToBinary", { enumerable: true, get: function () { return flat_geojson_to_binary_1.flatGeojsonToBinary; } });
-var geojson_to_binary_1 = require("./lib/geojson-to-binary");
-Object.defineProperty(exports, "geojsonToBinary", { enumerable: true, get: function () { return geojson_to_binary_1.geojsonToBinary; } });
-var geojson_to_flat_geojson_1 = require("./lib/geojson-to-flat-geojson");
-Object.defineProperty(exports, "geojsonToFlatGeojson", { enumerable: true, get: function () { return geojson_to_flat_geojson_1.geojsonToFlatGeojson; } });
-var binary_to_geojson_1 = require("./lib/binary-to-geojson");
-Object.defineProperty(exports, "binaryToGeojson", { enumerable: true, get: function () { return binary_to_geojson_1.binaryToGeojson; } });
-Object.defineProperty(exports, "binaryToGeoJson", { enumerable: true, get: function () { return binary_to_geojson_1.binaryToGeoJson; } });
-Object.defineProperty(exports, "binaryToGeometry", { enumerable: true, get: function () { return binary_to_geojson_1.binaryToGeometry; } });
-var transform_1 = require("./lib/transform");
-Object.defineProperty(exports, "transformBinaryCoords", { enumerable: true, get: function () { return transform_1.transformBinaryCoords; } });
-Object.defineProperty(exports, "transformGeoJsonCoords", { enumerable: true, get: function () { return transform_1.transformGeoJsonCoords; } });

package/dist/lib/binary-to-geojson.js

@@ -1,233 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.binaryToGeometry = exports.binaryToGeoJson = exports.binaryToGeojson = void 0;
-/**
- * Convert binary geometry representation to GeoJSON
- * @param data   geometry data in binary representation
- * @param options
- * @param options.type  Input data type: Point, LineString, or Polygon
- * @param options.featureId  Global feature id. If specified, only a single feature is extracted
- * @return GeoJSON objects
- */
-function binaryToGeojson(data, options) {
-    const globalFeatureId = options?.globalFeatureId;
-    if (globalFeatureId !== undefined) {
-        return getSingleFeature(data, globalFeatureId);
-    }
-    return parseFeatures(data, options?.type);
-}
-exports.binaryToGeojson = binaryToGeojson;
-/** @deprecated use `binaryToGeojson` or `binaryToGeometry` instead */
-function binaryToGeoJson(data, type, format = 'feature') {
-    switch (format) {
-        case 'feature':
-            return parseFeatures(data, type);
-        case 'geometry':
-            return binaryToGeometry(data);
-        default:
-            throw new Error(format);
-    }
-}
-exports.binaryToGeoJson = binaryToGeoJson;
-/**
- * Return a single feature from a binary geometry representation as GeoJSON
- * @param data   geometry data in binary representation
- * @return GeoJSON feature
- */
-function getSingleFeature(data, globalFeatureId) {
-    const dataArray = normalizeInput(data);
-    for (const data of dataArray) {
-        let lastIndex = 0;
-        let lastValue = data.featureIds.value[0];
-        // Scan through data until we find matching feature
-        for (let i = 0; i < data.featureIds.value.length; i++) {
-            const currValue = data.featureIds.value[i];
-            if (currValue === lastValue) {
-                // eslint-disable-next-line no-continue
-                continue;
-            }
-            if (globalFeatureId === data.globalFeatureIds.value[lastIndex]) {
-                return parseFeature(data, lastIndex, i);
-            }
-            lastIndex = i;
-            lastValue = currValue;
-        }
-        if (globalFeatureId === data.globalFeatureIds.value[lastIndex]) {
-            return parseFeature(data, lastIndex, data.featureIds.value.length);
-        }
-    }
-    throw new Error(`featureId:${globalFeatureId} not found`);
-}
-function parseFeatures(data, type) {
-    const dataArray = normalizeInput(data, type);
-    return parseFeatureCollection(dataArray);
-}
-/** Parse input binary data and return a valid GeoJSON geometry object */
-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?.type}`);
-    }
-}
-exports.binaryToGeometry = binaryToGeometry;
-// Normalize features
-// Return an array of data objects, each of which have a type key
-function normalizeInput(data, type) {
-    const isHeterogeneousType = Boolean(data.points || data.lines || data.polygons);
-    if (!isHeterogeneousType) {
-        // @ts-expect-error This is a legacy check which allowed `data` to be an instance of the values
-        // here. Aka the new data.points, data.lines, or data.polygons.
-        data.type = type || parseType(data);
-        return [data];
-    }
-    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;
-}
-/** Parse input binary data and return an array of GeoJSON Features */
-function parseFeatureCollection(dataArray) {
-    const features = [];
-    for (const data of dataArray) {
-        if (data.featureIds.value.length === 0) {
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        let lastIndex = 0;
-        let lastValue = data.featureIds.value[0];
-        // Need to deduce start, end indices of each feature
-        for (let i = 0; i < data.featureIds.value.length; i++) {
-            const currValue = data.featureIds.value[i];
-            if (currValue === lastValue) {
-                // eslint-disable-next-line no-continue
-                continue;
-            }
-            features.push(parseFeature(data, lastIndex, i));
-            lastIndex = i;
-            lastValue = currValue;
-        }
-        // Last feature
-        features.push(parseFeature(data, lastIndex, data.featureIds.value.length));
-    }
-    return features;
-}
-/** Parse input binary data and return a single GeoJSON Feature */
-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 };
-}
-/** Parse input binary data and return an object of fields */
-function parseFields(data, startIndex = 0, endIndex) {
-    return data.fields && data.fields[data.featureIds.value[startIndex]];
-}
-/** Parse input binary data and return an object of properties */
-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;
-}
-/** Parse binary data of type Polygon */
-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;
-    // Polygon
-    if (!multi) {
-        const coordinates = [];
-        for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
-            const startRingIndex = primitivePolygonIndices[i];
-            const endRingIndex = primitivePolygonIndices[i + 1];
-            const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
-            coordinates.push(ringCoordinates);
-        }
-        return { type: 'Polygon', coordinates };
-    }
-    // MultiPolygon
-    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 };
-}
-/** Parse binary data of type LineString */
-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 coordinates = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
-        return { type: 'LineString', coordinates };
-    }
-    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 };
-}
-/** Parse binary data of type Point */
-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] };
-}
-/**
- * Parse a linear ring of positions to a GeoJSON linear ring
- *
- * @param positions Positions TypedArray
- * @param startIndex Start index to include in ring
- * @param endIndex End index to include in ring
- * @returns GeoJSON ring
- */
-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;
-}
-// Deduce geometry type of data object
-function parseType(data) {
-    if (data.pathIndices) {
-        return 'LineString';
-    }
-    if (data.polygonIndices) {
-        return 'Polygon';
-    }
-    return 'Point';
-}