@loaders.gl/gis 4.0.0-alpha.4 → 4.0.0-alpha.5

package/dist/bundle.d.ts

@@ -0,0 +1,2 @@
+declare const moduleExports: any;
+//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,aAAa,KAAqB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+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 { transformBinaryCoords, transformGeoJsonCoords } from './lib/transform';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAC,eAAe,EAAC,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAC,oBAAoB,EAAC,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAC,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAC,MAAM,yBAAyB,CAAC;AAC3F,OAAO,EAAC,qBAAqB,EAAE,sBAAsB,EAAC,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -1,4 +1,6 @@
+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 { transformBinaryCoords, transformGeoJsonCoords } from './lib/transform';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":["geojsonToBinary","binaryToGeojson","binaryToGeoJson","binaryToGeometry","transformBinaryCoords","transformGeoJsonCoords"],"mappings":"AAGA,SAAQA,eAAR,QAA8B,yBAA9B;AACA,SAAQC,eAAR,EAAyBC,eAAzB,EAA0CC,gBAA1C,QAAiE,yBAAjE;AACA,SAAQC,qBAAR,EAA+BC,sBAA/B,QAA4D,iBAA5D","sourcesContent":["// Types from `@loaders.gl/schema`\n\n// Functions\nexport {geojsonToBinary} from './lib/geojson-to-binary';\nexport {binaryToGeojson, binaryToGeoJson, binaryToGeometry} from './lib/binary-to-geojson';\nexport {transformBinaryCoords, transformGeoJsonCoords} from './lib/transform';\n"],"file":"index.js"}
+{"version":3,"sources":["../src/index.ts"],"names":["flatGeojsonToBinary","geojsonToBinary","geojsonToFlatGeojson","binaryToGeojson","binaryToGeoJson","binaryToGeometry","transformBinaryCoords","transformGeoJsonCoords"],"mappings":"AAGA,SAAQA,mBAAR,QAAkC,8BAAlC;AACA,SAAQC,eAAR,QAA8B,yBAA9B;AACA,SAAQC,oBAAR,QAAmC,+BAAnC;AACA,SAAQC,eAAR,EAAyBC,eAAzB,EAA0CC,gBAA1C,QAAiE,yBAAjE;AACA,SAAQC,qBAAR,EAA+BC,sBAA/B,QAA4D,iBAA5D","sourcesContent":["// Types from `@loaders.gl/schema`\n\n// Functions\nexport {flatGeojsonToBinary} from './lib/flat-geojson-to-binary';\nexport {geojsonToBinary} from './lib/geojson-to-binary';\nexport {geojsonToFlatGeojson} from './lib/geojson-to-flat-geojson';\nexport {binaryToGeojson, binaryToGeoJson, binaryToGeometry} from './lib/binary-to-geojson';\nexport {transformBinaryCoords, transformGeoJsonCoords} from './lib/transform';\n"],"file":"index.js"}

package/dist/lib/binary-to-geojson.d.ts

@@ -0,0 +1,21 @@
+import type { BinaryGeometry, BinaryFeatures, BinaryGeometryType } from '@loaders.gl/schema';
+import type { Feature, Geometry } from '@loaders.gl/schema';
+declare type BinaryToGeoJsonOptions = {
+    type?: BinaryGeometryType;
+    globalFeatureId?: number;
+};
+/**
+ * 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
+ */
+export declare function binaryToGeojson(data: BinaryFeatures, options?: BinaryToGeoJsonOptions): Feature[] | Feature;
+/** @deprecated use `binaryToGeojson` or `binaryToGeometry` instead */
+export declare function binaryToGeoJson(data: BinaryGeometry | BinaryFeatures, type?: BinaryGeometryType, format?: 'feature' | 'geometry'): Geometry | Feature[];
+/** Parse input binary data and return a valid GeoJSON geometry object */
+export declare function binaryToGeometry(data: BinaryGeometry, startIndex?: number, endIndex?: number): Geometry;
+export {};
+//# sourceMappingURL=binary-to-geojson.d.ts.map

package/dist/lib/binary-to-geojson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-to-geojson.d.ts","sourceRoot":"","sources":["../../src/lib/binary-to-geojson.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,cAAc,EACd,kBAAkB,EAKnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAC,OAAO,EAAE,QAAQ,EAA8B,MAAM,oBAAoB,CAAC;AAavF,aAAK,sBAAsB,GAAG;IAC5B,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,cAAc,EACpB,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,EAAE,GAAG,OAAO,CAMrB;AAED,sEAAsE;AACtE,wBAAgB,eAAe,CAC7B,IAAI,EAAE,cAAc,GAAG,cAAc,EACrC,IAAI,CAAC,EAAE,kBAAkB,EACzB,MAAM,GAAE,SAAS,GAAG,UAAsB,GACzC,QAAQ,GAAG,OAAO,EAAE,CAStB;AAwCD,yEAAyE;AACzE,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,cAAc,EACpB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,GAChB,QAAQ,CAYV"}

package/dist/lib/extract-geometry-info.d.ts

@@ -0,0 +1,8 @@
+import { Feature, GeojsonGeometryInfo } from '@loaders.gl/schema';
+/**
+ *  Initial scan over GeoJSON features
+ *  Counts number of coordinates of each geometry type and
+ *  keeps track of the max coordinate dimensions
+ */
+export declare function extractGeometryInfo(features: Feature[]): GeojsonGeometryInfo;
+//# sourceMappingURL=extract-geometry-info.d.ts.map

package/dist/lib/extract-geometry-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-geometry-info.d.ts","sourceRoot":"","sources":["../../src/lib/extract-geometry-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAE,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AAEhE;;;;GAIG;AAEH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,mBAAmB,CA4F5E"}

package/dist/lib/extract-geometry-info.js

@@ -0,0 +1,105 @@
+export 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 = 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 flattened = polygon.flat();
+          polygonPositionsCount += flattened.length;
+
+          for (const coord of flattened) {
+            coordLengths.add(coord.length);
+          }
+        }
+
+        break;
+
+      default:
+        throw new Error("Unsupported geometry type: ".concat(geometry.type));
+    }
+  }
+
+  return {
+    coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,
+    pointPositionsCount,
+    pointFeaturesCount,
+    linePositionsCount,
+    linePathsCount,
+    lineFeaturesCount,
+    polygonPositionsCount,
+    polygonObjectsCount,
+    polygonRingsCount,
+    polygonFeaturesCount
+  };
+}
+//# sourceMappingURL=extract-geometry-info.js.map

package/dist/lib/extract-geometry-info.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/extract-geometry-info.ts"],"names":["extractGeometryInfo","features","pointPositionsCount","pointFeaturesCount","linePositionsCount","linePathsCount","lineFeaturesCount","polygonPositionsCount","polygonObjectsCount","polygonRingsCount","polygonFeaturesCount","coordLengths","Set","feature","geometry","type","add","coordinates","length","point","coord","line","flattened","flat","polygon","Error","coordLength","size","Math","max"],"mappings":"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","sourcesContent":["import {Feature, GeojsonGeometryInfo} from '@loaders.gl/schema';\n\n/**\n *  Initial scan over GeoJSON features\n *  Counts number of coordinates of each geometry type and\n *  keeps track of the max coordinate dimensions\n */\n// eslint-disable-next-line complexity, max-statements\nexport function extractGeometryInfo(features: Feature[]): GeojsonGeometryInfo {\n  // Counts the number of _positions_, so [x, y, z] counts as one\n  let pointPositionsCount = 0;\n  let pointFeaturesCount = 0;\n  let linePositionsCount = 0;\n  let linePathsCount = 0;\n  let lineFeaturesCount = 0;\n  let polygonPositionsCount = 0;\n  let polygonObjectsCount = 0;\n  let polygonRingsCount = 0;\n  let polygonFeaturesCount = 0;\n  const coordLengths = new Set<number>();\n\n  for (const feature of features) {\n    const geometry = feature.geometry;\n    switch (geometry.type) {\n      case 'Point':\n        pointFeaturesCount++;\n        pointPositionsCount++;\n        coordLengths.add(geometry.coordinates.length);\n        break;\n      case 'MultiPoint':\n        pointFeaturesCount++;\n        pointPositionsCount += geometry.coordinates.length;\n        for (const point of geometry.coordinates) {\n          coordLengths.add(point.length);\n        }\n        break;\n      case 'LineString':\n        lineFeaturesCount++;\n        linePositionsCount += geometry.coordinates.length;\n        linePathsCount++;\n\n        for (const coord of geometry.coordinates) {\n          coordLengths.add(coord.length);\n        }\n        break;\n      case 'MultiLineString':\n        lineFeaturesCount++;\n        for (const line of geometry.coordinates) {\n          linePositionsCount += line.length;\n          linePathsCount++;\n\n          // eslint-disable-next-line max-depth\n          for (const coord of line) {\n            coordLengths.add(coord.length);\n          }\n        }\n        break;\n      case 'Polygon':\n        polygonFeaturesCount++;\n        polygonObjectsCount++;\n        polygonRingsCount += geometry.coordinates.length;\n        const flattened = geometry.coordinates.flat();\n        polygonPositionsCount += flattened.length;\n\n        for (const coord of flattened) {\n          coordLengths.add(coord.length);\n        }\n        break;\n      case 'MultiPolygon':\n        polygonFeaturesCount++;\n        for (const polygon of geometry.coordinates) {\n          polygonObjectsCount++;\n          polygonRingsCount += polygon.length;\n          const flattened = polygon.flat();\n          polygonPositionsCount += flattened.length;\n\n          // eslint-disable-next-line max-depth\n          for (const coord of flattened) {\n            coordLengths.add(coord.length);\n          }\n        }\n        break;\n      default:\n        throw new Error(`Unsupported geometry type: ${geometry.type}`);\n    }\n  }\n\n  return {\n    coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,\n\n    pointPositionsCount,\n    pointFeaturesCount,\n    linePositionsCount,\n    linePathsCount,\n    lineFeaturesCount,\n    polygonPositionsCount,\n    polygonObjectsCount,\n    polygonRingsCount,\n    polygonFeaturesCount\n  };\n}\n"],"file":"extract-geometry-info.js"}

package/dist/lib/flat-geojson-to-binary-types.d.ts

@@ -0,0 +1,58 @@
+import type { TypedArray } from '@loaders.gl/schema';
+/**
+ * Permissable constructor for numeric props
+ */
+export declare type PropArrayConstructor = Float32ArrayConstructor | Float64ArrayConstructor | ArrayConstructor;
+/**
+ * Collection type for holding intermediate binary data before conversion to `BinaryPointGeometry`
+ */
+export declare type Points = {
+    type: 'Point';
+    positions: Float32Array | Float64Array;
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: {
+        [key: string]: TypedArray;
+    };
+    properties: {}[];
+    fields: {
+        id?: string | number;
+    }[];
+};
+/**
+ * Collection type for holding intermediate binary data before conversion to `BinaryLineStringGeometry`
+ */
+export declare type Lines = {
+    type: 'LineString';
+    positions: Float32Array | Float64Array;
+    pathIndices: Uint16Array | Uint32Array;
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: {
+        [key: string]: TypedArray;
+    };
+    properties: {}[];
+    fields: {
+        id?: string | number;
+    }[];
+};
+/**
+ * Collection type for holding intermediate binary data before conversion to `BinaryPolygonGeometry`
+ */
+export declare type Polygons = {
+    type: 'Polygon';
+    positions: Float32Array | Float64Array;
+    polygonIndices: Uint16Array | Uint32Array;
+    primitivePolygonIndices: Uint16Array | Uint32Array;
+    triangles: number[];
+    globalFeatureIds: Uint16Array | Uint32Array;
+    featureIds: Uint16Array | Uint32Array;
+    numericProps: {
+        [key: string]: TypedArray;
+    };
+    properties: {}[];
+    fields: {
+        id?: string | number;
+    }[];
+};
+//# sourceMappingURL=flat-geojson-to-binary-types.d.ts.map

package/dist/lib/flat-geojson-to-binary-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-geojson-to-binary-types.d.ts","sourceRoot":"","sources":["../../src/lib/flat-geojson-to-binary-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEnD;;GAEG;AACH,oBAAY,oBAAoB,GAC5B,uBAAuB,GACvB,uBAAuB,GACvB,gBAAgB,CAAC;AAErB;;GAEG;AACH,oBAAY,MAAM,GAAG;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC;AAEF;;GAEG;AACH,oBAAY,KAAK,GAAG;IAClB,IAAI,EAAE,YAAY,CAAC;IACnB,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,WAAW,EAAE,WAAW,GAAG,WAAW,CAAC;IACvC,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC;AAEF;;GAEG;AACH,oBAAY,QAAQ,GAAG;IACrB,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,cAAc,EAAE,WAAW,GAAG,WAAW,CAAC;IAC1C,uBAAuB,EAAE,WAAW,GAAG,WAAW,CAAC;IACnD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=flat-geojson-to-binary-types.js.map

package/dist/lib/flat-geojson-to-binary-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"flat-geojson-to-binary-types.js"}

package/dist/lib/flat-geojson-to-binary.d.ts

@@ -0,0 +1,37 @@
+import type { BinaryFeatures, FlatFeature, GeojsonGeometryInfo } from '@loaders.gl/schema';
+import { PropArrayConstructor } from './flat-geojson-to-binary-types';
+/**
+ * Convert binary features to flat binary arrays. Similar to
+ * `geojsonToBinary` helper function, except that it expects
+ * a binary representation of the feature data, which enables
+ * 2X-3X speed increase in parse speed, compared to using
+ * geoJSON. See `binary-vector-tile/VectorTileFeature` for
+ * data format detais
+ *
+ * @param features
+ * @param geometryInfo
+ * @param options
+ * @returns filled arrays
+ */
+export declare function flatGeojsonToBinary(features: FlatFeature[], geometryInfo: GeojsonGeometryInfo, options?: FlatGeojsonToBinaryOptions): BinaryFeatures;
+/**
+ * Options for `flatGeojsonToBinary`
+ */
+export declare type FlatGeojsonToBinaryOptions = {
+    numericPropKeys?: string[];
+    PositionDataType?: Float32ArrayConstructor | Float64ArrayConstructor;
+};
+export declare const TEST_EXPORTS: {
+    extractNumericPropTypes: typeof extractNumericPropTypes;
+};
+/**
+ * Extracts properties that are always numeric
+ *
+ * @param features
+ * @returns object with numeric types
+ */
+declare function extractNumericPropTypes(features: FlatFeature[]): {
+    [key: string]: PropArrayConstructor;
+};
+export {};
+//# sourceMappingURL=flat-geojson-to-binary.d.ts.map

package/dist/lib/flat-geojson-to-binary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-geojson-to-binary.d.ts","sourceRoot":"","sources":["../../src/lib/flat-geojson-to-binary.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,cAAc,EACd,WAAW,EAIX,mBAAmB,EAEpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAC,oBAAoB,EAA0B,MAAM,gCAAgC,CAAC;AAE7F;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,WAAW,EAAE,EACvB,YAAY,EAAE,mBAAmB,EACjC,OAAO,CAAC,EAAE,0BAA0B,kBAerC;AAED;;GAEG;AACH,oBAAY,0BAA0B,GAAG;IACvC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,uBAAuB,GAAG,uBAAuB,CAAC;CACtE,CAAC;AAEF,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF;;;;;GAKG;AACH,iBAAS,uBAAuB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG;IACzD,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAAC;CACrC,CAgBA"}

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

@@ -0,0 +1,339 @@
+import { earcut } from '@math.gl/polygon';
+export 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
+  });
+}
+export const TEST_EXPORTS = {
+  extractNumericPropTypes
+};
+
+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
+  } = 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),
+    triangles: [],
+    globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
+    featureIds: polygonFeaturesCount > 65535 ? new Uint32Array(polygonPositionsCount) : new Uint16Array(polygonPositionsCount),
+    numericProps: {},
+    properties: [],
+    fields: []
+  };
+
+  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 ? nextIndices === undefined ? 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
+}) {
+  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 = 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) {
+  return {
+    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
+      },
+      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)
+    }
+  };
+}
+
+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;
+}
+//# sourceMappingURL=flat-geojson-to-binary.js.map