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

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

@@ -1,316 +1,381 @@
+/* eslint-disable indent */
 import { earcut } from '@math.gl/polygon';
+/**
+ * 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 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
-  });
+    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
+    });
 }
 export const TEST_EXPORTS = {
-  extractNumericPropTypes
+    extractNumericPropTypes
 };
+/**
+ * Extracts properties that are always numeric
+ *
+ * @param features
+ * @returns object with numeric types
+ */
 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]);
-      }
+    const propArrayTypes = {};
+    for (const feature of features) {
+        if (feature.properties) {
+            for (const key in feature.properties) {
+                // If property has not been seen before, or if property has been numeric
+                // in all previous features, check if numeric in this feature
+                // If not numeric, Array is stored to prevent rechecking in the future
+                // Additionally, detects if 64 bit precision is required
+                const val = feature.properties[key];
+                propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);
+            }
+        }
     }
-  }
-  return propArrayTypes;
+    return propArrayTypes;
 }
+/**
+ * Fills coordinates into pre-allocated typed arrays
+ *
+ * @param features
+ * @param geometryInfo
+ * @param options
+ * @returns an accessor object with value and size keys
+ */
+// eslint-disable-next-line complexity, max-statements
 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);
+    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 = [];
     }
-  }
-  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
-          });
+    // Instantiate numeric properties arrays; one value per vertex
+    for (const object of [points, lines, polygons]) {
+        for (const propName of numericPropKeys) {
+            // If property has been numeric in all previous features in which the property existed, check
+            // if numeric in this feature
+            const T = propArrayTypes[propName];
+            object.numericProps[propName] = new T(object.positions.length / coordLength);
         }
-        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
-          });
+    }
+    // Set last element of path/polygon indices as positions length
+    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.polygonFeature++;
-        break;
-      default:
-        throw new Error('Invalid geometry type');
+        indexMap.feature++;
     }
-    indexMap.feature++;
-  }
-  return makeAccessorObjects(points, lines, polygons, coordLength);
+    // Wrap each array in an accessor object with value and size keys
+    return makeAccessorObjects(points, lines, polygons, coordLength);
 }
+/**
+ * Fills (Multi)Point coordinates into points object of arrays
+ *
+ * @param geometry
+ * @param points
+ * @param indexMap
+ * @param coordLength
+ * @param properties
+ */
 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;
+    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;
 }
+/**
+ * Fills (Multi)LineString coordinates into lines object of arrays
+ *
+ * @param geometry
+ * @param lines
+ * @param indexMap
+ * @param coordLength
+ * @param properties
+ */
 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;
-  }
+    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) {
+        // Extract range of data we are working with, defined by start
+        // and end indices (these index into the geometry.data array)
+        const start = geometry.indices[i];
+        const end = i === il - 1
+            ? geometry.data.length // last line, so read to end of data
+            : geometry.indices[i + 1]; // start index for next line
+        lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
+        indexMap.linePosition += (end - start) / coordLength;
+    }
 }
+/**
+ * Fills (Multi)Polygon coordinates into polygons object of arrays
+ *
+ * @param geometry
+ * @param polygons
+ * @param indexMap
+ * @param coordLength
+ * @param properties
+ */
 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;
+    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);
+    // Unlike Point & LineString geometry.indices is a 2D array
+    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 === undefined
+                        ? geometry.data.length // end of data (no next indices)
+                        : nextIndices[0] // start of first line in nextIndices
+                : indices[i + 1]; // start index for next line
+            polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
+            indexMap.polygonPosition += (end - start) / coordLength;
+        }
+        const endPosition = indexMap.polygonPosition;
+        triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength });
     }
-    const endPosition = indexMap.polygonPosition;
-    triangulatePolygon(polygons, areas, indices, {
-      startPosition,
-      endPosition,
-      coordLength
-    });
-  }
 }
-function triangulatePolygon(polygons, areas, indices, _ref) {
-  let {
-    startPosition,
-    endPosition,
-    coordLength
-  } = _ref;
-  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 = earcut(polygonPositions, holes, coordLength, areas);
-  for (let t = 0, tl = triangles.length; t < tl; ++t) {
-    polygons.triangles.push(startPosition + triangles[t]);
-  }
+/**
+ * Triangulate polygon using earcut
+ *
+ * @param polygons
+ * @param areas
+ * @param indices
+ * @param param3
+ */
+function triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength }) {
+    if (!polygons.triangles) {
+        return;
+    }
+    const start = startPosition * coordLength;
+    const end = endPosition * coordLength;
+    // Extract positions and holes for just this polygon
+    const polygonPositions = polygons.positions.subarray(start, end);
+    // Holes are referenced relative to outer polygon
+    const offset = indices[0];
+    const holes = indices.slice(1).map((n) => (n - offset) / coordLength);
+    // Compute triangulation
+    const triangles = earcut(polygonPositions, holes, coordLength, areas);
+    // Indices returned by triangulation are relative to start
+    // of polygon, so we need to offset
+    for (let t = 0, tl = triangles.length; t < tl; ++t) {
+        polygons.triangles.push(startPosition + triangles[t]);
+    }
 }
+/**
+ * Wraps an object containing array into accessors
+ *
+ * @param obj
+ * @param size
+ */
 function wrapProps(obj, size) {
-  const returnObj = {};
-  for (const key in obj) {
-    returnObj[key] = {
-      value: obj[key],
-      size
-    };
-  }
-  return returnObj;
+    const returnObj = {};
+    for (const key in obj) {
+        returnObj[key] = { value: obj[key], size };
+    }
+    return returnObj;
 }
+/**
+ * Wrap each array in an accessor object with value and size keys
+ *
+ * @param points
+ * @param lines
+ * @param polygons
+ * @param coordLength
+ * @returns object
+ */
 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)
-    }
-  };
-  if (binaryFeatures.polygons && polygons.triangles) {
-    binaryFeatures.polygons.triangles = {
-      value: new Uint32Array(polygons.triangles),
-      size: 1
+    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
     };
-  }
-  return binaryFeatures;
+    if (binaryFeatures.polygons && polygons.triangles) {
+        binaryFeatures.polygons.triangles = { value: new Uint32Array(polygons.triangles), size: 1 };
+    }
+    return binaryFeatures;
 }
+/**
+ * Add numeric properties to object
+ *
+ * @param object
+ * @param properties
+ * @param index
+ * @param length
+ */
 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);
+    for (const numericPropName in object.numericProps) {
+        if (numericPropName in properties) {
+            const value = properties[numericPropName];
+            object.numericProps[numericPropName].fill(value, index, index + length);
+        }
     }
-  }
 }
+/**
+ * Keep string properties in object
+ *
+ * @param properties
+ * @param numericKeys
+ * @returns object
+ */
 function keepStringProperties(properties, numericKeys) {
-  const props = {};
-  for (const key in properties) {
-    if (!numericKeys.includes(key)) {
-      props[key] = properties[key];
+    const props = {};
+    for (const key in properties) {
+        if (!numericKeys.includes(key)) {
+            props[key] = properties[key];
+        }
     }
-  }
-  return props;
+    return props;
 }
+/**
+ *
+ * Deduce correct array constructor to use for a given value
+ *
+ * @param x value to test
+ * @param constructor previous constructor deduced
+ * @returns PropArrayConstructor
+ */
 function deduceArrayType(x, constructor) {
-  if (constructor === Array || !Number.isFinite(x)) {
-    return Array;
-  }
-  return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;
+    if (constructor === Array || !Number.isFinite(x)) {
+        return Array;
+    }
+    // If this or previous value required 64bits use Float64Array
+    return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;
 }
-//# sourceMappingURL=flat-geojson-to-binary.js.map