@loaders.gl/gis 3.1.0 → 3.1.4

package/dist/es5/index.js

@@ -3,12 +3,24 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "flatGeojsonToBinary", {
+  enumerable: true,
+  get: function get() {
+    return _flatGeojsonToBinary.flatGeojsonToBinary;
+  }
+});
 Object.defineProperty(exports, "geojsonToBinary", {
   enumerable: true,
   get: function get() {
     return _geojsonToBinary.geojsonToBinary;
   }
 });
+Object.defineProperty(exports, "geojsonToFlatGeojson", {
+  enumerable: true,
+  get: function get() {
+    return _geojsonToFlatGeojson.geojsonToFlatGeojson;
+  }
+});
 Object.defineProperty(exports, "binaryToGeojson", {
   enumerable: true,
   get: function get() {
@@ -40,8 +52,12 @@ Object.defineProperty(exports, "transformGeoJsonCoords", {
   }
 });
 
+var _flatGeojsonToBinary = require("./lib/flat-geojson-to-binary");
+
 var _geojsonToBinary = require("./lib/geojson-to-binary");
 
+var _geojsonToFlatGeojson = require("./lib/geojson-to-flat-geojson");
+
 var _binaryToGeojson = require("./lib/binary-to-geojson");
 
 var _transform = require("./lib/transform");

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA;;AACA;;AACA","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":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA;;AACA;;AACA;;AACA;;AACA","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/es5/lib/extract-geometry-info.js

@@ -0,0 +1,204 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractGeometryInfo = extractGeometryInfo;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function extractGeometryInfo(features) {
+  var pointPositionsCount = 0;
+  var pointFeaturesCount = 0;
+  var linePositionsCount = 0;
+  var linePathsCount = 0;
+  var lineFeaturesCount = 0;
+  var polygonPositionsCount = 0;
+  var polygonObjectsCount = 0;
+  var polygonRingsCount = 0;
+  var polygonFeaturesCount = 0;
+  var coordLengths = new Set();
+
+  var _iterator = _createForOfIteratorHelper(features),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var feature = _step.value;
+      var geometry = feature.geometry;
+
+      switch (geometry.type) {
+        case 'Point':
+          pointFeaturesCount++;
+          pointPositionsCount++;
+          coordLengths.add(geometry.coordinates.length);
+          break;
+
+        case 'MultiPoint':
+          pointFeaturesCount++;
+          pointPositionsCount += geometry.coordinates.length;
+
+          var _iterator2 = _createForOfIteratorHelper(geometry.coordinates),
+              _step2;
+
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var point = _step2.value;
+              coordLengths.add(point.length);
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+
+          break;
+
+        case 'LineString':
+          lineFeaturesCount++;
+          linePositionsCount += geometry.coordinates.length;
+          linePathsCount++;
+
+          var _iterator3 = _createForOfIteratorHelper(geometry.coordinates),
+              _step3;
+
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var coord = _step3.value;
+              coordLengths.add(coord.length);
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+
+          break;
+
+        case 'MultiLineString':
+          lineFeaturesCount++;
+
+          var _iterator4 = _createForOfIteratorHelper(geometry.coordinates),
+              _step4;
+
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var line = _step4.value;
+              linePositionsCount += line.length;
+              linePathsCount++;
+
+              var _iterator5 = _createForOfIteratorHelper(line),
+                  _step5;
+
+              try {
+                for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                  var _coord = _step5.value;
+                  coordLengths.add(_coord.length);
+                }
+              } catch (err) {
+                _iterator5.e(err);
+              } finally {
+                _iterator5.f();
+              }
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+
+          break;
+
+        case 'Polygon':
+          polygonFeaturesCount++;
+          polygonObjectsCount++;
+          polygonRingsCount += geometry.coordinates.length;
+          var flattened = geometry.coordinates.flat();
+          polygonPositionsCount += flattened.length;
+
+          var _iterator6 = _createForOfIteratorHelper(flattened),
+              _step6;
+
+          try {
+            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+              var _coord2 = _step6.value;
+              coordLengths.add(_coord2.length);
+            }
+          } catch (err) {
+            _iterator6.e(err);
+          } finally {
+            _iterator6.f();
+          }
+
+          break;
+
+        case 'MultiPolygon':
+          polygonFeaturesCount++;
+
+          var _iterator7 = _createForOfIteratorHelper(geometry.coordinates),
+              _step7;
+
+          try {
+            for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+              var polygon = _step7.value;
+              polygonObjectsCount++;
+              polygonRingsCount += polygon.length;
+
+              var _flattened = polygon.flat();
+
+              polygonPositionsCount += _flattened.length;
+
+              var _iterator8 = _createForOfIteratorHelper(_flattened),
+                  _step8;
+
+              try {
+                for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+                  var _coord3 = _step8.value;
+                  coordLengths.add(_coord3.length);
+                }
+              } catch (err) {
+                _iterator8.e(err);
+              } finally {
+                _iterator8.f();
+              }
+            }
+          } catch (err) {
+            _iterator7.e(err);
+          } finally {
+            _iterator7.f();
+          }
+
+          break;
+
+        default:
+          throw new Error("Unsupported geometry type: ".concat(geometry.type));
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return {
+    coordLength: coordLengths.size > 0 ? Math.max.apply(Math, (0, _toConsumableArray2.default)(coordLengths)) : 2,
+    pointPositionsCount: pointPositionsCount,
+    pointFeaturesCount: pointFeaturesCount,
+    linePositionsCount: linePositionsCount,
+    linePathsCount: linePathsCount,
+    lineFeaturesCount: lineFeaturesCount,
+    polygonPositionsCount: polygonPositionsCount,
+    polygonObjectsCount: polygonObjectsCount,
+    polygonRingsCount: polygonRingsCount,
+    polygonFeaturesCount: polygonFeaturesCount
+  };
+}
+//# sourceMappingURL=extract-geometry-info.js.map

package/dist/es5/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/es5/lib/flat-geojson-to-binary-types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=flat-geojson-to-binary-types.js.map

package/dist/es5/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/es5/lib/flat-geojson-to-binary.js

@@ -0,0 +1,397 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flatGeojsonToBinary = flatGeojsonToBinary;
+exports.TEST_EXPORTS = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _polygon = require("@math.gl/polygon");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function flatGeojsonToBinary(features, geometryInfo, options) {
+  var propArrayTypes = extractNumericPropTypes(features);
+  var numericPropKeys = Object.keys(propArrayTypes).filter(function (k) {
+    return propArrayTypes[k] !== Array;
+  });
+  return fillArrays(features, _objectSpread({
+    propArrayTypes: propArrayTypes
+  }, geometryInfo), {
+    numericPropKeys: options && options.numericPropKeys || numericPropKeys,
+    PositionDataType: options ? options.PositionDataType : Float32Array
+  });
+}
+
+var TEST_EXPORTS = {
+  extractNumericPropTypes: extractNumericPropTypes
+};
+exports.TEST_EXPORTS = TEST_EXPORTS;
+
+function extractNumericPropTypes(features) {
+  var propArrayTypes = {};
+
+  var _iterator = _createForOfIteratorHelper(features),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var feature = _step.value;
+
+      if (feature.properties) {
+        for (var _key in feature.properties) {
+          var val = feature.properties[_key];
+          propArrayTypes[_key] = deduceArrayType(val, propArrayTypes[_key]);
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return propArrayTypes;
+}
+
+function fillArrays(features, geometryInfo, options) {
+  var pointPositionsCount = geometryInfo.pointPositionsCount,
+      pointFeaturesCount = geometryInfo.pointFeaturesCount,
+      linePositionsCount = geometryInfo.linePositionsCount,
+      linePathsCount = geometryInfo.linePathsCount,
+      lineFeaturesCount = geometryInfo.lineFeaturesCount,
+      polygonPositionsCount = geometryInfo.polygonPositionsCount,
+      polygonObjectsCount = geometryInfo.polygonObjectsCount,
+      polygonRingsCount = geometryInfo.polygonRingsCount,
+      polygonFeaturesCount = geometryInfo.polygonFeaturesCount,
+      propArrayTypes = geometryInfo.propArrayTypes,
+      coordLength = geometryInfo.coordLength;
+  var _options$numericPropK = options.numericPropKeys,
+      numericPropKeys = _options$numericPropK === void 0 ? [] : _options$numericPropK,
+      _options$PositionData = options.PositionDataType,
+      PositionDataType = _options$PositionData === void 0 ? Float32Array : _options$PositionData;
+  var hasGlobalId = features[0] && 'id' in features[0];
+  var GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
+  var points = {
+    type: 'Point',
+    positions: new PositionDataType(pointPositionsCount * coordLength),
+    globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
+    featureIds: pointFeaturesCount > 65535 ? new Uint32Array(pointPositionsCount) : new Uint16Array(pointPositionsCount),
+    numericProps: {},
+    properties: [],
+    fields: []
+  };
+  var 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: []
+  };
+  var 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 (var _i = 0, _arr = [points, lines, polygons]; _i < _arr.length; _i++) {
+    var object = _arr[_i];
+
+    var _iterator2 = _createForOfIteratorHelper(numericPropKeys),
+        _step2;
+
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var propName = _step2.value;
+        var T = propArrayTypes[propName];
+        object.numericProps[propName] = new T(object.positions.length / coordLength);
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+
+  lines.pathIndices[linePathsCount] = linePositionsCount;
+  polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;
+  polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;
+  var indexMap = {
+    pointPosition: 0,
+    pointFeature: 0,
+    linePosition: 0,
+    linePath: 0,
+    lineFeature: 0,
+    polygonPosition: 0,
+    polygonObject: 0,
+    polygonRing: 0,
+    polygonFeature: 0,
+    feature: 0
+  };
+
+  var _iterator3 = _createForOfIteratorHelper(features),
+      _step3;
+
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var feature = _step3.value;
+      var geometry = feature.geometry;
+      var 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++;
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+
+  return makeAccessorObjects(points, lines, polygons, coordLength);
+}
+
+function handlePoint(geometry, points, indexMap, coordLength, properties) {
+  points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
+  var 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);
+  var 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 (var i = 0, il = geometry.indices.length; i < il; ++i) {
+    var start = geometry.indices[i];
+    var 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);
+  var 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 (var l = 0, ll = geometry.indices.length; l < ll; ++l) {
+    var startPosition = indexMap.polygonPosition;
+    polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
+    var areas = geometry.areas[l];
+    var indices = geometry.indices[l];
+    var nextIndices = geometry.indices[l + 1];
+
+    for (var i = 0, il = indices.length; i < il; ++i) {
+      var start = indices[i];
+      var 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;
+    }
+
+    var endPosition = indexMap.polygonPosition;
+    triangulatePolygon(polygons, areas, indices, {
+      startPosition: startPosition,
+      endPosition: endPosition,
+      coordLength: coordLength
+    });
+  }
+}
+
+function triangulatePolygon(polygons, areas, indices, _ref) {
+  var startPosition = _ref.startPosition,
+      endPosition = _ref.endPosition,
+      coordLength = _ref.coordLength;
+  var start = startPosition * coordLength;
+  var end = endPosition * coordLength;
+  var polygonPositions = polygons.positions.subarray(start, end);
+  var offset = indices[0];
+  var holes = indices.slice(1).map(function (n) {
+    return (n - offset) / coordLength;
+  });
+  var triangles = (0, _polygon.earcut)(polygonPositions, holes, coordLength, areas);
+
+  for (var t = 0, tl = triangles.length; t < tl; ++t) {
+    polygons.triangles.push(startPosition + triangles[t]);
+  }
+}
+
+function wrapProps(obj, size) {
+  var returnObj = {};
+
+  for (var _key2 in obj) {
+    returnObj[_key2] = {
+      value: obj[_key2],
+      size: size
+    };
+  }
+
+  return returnObj;
+}
+
+function makeAccessorObjects(points, lines, polygons, coordLength) {
+  return {
+    points: _objectSpread(_objectSpread({}, 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: _objectSpread(_objectSpread({}, 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: _objectSpread(_objectSpread({}, 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 (var numericPropName in object.numericProps) {
+    if (numericPropName in properties) {
+      var value = properties[numericPropName];
+      object.numericProps[numericPropName].fill(value, index, index + length);
+    }
+  }
+}
+
+function keepStringProperties(properties, numericKeys) {
+  var props = {};
+
+  for (var _key3 in properties) {
+    if (!numericKeys.includes(_key3)) {
+      props[_key3] = properties[_key3];
+    }
+  }
+
+  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