@loaders.gl/i3s 3.0.13 → 3.0.14

package/dist/es5/lib/parsers/parse-i3s-tile-content.js

@@ -1,10 +1,20 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parseI3STileContent = parseI3STileContent;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _core = require("@loaders.gl/core");
 
 var _core2 = require("@math.gl/core");
@@ -21,157 +31,270 @@ var _urlUtils = require("../utils/url-utils");
 
 var _constants = require("./constants");
 
-const scratchVector = new _core2.Vector3([0, 0, 0]);
-const FORMAT_LOADER_MAP = {
+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; }
+
+var scratchVector = new _core2.Vector3([0, 0, 0]);
+var FORMAT_LOADER_MAP = {
   jpeg: _images.ImageLoader,
   png: _images.ImageLoader,
   'ktx-etc2': _textures.CompressedTextureLoader,
   dds: _textures.CompressedTextureLoader
 };
-const I3S_ATTRIBUTE_TYPE = 'i3s-attribute-type';
-
-async function parseI3STileContent(arrayBuffer, tile, tileset, options, context) {
-  tile.content = tile.content || {};
-  tile.content.featureIds = tile.content.featureIds || null;
-  tile.content.featureData = constructFeatureDataStruct(tile, tileset);
-  tile.content.attributes = {};
-
-  if (tile.textureUrl) {
-    var _options$i3s;
-
-    const url = (0, _urlUtils.getUrlWithToken)(tile.textureUrl, options === null || options === void 0 ? void 0 : (_options$i3s = options.i3s) === null || _options$i3s === void 0 ? void 0 : _options$i3s.token);
-    const loader = FORMAT_LOADER_MAP[tile.textureFormat] || _images.ImageLoader;
-    const response = await fetch(url);
-    const arrayBuffer = await response.arrayBuffer();
-
-    if (loader === _images.ImageLoader) {
-      const options = {
-        image: {
-          type: 'data'
-        }
-      };
-      tile.content.texture = await context.parse(arrayBuffer, options);
-    } else if (loader === _textures.CompressedTextureLoader) {
-      const texture = await (0, _core.load)(arrayBuffer, _textures.CompressedTextureLoader);
-      tile.content.texture = {
-        compressed: true,
-        mipmaps: false,
-        width: texture[0].width,
-        height: texture[0].height,
-        data: texture
-      };
-    }
-  }
+var I3S_ATTRIBUTE_TYPE = 'i3s-attribute-type';
 
-  tile.content.material = makePbrMaterial(tile.materialDefinition, tile.content.texture);
-
-  if (tile.content.material) {
-    tile.content.texture = null;
-  }
-
-  return await parseI3SNodeGeometry(arrayBuffer, tile, context);
+function parseI3STileContent(_x, _x2, _x3, _x4, _x5) {
+  return _parseI3STileContent.apply(this, arguments);
 }
 
-async function parseI3SNodeGeometry(arrayBuffer, tile = {}, context) {
-  if (!tile.content) {
-    return tile;
-  }
-
-  const content = tile.content;
-  let attributes;
-  let vertexCount;
-  let byteOffset = 0;
-  let featureCount = 0;
-
-  if (tile.isDracoGeometry) {
-    const decompressedGeometry = await (0, _core.parse)(arrayBuffer, _draco.DracoLoader, {
-      draco: {
-        attributeNameEntry: I3S_ATTRIBUTE_TYPE
+function _parseI3STileContent() {
+  _parseI3STileContent = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer, tile, tileset, options, context) {
+    var _options$i3s, url, loader, response, _arrayBuffer, _options, texture;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            tile.content = tile.content || {};
+            tile.content.featureIds = tile.content.featureIds || null;
+            tile.content.featureData = constructFeatureDataStruct(tile, tileset);
+            tile.content.attributes = {};
+
+            if (!tile.textureUrl) {
+              _context.next = 25;
+              break;
+            }
+
+            url = (0, _urlUtils.getUrlWithToken)(tile.textureUrl, options === null || options === void 0 ? void 0 : (_options$i3s = options.i3s) === null || _options$i3s === void 0 ? void 0 : _options$i3s.token);
+            loader = FORMAT_LOADER_MAP[tile.textureFormat] || _images.ImageLoader;
+            _context.next = 9;
+            return fetch(url);
+
+          case 9:
+            response = _context.sent;
+            _context.next = 12;
+            return response.arrayBuffer();
+
+          case 12:
+            _arrayBuffer = _context.sent;
+
+            if (!(loader === _images.ImageLoader)) {
+              _context.next = 20;
+              break;
+            }
+
+            _options = {
+              image: {
+                type: 'data'
+              }
+            };
+            _context.next = 17;
+            return context.parse(_arrayBuffer, _options);
+
+          case 17:
+            tile.content.texture = _context.sent;
+            _context.next = 25;
+            break;
+
+          case 20:
+            if (!(loader === _textures.CompressedTextureLoader)) {
+              _context.next = 25;
+              break;
+            }
+
+            _context.next = 23;
+            return (0, _core.load)(_arrayBuffer, _textures.CompressedTextureLoader);
+
+          case 23:
+            texture = _context.sent;
+            tile.content.texture = {
+              compressed: true,
+              mipmaps: false,
+              width: texture[0].width,
+              height: texture[0].height,
+              data: texture
+            };
+
+          case 25:
+            tile.content.material = makePbrMaterial(tile.materialDefinition, tile.content.texture);
+
+            if (tile.content.material) {
+              tile.content.texture = null;
+            }
+
+            _context.next = 29;
+            return parseI3SNodeGeometry(arrayBuffer, tile, context);
+
+          case 29:
+            return _context.abrupt("return", _context.sent);
+
+          case 30:
+          case "end":
+            return _context.stop();
+        }
       }
-    });
-    vertexCount = decompressedGeometry.header.vertexCount;
-    const indices = decompressedGeometry.indices.value;
-    const {
-      POSITION,
-      NORMAL,
-      COLOR_0,
-      TEXCOORD_0,
-      ['feature-index']: featureIndex,
-      ['uv-region']: uvRegion
-    } = decompressedGeometry.attributes;
-    attributes = {
-      position: POSITION,
-      normal: NORMAL,
-      color: COLOR_0,
-      uv0: TEXCOORD_0,
-      uvRegion,
-      id: featureIndex,
-      indices
-    };
-    updateAttributesMetadata(attributes, decompressedGeometry);
-    const featureIds = getFeatureIdsFromFeatureIndexMetadata(featureIndex);
-
-    if (featureIds) {
-      flattenFeatureIdsByFeatureIndices(attributes, featureIds);
-    }
-  } else {
-    const {
-      vertexAttributes,
-      attributesOrder,
-      featureAttributes,
-      featureAttributeOrder
-    } = content.featureData;
-    const headers = parseHeaders(content, arrayBuffer);
-    byteOffset = headers.byteOffset;
-    vertexCount = headers.vertexCount;
-    featureCount = headers.featureCount;
-    const {
-      attributes: normalizedVertexAttributes,
-      byteOffset: offset
-    } = normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, vertexCount, attributesOrder);
-    const {
-      attributes: normalizedFeatureAttributes
-    } = normalizeAttributes(arrayBuffer, offset, featureAttributes, featureCount, featureAttributeOrder);
-    flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes);
-    attributes = concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes);
-  }
-
-  const {
-    enuMatrix,
-    cartographicOrigin,
-    cartesianOrigin
-  } = parsePositions(attributes.position, tile);
-  const matrix = new _core2.Matrix4().multiplyRight(enuMatrix);
-  content.attributes = {
-    positions: attributes.position,
-    normals: attributes.normal,
-    colors: normalizeAttribute(attributes.color),
-    texCoords: attributes.uv0,
-    uvRegions: normalizeAttribute(attributes.uvRegion)
-  };
-  content.indices = attributes.indices || null;
-
-  if (attributes.id && attributes.id.value) {
-    tile.content.featureIds = attributes.id.value;
-  }
+    }, _callee);
+  }));
+  return _parseI3STileContent.apply(this, arguments);
+}
 
-  for (const attributeIndex in content.attributes) {
-    if (!content.attributes[attributeIndex]) {
-      delete content.attributes[attributeIndex];
-    }
-  }
+function parseI3SNodeGeometry(_x6) {
+  return _parseI3SNodeGeometry.apply(this, arguments);
+}
 
-  content.vertexCount = vertexCount;
-  content.cartographicCenter = cartographicOrigin;
-  content.cartesianOrigin = cartesianOrigin;
-  content.modelMatrix = matrix.invert();
-  content.byteLength = arrayBuffer.byteLength;
-  return tile;
+function _parseI3SNodeGeometry() {
+  _parseI3SNodeGeometry = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(arrayBuffer) {
+    var tile,
+        context,
+        content,
+        attributes,
+        vertexCount,
+        byteOffset,
+        featureCount,
+        decompressedGeometry,
+        indices,
+        _decompressedGeometry,
+        POSITION,
+        NORMAL,
+        COLOR_0,
+        TEXCOORD_0,
+        featureIndex,
+        uvRegion,
+        featureIds,
+        _content$featureData,
+        vertexAttributes,
+        attributesOrder,
+        featureAttributes,
+        featureAttributeOrder,
+        headers,
+        _normalizeAttributes,
+        normalizedVertexAttributes,
+        offset,
+        _normalizeAttributes2,
+        normalizedFeatureAttributes,
+        _parsePositions,
+        enuMatrix,
+        cartographicOrigin,
+        cartesianOrigin,
+        matrix,
+        attributeIndex,
+        _args2 = arguments;
+
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            tile = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
+            context = _args2.length > 2 ? _args2[2] : undefined;
+
+            if (tile.content) {
+              _context2.next = 4;
+              break;
+            }
+
+            return _context2.abrupt("return", tile);
+
+          case 4:
+            content = tile.content;
+            byteOffset = 0;
+            featureCount = 0;
+
+            if (!tile.isDracoGeometry) {
+              _context2.next = 20;
+              break;
+            }
+
+            _context2.next = 10;
+            return (0, _core.parse)(arrayBuffer, _draco.DracoLoader, {
+              draco: {
+                attributeNameEntry: I3S_ATTRIBUTE_TYPE
+              }
+            });
+
+          case 10:
+            decompressedGeometry = _context2.sent;
+            vertexCount = decompressedGeometry.header.vertexCount;
+            indices = decompressedGeometry.indices.value;
+            _decompressedGeometry = decompressedGeometry.attributes, POSITION = _decompressedGeometry.POSITION, NORMAL = _decompressedGeometry.NORMAL, COLOR_0 = _decompressedGeometry.COLOR_0, TEXCOORD_0 = _decompressedGeometry.TEXCOORD_0, featureIndex = _decompressedGeometry['feature-index'], uvRegion = _decompressedGeometry['uv-region'];
+            attributes = {
+              position: POSITION,
+              normal: NORMAL,
+              color: COLOR_0,
+              uv0: TEXCOORD_0,
+              uvRegion: uvRegion,
+              id: featureIndex,
+              indices: indices
+            };
+            updateAttributesMetadata(attributes, decompressedGeometry);
+            featureIds = getFeatureIdsFromFeatureIndexMetadata(featureIndex);
+
+            if (featureIds) {
+              flattenFeatureIdsByFeatureIndices(attributes, featureIds);
+            }
+
+            _context2.next = 29;
+            break;
+
+          case 20:
+            _content$featureData = content.featureData, vertexAttributes = _content$featureData.vertexAttributes, attributesOrder = _content$featureData.attributesOrder, featureAttributes = _content$featureData.featureAttributes, featureAttributeOrder = _content$featureData.featureAttributeOrder;
+            headers = parseHeaders(content, arrayBuffer);
+            byteOffset = headers.byteOffset;
+            vertexCount = headers.vertexCount;
+            featureCount = headers.featureCount;
+            _normalizeAttributes = normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, vertexCount, attributesOrder), normalizedVertexAttributes = _normalizeAttributes.attributes, offset = _normalizeAttributes.byteOffset;
+            _normalizeAttributes2 = normalizeAttributes(arrayBuffer, offset, featureAttributes, featureCount, featureAttributeOrder), normalizedFeatureAttributes = _normalizeAttributes2.attributes;
+            flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes);
+            attributes = concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes);
+
+          case 29:
+            _parsePositions = parsePositions(attributes.position, tile), enuMatrix = _parsePositions.enuMatrix, cartographicOrigin = _parsePositions.cartographicOrigin, cartesianOrigin = _parsePositions.cartesianOrigin;
+            matrix = new _core2.Matrix4().multiplyRight(enuMatrix);
+            content.attributes = {
+              positions: attributes.position,
+              normals: attributes.normal,
+              colors: normalizeAttribute(attributes.color),
+              texCoords: attributes.uv0,
+              uvRegions: normalizeAttribute(attributes.uvRegion)
+            };
+            content.indices = attributes.indices || null;
+
+            if (attributes.id && attributes.id.value) {
+              tile.content.featureIds = attributes.id.value;
+            }
+
+            for (attributeIndex in content.attributes) {
+              if (!content.attributes[attributeIndex]) {
+                delete content.attributes[attributeIndex];
+              }
+            }
+
+            content.vertexCount = vertexCount;
+            content.cartographicCenter = cartographicOrigin;
+            content.cartesianOrigin = cartesianOrigin;
+            content.modelMatrix = matrix.invert();
+            content.byteLength = arrayBuffer.byteLength;
+            return _context2.abrupt("return", tile);
+
+          case 41:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _parseI3SNodeGeometry.apply(this, arguments);
 }
 
 function updateAttributesMetadata(attributes, decompressedGeometry) {
-  for (const key in decompressedGeometry.loaderData.attributes) {
-    const dracoAttribute = decompressedGeometry.loaderData.attributes[key];
+  for (var key in decompressedGeometry.loaderData.attributes) {
+    var dracoAttribute = decompressedGeometry.loaderData.attributes[key];
 
     switch (dracoAttribute.name) {
       case 'POSITION':
@@ -189,9 +312,7 @@ function updateAttributesMetadata(attributes, decompressedGeometry) {
 }
 
 function concatAttributes(normalizedVertexAttributes, normalizedFeatureAttributes) {
-  return { ...normalizedVertexAttributes,
-    ...normalizedFeatureAttributes
-  };
+  return _objectSpread(_objectSpread({}, normalizedVertexAttributes), normalizedFeatureAttributes);
 }
 
 function normalizeAttribute(attribute) {
@@ -204,25 +325,25 @@ function normalizeAttribute(attribute) {
 }
 
 function constructFeatureDataStruct(tile, tileset) {
-  const defaultGeometrySchema = tileset.store.defaultGeometrySchema;
-  const featureData = defaultGeometrySchema;
+  var defaultGeometrySchema = tileset.store.defaultGeometrySchema;
+  var featureData = defaultGeometrySchema;
 
-  for (const geometryAttribute in _constants.I3S_NAMED_GEOMETRY_ATTRIBUTES) {
-    for (const namedAttribute in _constants.I3S_NAMED_VERTEX_ATTRIBUTES) {
-      const attribute = defaultGeometrySchema[geometryAttribute][namedAttribute];
+  for (var geometryAttribute in _constants.I3S_NAMED_GEOMETRY_ATTRIBUTES) {
+    for (var namedAttribute in _constants.I3S_NAMED_VERTEX_ATTRIBUTES) {
+      var attribute = defaultGeometrySchema[geometryAttribute][namedAttribute];
 
       if (attribute) {
-        const {
-          byteOffset = 0,
-          count = 0,
-          valueType,
-          valuesPerElement
-        } = attribute;
+        var _attribute$byteOffset = attribute.byteOffset,
+            byteOffset = _attribute$byteOffset === void 0 ? 0 : _attribute$byteOffset,
+            _attribute$count = attribute.count,
+            count = _attribute$count === void 0 ? 0 : _attribute$count,
+            valueType = attribute.valueType,
+            valuesPerElement = attribute.valuesPerElement;
         featureData[geometryAttribute][namedAttribute] = {
-          valueType,
-          valuesPerElement,
-          byteOffset,
-          count
+          valueType: valueType,
+          valuesPerElement: valuesPerElement,
+          byteOffset: byteOffset,
+          count: count
         };
       }
     }
@@ -233,17 +354,16 @@ function constructFeatureDataStruct(tile, tileset) {
 }
 
 function parseHeaders(content, buffer) {
-  let byteOffset = 0;
-  let vertexCount = 0;
-  let featureCount = 0;
-  const headers = content.featureData[_constants.I3S_NAMED_HEADER_ATTRIBUTES.header];
-
-  for (const header in headers) {
-    const {
-      property,
-      type
-    } = headers[header];
-    const TypedArrayTypeHeader = _constants.TYPE_ARRAY_MAP[type];
+  var byteOffset = 0;
+  var vertexCount = 0;
+  var featureCount = 0;
+  var headers = content.featureData[_constants.I3S_NAMED_HEADER_ATTRIBUTES.header];
+
+  for (var header in headers) {
+    var _headers$header = headers[header],
+        property = _headers$header.property,
+        type = _headers$header.type;
+    var TypedArrayTypeHeader = _constants.TYPE_ARRAY_MAP[type];
 
     if (property === _constants.I3S_NAMED_HEADER_ATTRIBUTES.vertexCount) {
       vertexCount = new TypedArrayTypeHeader(buffer, 0, 4)[0];
@@ -257,73 +377,83 @@ function parseHeaders(content, buffer) {
   }
 
   return {
-    vertexCount,
-    featureCount,
-    byteOffset
+    vertexCount: vertexCount,
+    featureCount: featureCount,
+    byteOffset: byteOffset
   };
 }
 
 function normalizeAttributes(arrayBuffer, byteOffset, vertexAttributes, vertexCount, attributesOrder) {
-  const attributes = {};
+  var attributes = {};
 
-  for (const attribute of attributesOrder) {
-    if (vertexAttributes[attribute]) {
-      const {
-        valueType,
-        valuesPerElement
-      } = vertexAttributes[attribute];
-      const count = vertexCount;
+  var _iterator = _createForOfIteratorHelper(attributesOrder),
+      _step;
 
-      if (byteOffset + count * valuesPerElement > arrayBuffer.byteLength) {
-        break;
-      }
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var attribute = _step.value;
 
-      const buffer = arrayBuffer.slice(byteOffset);
-      let value = [];
+      if (vertexAttributes[attribute]) {
+        var _vertexAttributes$att = vertexAttributes[attribute],
+            valueType = _vertexAttributes$att.valueType,
+            valuesPerElement = _vertexAttributes$att.valuesPerElement;
+        var count = vertexCount;
 
-      if (valueType === 'UInt64') {
-        value = parseUint64Values(buffer, count * valuesPerElement, _constants.SIZEOF[valueType]);
-      } else {
-        const TypedArrayType = _constants.TYPE_ARRAY_MAP[valueType];
-        value = new TypedArrayType(buffer, 0, count * valuesPerElement);
-      }
+        if (byteOffset + count * valuesPerElement > arrayBuffer.byteLength) {
+          break;
+        }
 
-      attributes[attribute] = {
-        value,
-        type: _constants.GL_TYPE_MAP[valueType],
-        size: valuesPerElement
-      };
+        var buffer = arrayBuffer.slice(byteOffset);
+        var value = [];
 
-      switch (attribute) {
-        case 'color':
-          attributes.color.normalized = true;
-          break;
+        if (valueType === 'UInt64') {
+          value = parseUint64Values(buffer, count * valuesPerElement, _constants.SIZEOF[valueType]);
+        } else {
+          var TypedArrayType = _constants.TYPE_ARRAY_MAP[valueType];
+          value = new TypedArrayType(buffer, 0, count * valuesPerElement);
+        }
 
-        case 'position':
-        case 'region':
-        case 'normal':
-        default:
-      }
+        attributes[attribute] = {
+          value: value,
+          type: _constants.GL_TYPE_MAP[valueType],
+          size: valuesPerElement
+        };
 
-      byteOffset = byteOffset + count * valuesPerElement * _constants.SIZEOF[valueType];
+        switch (attribute) {
+          case 'color':
+            attributes.color.normalized = true;
+            break;
+
+          case 'position':
+          case 'region':
+          case 'normal':
+          default:
+        }
+
+        byteOffset = byteOffset + count * valuesPerElement * _constants.SIZEOF[valueType];
+      }
     }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
 
   return {
-    attributes,
-    byteOffset
+    attributes: attributes,
+    byteOffset: byteOffset
   };
 }
 
 function parseUint64Values(buffer, elementsCount, attributeSize) {
-  const values = [];
-  const dataView = new DataView(buffer);
-  let offset = 0;
-
-  for (let index = 0; index < elementsCount; index++) {
-    const left = dataView.getUint32(offset, true);
-    const right = dataView.getUint32(offset + 4, true);
-    const value = left + 2 ** 32 * right;
+  var values = [];
+  var dataView = new DataView(buffer);
+  var offset = 0;
+
+  for (var index = 0; index < elementsCount; index++) {
+    var left = dataView.getUint32(offset, true);
+    var right = dataView.getUint32(offset + 4, true);
+    var value = left + Math.pow(2, 32) * right;
     values.push(value);
     offset += attributeSize;
   }
@@ -332,12 +462,12 @@ function parseUint64Values(buffer, elementsCount, attributeSize) {
 }
 
 function parsePositions(attribute, tile) {
-  const mbs = tile.mbs;
-  const value = attribute.value;
-  const metadata = attribute.metadata;
-  const enuMatrix = new _core2.Matrix4();
-  const cartographicOrigin = new _core2.Vector3(mbs[0], mbs[1], mbs[2]);
-  const cartesianOrigin = new _core2.Vector3();
+  var mbs = tile.mbs;
+  var value = attribute.value;
+  var metadata = attribute.metadata;
+  var enuMatrix = new _core2.Matrix4();
+  var cartographicOrigin = new _core2.Vector3(mbs[0], mbs[1], mbs[2]);
+  var cartesianOrigin = new _core2.Vector3();
 
   _geospatial.Ellipsoid.WGS84.cartographicToCartesian(cartographicOrigin, cartesianOrigin);
 
@@ -345,45 +475,46 @@ function parsePositions(attribute, tile) {
 
   attribute.value = offsetsToCartesians(value, metadata, cartographicOrigin);
   return {
-    enuMatrix,
+    enuMatrix: enuMatrix,
     fixedFrameToENUMatrix: enuMatrix.invert(),
-    cartographicOrigin,
-    cartesianOrigin
+    cartographicOrigin: cartographicOrigin,
+    cartesianOrigin: cartesianOrigin
   };
 }
 
-function offsetsToCartesians(vertices, metadata = {}, cartographicOrigin) {
-  const positions = new Float64Array(vertices.length);
-  const scaleX = metadata['i3s-scale_x'] && metadata['i3s-scale_x'].double || 1;
-  const scaleY = metadata['i3s-scale_y'] && metadata['i3s-scale_y'].double || 1;
+function offsetsToCartesians(vertices) {
+  var metadata = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var cartographicOrigin = arguments.length > 2 ? arguments[2] : undefined;
+  var positions = new Float64Array(vertices.length);
+  var scaleX = metadata['i3s-scale_x'] && metadata['i3s-scale_x'].double || 1;
+  var scaleY = metadata['i3s-scale_y'] && metadata['i3s-scale_y'].double || 1;
 
-  for (let i = 0; i < positions.length; i += 3) {
+  for (var i = 0; i < positions.length; i += 3) {
     positions[i] = vertices[i] * scaleX + cartographicOrigin.x;
     positions[i + 1] = vertices[i + 1] * scaleY + cartographicOrigin.y;
     positions[i + 2] = vertices[i + 2] + cartographicOrigin.z;
   }
 
-  for (let i = 0; i < positions.length; i += 3) {
-    _geospatial.Ellipsoid.WGS84.cartographicToCartesian(positions.subarray(i, i + 3), scratchVector);
+  for (var _i = 0; _i < positions.length; _i += 3) {
+    _geospatial.Ellipsoid.WGS84.cartographicToCartesian(positions.subarray(_i, _i + 3), scratchVector);
 
-    positions[i] = scratchVector.x;
-    positions[i + 1] = scratchVector.y;
-    positions[i + 2] = scratchVector.z;
+    positions[_i] = scratchVector.x;
+    positions[_i + 1] = scratchVector.y;
+    positions[_i + 2] = scratchVector.z;
   }
 
   return positions;
 }
 
 function makePbrMaterial(materialDefinition, texture) {
-  let pbrMaterial;
+  var pbrMaterial;
 
   if (materialDefinition) {
-    pbrMaterial = { ...materialDefinition,
-      pbrMetallicRoughness: materialDefinition.pbrMetallicRoughness ? { ...materialDefinition.pbrMetallicRoughness
-      } : {
+    pbrMaterial = _objectSpread(_objectSpread({}, materialDefinition), {}, {
+      pbrMetallicRoughness: materialDefinition.pbrMetallicRoughness ? _objectSpread({}, materialDefinition.pbrMetallicRoughness) : {
         baseColorFactor: [255, 255, 255, 255]
       }
-    };
+    });
   } else {
     pbrMaterial = {
       pbrMetallicRoughness: {}
@@ -417,9 +548,9 @@ function makePbrMaterial(materialDefinition, texture) {
 }
 
 function convertColorFormat(colorFactor) {
-  const normalizedColor = [...colorFactor];
+  var normalizedColor = (0, _toConsumableArray2.default)(colorFactor);
 
-  for (let index = 0; index < colorFactor.length; index++) {
+  for (var index = 0; index < colorFactor.length; index++) {
     normalizedColor[index] = colorFactor[index] / 255;
   }
 
@@ -427,58 +558,56 @@ function convertColorFormat(colorFactor) {
 }
 
 function setMaterialTexture(material, image) {
-  const texture = {
+  var texture = {
     source: {
-      image
+      image: image
     }
   };
 
   if (material.pbrMetallicRoughness && material.pbrMetallicRoughness.baseColorTexture) {
-    material.pbrMetallicRoughness.baseColorTexture = { ...material.pbrMetallicRoughness.baseColorTexture,
-      texture
-    };
+    material.pbrMetallicRoughness.baseColorTexture = _objectSpread(_objectSpread({}, material.pbrMetallicRoughness.baseColorTexture), {}, {
+      texture: texture
+    });
   } else if (material.emissiveTexture) {
-    material.emissiveTexture = { ...material.emissiveTexture,
-      texture
-    };
+    material.emissiveTexture = _objectSpread(_objectSpread({}, material.emissiveTexture), {}, {
+      texture: texture
+    });
   } else if (material.pbrMetallicRoughness && material.pbrMetallicRoughness.metallicRoughnessTexture) {
-    material.pbrMetallicRoughness.metallicRoughnessTexture = { ...material.pbrMetallicRoughness.metallicRoughnessTexture,
-      texture
-    };
+    material.pbrMetallicRoughness.metallicRoughnessTexture = _objectSpread(_objectSpread({}, material.pbrMetallicRoughness.metallicRoughnessTexture), {}, {
+      texture: texture
+    });
   } else if (material.normalTexture) {
-    material.normalTexture = { ...material.normalTexture,
-      texture
-    };
+    material.normalTexture = _objectSpread(_objectSpread({}, material.normalTexture), {}, {
+      texture: texture
+    });
   } else if (material.occlusionTexture) {
-    material.occlusionTexture = { ...material.occlusionTexture,
-      texture
-    };
+    material.occlusionTexture = _objectSpread(_objectSpread({}, material.occlusionTexture), {}, {
+      texture: texture
+    });
   }
 }
 
 function flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes) {
-  const {
-    id,
-    faceRange
-  } = normalizedFeatureAttributes;
+  var id = normalizedFeatureAttributes.id,
+      faceRange = normalizedFeatureAttributes.faceRange;
 
   if (!id || !faceRange) {
     return;
   }
 
-  const featureIds = id.value;
-  const range = faceRange.value;
-  const featureIdsLength = range[range.length - 1] + 1;
-  const orderedFeatureIndices = new Uint32Array(featureIdsLength * 3);
-  let featureIndex = 0;
-  let startIndex = 0;
-
-  for (let index = 1; index < range.length; index += 2) {
-    const fillId = Number(featureIds[featureIndex]);
-    const endValue = range[index];
-    const prevValue = range[index - 1];
-    const trianglesCount = endValue - prevValue + 1;
-    const endIndex = startIndex + trianglesCount * 3;
+  var featureIds = id.value;
+  var range = faceRange.value;
+  var featureIdsLength = range[range.length - 1] + 1;
+  var orderedFeatureIndices = new Uint32Array(featureIdsLength * 3);
+  var featureIndex = 0;
+  var startIndex = 0;
+
+  for (var index = 1; index < range.length; index += 2) {
+    var fillId = Number(featureIds[featureIndex]);
+    var endValue = range[index];
+    var prevValue = range[index - 1];
+    var trianglesCount = endValue - prevValue + 1;
+    var endIndex = startIndex + trianglesCount * 3;
     orderedFeatureIndices.fill(fillId, startIndex, endIndex);
     featureIndex++;
     startIndex = endIndex;
@@ -488,10 +617,10 @@ function flattenFeatureIdsByFaceRanges(normalizedFeatureAttributes) {
 }
 
 function flattenFeatureIdsByFeatureIndices(attributes, featureIds) {
-  const featureIndices = attributes.id.value;
-  const result = new Float32Array(featureIndices.length);
+  var featureIndices = attributes.id.value;
+  var result = new Float32Array(featureIndices.length);
 
-  for (let index = 0; index < featureIndices.length; index++) {
+  for (var index = 0; index < featureIndices.length; index++) {
     result[index] = featureIds[featureIndices[index]];
   }