@loaders.gl/gis 3.0.9 → 3.0.13

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

@@ -1,30 +1,13 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.geojsonToBinary = geojsonToBinary;
 exports.TEST_EXPORTS = void 0;
 
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-
-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 _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 geojsonToBinary(features) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var firstPassData = firstPass(features);
+function geojsonToBinary(features, options = {}) {
+  const firstPassData = firstPass(features);
   return secondPass(features, firstPassData, {
     coordLength: options.coordLength || firstPassData.coordLength,
     numericPropKeys: options.numericPropKeys || firstPassData.numericPropKeys,
@@ -32,222 +15,143 @@ function geojsonToBinary(features) {
   });
 }
 
-var TEST_EXPORTS = {
-  firstPass: firstPass,
-  secondPass: secondPass
+const TEST_EXPORTS = {
+  firstPass,
+  secondPass
 };
 exports.TEST_EXPORTS = TEST_EXPORTS;
 
 function firstPass(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 numericPropKeys = {};
-
-  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();
-          }
+  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();
+  const numericPropKeys = {};
+
+  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;
 
-          break;
+      case 'LineString':
+        lineFeaturesCount++;
+        linePositionsCount += geometry.coordinates.length;
+        linePathsCount++;
 
-        case 'LineString':
-          lineFeaturesCount++;
-          linePositionsCount += geometry.coordinates.length;
+        for (const coord of geometry.coordinates) {
+          coordLengths.add(coord.length);
+        }
+
+        break;
+
+      case 'MultiLineString':
+        lineFeaturesCount++;
+
+        for (const line of geometry.coordinates) {
+          linePositionsCount += line.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();
+          for (const coord of line) {
+            coordLengths.add(coord.length);
           }
+        }
 
-          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;
 
-          break;
+      case 'Polygon':
+        polygonFeaturesCount++;
+        polygonObjectsCount++;
+        polygonRingsCount += geometry.coordinates.length;
+        polygonPositionsCount += flatten(geometry.coordinates).length;
 
-        case 'Polygon':
-          polygonFeaturesCount++;
+        for (const coord of flatten(geometry.coordinates)) {
+          coordLengths.add(coord.length);
+        }
+
+        break;
+
+      case 'MultiPolygon':
+        polygonFeaturesCount++;
+
+        for (const polygon of geometry.coordinates) {
           polygonObjectsCount++;
-          polygonRingsCount += geometry.coordinates.length;
-          polygonPositionsCount += flatten(geometry.coordinates).length;
-
-          var _iterator6 = _createForOfIteratorHelper(flatten(geometry.coordinates)),
-              _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();
-          }
+          polygonRingsCount += polygon.length;
+          polygonPositionsCount += flatten(polygon).length;
 
-          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;
-              polygonPositionsCount += flatten(polygon).length;
-
-              var _iterator8 = _createForOfIteratorHelper(flatten(polygon)),
-                  _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();
+          for (const coord of flatten(polygon)) {
+            coordLengths.add(coord.length);
           }
+        }
 
-          break;
+        break;
 
-        default:
-          throw new Error("Unsupported geometry type: ".concat(geometry.type));
-      }
+      default:
+        throw new Error("Unsupported geometry type: ".concat(geometry.type));
+    }
 
-      if (feature.properties) {
-        for (var key in feature.properties) {
-          var val = feature.properties[key];
-          numericPropKeys[key] = numericPropKeys[key] || numericPropKeys[key] === undefined ? isNumeric(val) : numericPropKeys[key];
-        }
+    if (feature.properties) {
+      for (const key in feature.properties) {
+        const val = feature.properties[key];
+        numericPropKeys[key] = numericPropKeys[key] || numericPropKeys[key] === undefined ? isNumeric(val) : numericPropKeys[key];
       }
     }
-  } 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,
-    numericPropKeys: Object.keys(numericPropKeys).filter(function (k) {
-      return numericPropKeys[k];
-    })
+    coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,
+    pointPositionsCount,
+    pointFeaturesCount,
+    linePositionsCount,
+    linePathsCount,
+    lineFeaturesCount,
+    polygonPositionsCount,
+    polygonObjectsCount,
+    polygonRingsCount,
+    polygonFeaturesCount,
+    numericPropKeys: Object.keys(numericPropKeys).filter(k => numericPropKeys[k])
   };
 }
 
 function secondPass(features, firstPassData, options) {
-  var pointPositionsCount = firstPassData.pointPositionsCount,
-      pointFeaturesCount = firstPassData.pointFeaturesCount,
-      linePositionsCount = firstPassData.linePositionsCount,
-      linePathsCount = firstPassData.linePathsCount,
-      lineFeaturesCount = firstPassData.lineFeaturesCount,
-      polygonPositionsCount = firstPassData.polygonPositionsCount,
-      polygonObjectsCount = firstPassData.polygonObjectsCount,
-      polygonRingsCount = firstPassData.polygonRingsCount,
-      polygonFeaturesCount = firstPassData.polygonFeaturesCount;
-  var coordLength = options.coordLength,
-      numericPropKeys = options.numericPropKeys,
-      _options$PositionData = options.PositionDataType,
-      PositionDataType = _options$PositionData === void 0 ? Float32Array : _options$PositionData;
-  var GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
-  var points = {
+  const {
+    pointPositionsCount,
+    pointFeaturesCount,
+    linePositionsCount,
+    linePathsCount,
+    lineFeaturesCount,
+    polygonPositionsCount,
+    polygonObjectsCount,
+    polygonRingsCount,
+    polygonFeaturesCount
+  } = firstPassData;
+  const {
+    coordLength,
+    numericPropKeys,
+    PositionDataType = Float32Array
+  } = options;
+  const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
+  const points = {
     positions: new PositionDataType(pointPositionsCount * coordLength),
     globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
     featureIds: pointFeaturesCount > 65535 ? new Uint32Array(pointPositionsCount) : new Uint16Array(pointPositionsCount),
@@ -255,7 +159,7 @@ function secondPass(features, firstPassData, options) {
     properties: Array(),
     fields: Array()
   };
-  var lines = {
+  const lines = {
     positions: new PositionDataType(linePositionsCount * coordLength),
     pathIndices: linePositionsCount > 65535 ? new Uint32Array(linePathsCount + 1) : new Uint16Array(linePathsCount + 1),
     globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
@@ -264,7 +168,7 @@ function secondPass(features, firstPassData, options) {
     properties: Array(),
     fields: Array()
   };
-  var polygons = {
+  const polygons = {
     positions: new PositionDataType(polygonPositionsCount * coordLength),
     polygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonObjectsCount + 1) : new Uint16Array(polygonObjectsCount + 1),
     primitivePolygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonRingsCount + 1) : new Uint16Array(polygonRingsCount + 1),
@@ -275,28 +179,16 @@ function secondPass(features, firstPassData, options) {
     fields: Array()
   };
 
-  for (var _i = 0, _arr = [points, lines, polygons]; _i < _arr.length; _i++) {
-    var object = _arr[_i];
-
-    var _iterator9 = _createForOfIteratorHelper(numericPropKeys || []),
-        _step9;
-
-    try {
-      for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-        var propName = _step9.value;
-        object.numericProps[propName] = new Float32Array(object.positions.length / coordLength);
-      }
-    } catch (err) {
-      _iterator9.e(err);
-    } finally {
-      _iterator9.f();
+  for (const object of [points, lines, polygons]) {
+    for (const propName of numericPropKeys || []) {
+      object.numericProps[propName] = new Float32Array(object.positions.length / coordLength);
     }
   }
 
   lines.pathIndices[linePathsCount] = linePositionsCount;
   polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;
   polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;
-  var indexMap = {
+  const indexMap = {
     pointPosition: 0,
     pointFeature: 0,
     linePosition: 0,
@@ -309,62 +201,52 @@ function secondPass(features, firstPassData, options) {
     feature: 0
   };
 
-  var _iterator10 = _createForOfIteratorHelper(features),
-      _step10;
-
-  try {
-    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
-      var feature = _step10.value;
-      var geometry = feature.geometry;
-      var properties = feature.properties || {};
-
-      switch (geometry.type) {
-        case 'Point':
-          handlePoint(geometry.coordinates, points, indexMap, coordLength, properties);
-          points.properties.push(keepStringProperties(properties, numericPropKeys));
-          indexMap.pointFeature++;
-          break;
-
-        case 'MultiPoint':
-          handleMultiPoint(geometry.coordinates, points, indexMap, coordLength, properties);
-          points.properties.push(keepStringProperties(properties, numericPropKeys));
-          indexMap.pointFeature++;
-          break;
-
-        case 'LineString':
-          handleLineString(geometry.coordinates, lines, indexMap, coordLength, properties);
-          lines.properties.push(keepStringProperties(properties, numericPropKeys));
-          indexMap.lineFeature++;
-          break;
-
-        case 'MultiLineString':
-          handleMultiLineString(geometry.coordinates, lines, indexMap, coordLength, properties);
-          lines.properties.push(keepStringProperties(properties, numericPropKeys));
-          indexMap.lineFeature++;
-          break;
-
-        case 'Polygon':
-          handlePolygon(geometry.coordinates, polygons, indexMap, coordLength, properties);
-          polygons.properties.push(keepStringProperties(properties, numericPropKeys));
-          indexMap.polygonFeature++;
-          break;
-
-        case 'MultiPolygon':
-          handleMultiPolygon(geometry.coordinates, polygons, indexMap, coordLength, properties);
-          polygons.properties.push(keepStringProperties(properties, numericPropKeys));
-          indexMap.polygonFeature++;
-          break;
-
-        default:
-          throw new Error('Invalid geometry type');
-      }
-
-      indexMap.feature++;
+  for (const feature of features) {
+    const geometry = feature.geometry;
+    const properties = feature.properties || {};
+
+    switch (geometry.type) {
+      case 'Point':
+        handlePoint(geometry.coordinates, points, indexMap, coordLength, properties);
+        points.properties.push(keepStringProperties(properties, numericPropKeys));
+        indexMap.pointFeature++;
+        break;
+
+      case 'MultiPoint':
+        handleMultiPoint(geometry.coordinates, points, indexMap, coordLength, properties);
+        points.properties.push(keepStringProperties(properties, numericPropKeys));
+        indexMap.pointFeature++;
+        break;
+
+      case 'LineString':
+        handleLineString(geometry.coordinates, lines, indexMap, coordLength, properties);
+        lines.properties.push(keepStringProperties(properties, numericPropKeys));
+        indexMap.lineFeature++;
+        break;
+
+      case 'MultiLineString':
+        handleMultiLineString(geometry.coordinates, lines, indexMap, coordLength, properties);
+        lines.properties.push(keepStringProperties(properties, numericPropKeys));
+        indexMap.lineFeature++;
+        break;
+
+      case 'Polygon':
+        handlePolygon(geometry.coordinates, polygons, indexMap, coordLength, properties);
+        polygons.properties.push(keepStringProperties(properties, numericPropKeys));
+        indexMap.polygonFeature++;
+        break;
+
+      case 'MultiPolygon':
+        handleMultiPolygon(geometry.coordinates, polygons, indexMap, coordLength, properties);
+        polygons.properties.push(keepStringProperties(properties, numericPropKeys));
+        indexMap.polygonFeature++;
+        break;
+
+      default:
+        throw new Error('Invalid geometry type');
     }
-  } catch (err) {
-    _iterator10.e(err);
-  } finally {
-    _iterator10.f();
+
+    indexMap.feature++;
   }
 
   return makeAccessorObjects(points, lines, polygons, coordLength);
@@ -379,18 +261,8 @@ function handlePoint(coords, points, indexMap, coordLength, properties) {
 }
 
 function handleMultiPoint(coords, points, indexMap, coordLength, properties) {
-  var _iterator11 = _createForOfIteratorHelper(coords),
-      _step11;
-
-  try {
-    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
-      var point = _step11.value;
-      handlePoint(point, points, indexMap, coordLength, properties);
-    }
-  } catch (err) {
-    _iterator11.e(err);
-  } finally {
-    _iterator11.f();
+  for (const point of coords) {
+    handlePoint(point, points, indexMap, coordLength, properties);
   }
 }
 
@@ -398,7 +270,7 @@ function handleLineString(coords, lines, indexMap, coordLength, properties) {
   lines.pathIndices[indexMap.linePath] = indexMap.linePosition;
   indexMap.linePath++;
   fillCoords(lines.positions, coords, indexMap.linePosition, coordLength);
-  var nPositions = coords.length;
+  const nPositions = coords.length;
   fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
   lines.globalFeatureIds.set(new Uint32Array(nPositions).fill(indexMap.feature), indexMap.linePosition);
   lines.featureIds.set(new Uint32Array(nPositions).fill(indexMap.lineFeature), indexMap.linePosition);
@@ -406,18 +278,8 @@ function handleLineString(coords, lines, indexMap, coordLength, properties) {
 }
 
 function handleMultiLineString(coords, lines, indexMap, coordLength, properties) {
-  var _iterator12 = _createForOfIteratorHelper(coords),
-      _step12;
-
-  try {
-    for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
-      var line = _step12.value;
-      handleLineString(line, lines, indexMap, coordLength, properties);
-    }
-  } catch (err) {
-    _iterator12.e(err);
-  } finally {
-    _iterator12.f();
+  for (const line of coords) {
+    handleLineString(line, lines, indexMap, coordLength, properties);
   }
 }
 
@@ -425,47 +287,27 @@ function handlePolygon(coords, polygons, indexMap, coordLength, properties) {
   polygons.polygonIndices[indexMap.polygonObject] = indexMap.polygonPosition;
   indexMap.polygonObject++;
 
-  var _iterator13 = _createForOfIteratorHelper(coords),
-      _step13;
-
-  try {
-    for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
-      var ring = _step13.value;
-      polygons.primitivePolygonIndices[indexMap.polygonRing] = indexMap.polygonPosition;
-      indexMap.polygonRing++;
-      fillCoords(polygons.positions, ring, indexMap.polygonPosition, coordLength);
-      var nPositions = ring.length;
-      fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
-      polygons.globalFeatureIds.set(new Uint32Array(nPositions).fill(indexMap.feature), indexMap.polygonPosition);
-      polygons.featureIds.set(new Uint32Array(nPositions).fill(indexMap.polygonFeature), indexMap.polygonPosition);
-      indexMap.polygonPosition += nPositions;
-    }
-  } catch (err) {
-    _iterator13.e(err);
-  } finally {
-    _iterator13.f();
+  for (const ring of coords) {
+    polygons.primitivePolygonIndices[indexMap.polygonRing] = indexMap.polygonPosition;
+    indexMap.polygonRing++;
+    fillCoords(polygons.positions, ring, indexMap.polygonPosition, coordLength);
+    const nPositions = ring.length;
+    fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
+    polygons.globalFeatureIds.set(new Uint32Array(nPositions).fill(indexMap.feature), indexMap.polygonPosition);
+    polygons.featureIds.set(new Uint32Array(nPositions).fill(indexMap.polygonFeature), indexMap.polygonPosition);
+    indexMap.polygonPosition += nPositions;
   }
 }
 
 function handleMultiPolygon(coords, polygons, indexMap, coordLength, properties) {
-  var _iterator14 = _createForOfIteratorHelper(coords),
-      _step14;
-
-  try {
-    for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
-      var polygon = _step14.value;
-      handlePolygon(polygon, polygons, indexMap, coordLength, properties);
-    }
-  } catch (err) {
-    _iterator14.e(err);
-  } finally {
-    _iterator14.f();
+  for (const polygon of coords) {
+    handlePolygon(polygon, polygons, indexMap, coordLength, properties);
   }
 }
 
 function makeAccessorObjects(points, lines, polygons, coordLength) {
-  var returnObj = {
-    points: _objectSpread(_objectSpread({}, points), {}, {
+  const returnObj = {
+    points: { ...points,
       positions: {
         value: points.positions,
         size: coordLength
@@ -479,8 +321,8 @@ function makeAccessorObjects(points, lines, polygons, coordLength) {
         size: 1
       },
       type: 'Point'
-    }),
-    lines: _objectSpread(_objectSpread({}, lines), {}, {
+    },
+    lines: { ...lines,
       pathIndices: {
         value: lines.pathIndices,
         size: 1
@@ -498,8 +340,8 @@ function makeAccessorObjects(points, lines, polygons, coordLength) {
         size: 1
       },
       type: 'LineString'
-    }),
-    polygons: _objectSpread(_objectSpread({}, polygons), {}, {
+    },
+    polygons: { ...polygons,
       polygonIndices: {
         value: polygons.polygonIndices,
         size: 1
@@ -521,11 +363,11 @@ function makeAccessorObjects(points, lines, polygons, coordLength) {
         size: 1
       },
       type: 'Polygon'
-    })
+    }
   };
 
-  for (var geomType in returnObj) {
-    for (var numericProp in returnObj[geomType].numericProps) {
+  for (const geomType in returnObj) {
+    for (const numericProp in returnObj[geomType].numericProps) {
       returnObj[geomType].numericProps[numericProp] = {
         value: returnObj[geomType].numericProps[numericProp],
         size: 1
@@ -537,7 +379,7 @@ function makeAccessorObjects(points, lines, polygons, coordLength) {
 }
 
 function fillNumericProperties(object, properties, index, length) {
-  for (var numericPropName in object.numericProps) {
+  for (const numericPropName in object.numericProps) {
     if (numericPropName in properties) {
       object.numericProps[numericPropName].set(new Array(length).fill(properties[numericPropName]), index);
     }
@@ -545,9 +387,9 @@ function fillNumericProperties(object, properties, index, length) {
 }
 
 function keepStringProperties(properties, numericKeys) {
-  var props = {};
+  const props = {};
 
-  for (var key in properties) {
+  for (const key in properties) {
     if (!numericKeys.includes(key)) {
       props[key] = properties[key];
     }
@@ -557,28 +399,16 @@ function keepStringProperties(properties, numericKeys) {
 }
 
 function fillCoords(array, coords, startVertex, coordLength) {
-  var index = startVertex * coordLength;
-
-  var _iterator15 = _createForOfIteratorHelper(coords),
-      _step15;
+  let index = startVertex * coordLength;
 
-  try {
-    for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
-      var coord = _step15.value;
-      array.set(coord, index);
-      index += coordLength;
-    }
-  } catch (err) {
-    _iterator15.e(err);
-  } finally {
-    _iterator15.f();
+  for (const coord of coords) {
+    array.set(coord, index);
+    index += coordLength;
   }
 }
 
 function flatten(arrays) {
-  var _ref;
-
-  return (_ref = []).concat.apply(_ref, (0, _toConsumableArray2.default)(arrays));
+  return [].concat(...arrays);
 }
 
 function isNumeric(x) {