@loaders.gl/tile-converter 3.0.13 → 3.0.14

package/dist/es5/i3s-converter/i3s-converter.js

@@ -7,6 +7,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _core = require("@loaders.gl/core");
@@ -51,18 +65,30 @@ var _sharedResources = require("./json-templates/shared-resources");
 
 var _nodeDebug = require("./helpers/node-debug");
 
-const ION_DEFAULT_TOKEN = _process.default.env.IonToken || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ';
-const HARDCODED_NODES_PER_PAGE = 64;
-const _3D_TILES = '3DTILES';
-const _3D_OBJECT_LAYER_TYPE = '3DObject';
-const STRING_TYPE = 'string';
-const SHORT_INT_TYPE = 'Int32';
-const DOUBLE_TYPE = 'double';
-const OBJECT_ID_TYPE = 'OBJECTID';
-const REFRESH_TOKEN_TIMEOUT = 1800;
-
-class I3SConverter {
-  constructor() {
+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 ION_DEFAULT_TOKEN = _process.default.env.IonToken || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ';
+var HARDCODED_NODES_PER_PAGE = 64;
+var _3D_TILES = '3DTILES';
+var _3D_OBJECT_LAYER_TYPE = '3DObject';
+var STRING_TYPE = 'string';
+var SHORT_INT_TYPE = 'Int32';
+var DOUBLE_TYPE = 'double';
+var OBJECT_ID_TYPE = 'OBJECTID';
+var REFRESH_TOKEN_TIMEOUT = 1800;
+var CESIUM_DATASET_PREFIX = 'https://';
+
+var I3SConverter = function () {
+  function I3SConverter() {
+    (0, _classCallCheck2.default)(this, I3SConverter);
     (0, _defineProperty2.default)(this, "nodePages", void 0);
     (0, _defineProperty2.default)(this, "fileMap", void 0);
     (0, _defineProperty2.default)(this, "options", void 0);
@@ -79,6 +105,7 @@ class I3SConverter {
     (0, _defineProperty2.default)(this, "refreshTokenTime", void 0);
     (0, _defineProperty2.default)(this, "sourceTileset", void 0);
     (0, _defineProperty2.default)(this, "geoidHeightModel", void 0);
+    (0, _defineProperty2.default)(this, "Loader", _dTiles.Tiles3DLoader);
     this.nodePages = new _nodePages.default(_fileUtils.writeFile, HARDCODED_NODES_PER_PAGE);
     this.fileMap = {};
     this.options = {};
@@ -96,801 +123,1604 @@ class I3SConverter {
     this.boundingVolumeWarnings = null;
   }
 
-  async convert(options) {
-    this.conversionStartTime = _process.default.hrtime();
-    const {
-      tilesetName,
-      slpk,
-      egmFilePath,
-      inputUrl,
-      validate,
-      outputPath,
-      draco,
-      sevenZipExe,
-      maxDepth,
-      token
-    } = options;
-    this.options = {
-      maxDepth,
-      slpk,
-      sevenZipExe,
-      egmFilePath,
-      draco,
-      token,
-      inputUrl
-    };
-    this.validate = validate;
-    console.log('Loading egm file...');
-    this.geoidHeightModel = await (0, _core.load)(egmFilePath, _pgmLoader.PGMLoader);
-    console.log('Loading egm file completed!');
+  (0, _createClass2.default)(I3SConverter, [{
+    key: "convert",
+    value: function () {
+      var _convert = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(options) {
+        var tilesetName, slpk, egmFilePath, inputUrl, validate, outputPath, draco, sevenZipExe, maxDepth, token, preloadOptions, tilesetOptions, sourceTilesetJson;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                this.conversionStartTime = _process.default.hrtime();
+                tilesetName = options.tilesetName, slpk = options.slpk, egmFilePath = options.egmFilePath, inputUrl = options.inputUrl, validate = options.validate, outputPath = options.outputPath, draco = options.draco, sevenZipExe = options.sevenZipExe, maxDepth = options.maxDepth, token = options.token;
+                this.options = {
+                  maxDepth: maxDepth,
+                  slpk: slpk,
+                  sevenZipExe: sevenZipExe,
+                  egmFilePath: egmFilePath,
+                  draco: draco,
+                  token: token,
+                  inputUrl: inputUrl
+                };
+                this.validate = validate;
+                this.Loader = inputUrl.indexOf(CESIUM_DATASET_PREFIX) !== -1 ? _dTiles.CesiumIonLoader : _dTiles.Tiles3DLoader;
+                console.log('Loading egm file...');
+                _context.next = 8;
+                return (0, _core.load)(egmFilePath, _pgmLoader.PGMLoader);
+
+              case 8:
+                this.geoidHeightModel = _context.sent;
+                console.log('Loading egm file completed!');
+
+                if (slpk) {
+                  this.nodePages.useWriteFunction(_fileUtils.writeFileForSlpk);
+                }
+
+                _context.next = 13;
+                return this._fetchPreloadOptions();
+
+              case 13:
+                preloadOptions = _context.sent;
+                tilesetOptions = {
+                  loadOptions: {}
+                };
+
+                if (preloadOptions.headers) {
+                  tilesetOptions.loadOptions.fetch = {
+                    headers: preloadOptions.headers
+                  };
+                }
+
+                Object.assign(tilesetOptions, preloadOptions);
+                _context.next = 19;
+                return (0, _core.load)(inputUrl, this.Loader, tilesetOptions.loadOptions);
+
+              case 19:
+                sourceTilesetJson = _context.sent;
+                this.sourceTileset = new _tiles.Tileset3D(sourceTilesetJson, tilesetOptions);
+                _context.next = 23;
+                return this._createAndSaveTileset(outputPath, tilesetName);
+
+              case 23:
+                _context.next = 25;
+                return this._finishConversion({
+                  slpk: slpk,
+                  outputPath: outputPath,
+                  tilesetName: tilesetName
+                });
+
+              case 25:
+                return _context.abrupt("return", sourceTilesetJson);
+
+              case 26:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
 
-    if (slpk) {
-      this.nodePages.useWriteFunction(_fileUtils.writeFileForSlpk);
-    }
+      function convert(_x) {
+        return _convert.apply(this, arguments);
+      }
 
-    const preloadOptions = await this._fetchPreloadOptions();
-    const tilesetOptions = {
-      loadOptions: {}
-    };
+      return convert;
+    }()
+  }, {
+    key: "_createAndSaveTileset",
+    value: function () {
+      var _createAndSaveTileset2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(outputPath, tilesetName) {
+        var tilesetPath, sourceRootTile, boundingVolumes, parentId, isCreateSlpk, root0;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                tilesetPath = (0, _path.join)("".concat(outputPath), "".concat(tilesetName));
+                _context2.prev = 1;
+                _context2.next = 4;
+                return (0, _fileUtils.removeDir)(tilesetPath);
+
+              case 4:
+                _context2.next = 8;
+                break;
+
+              case 6:
+                _context2.prev = 6;
+                _context2.t0 = _context2["catch"](1);
+
+              case 8:
+                this.layers0Path = (0, _path.join)(tilesetPath, 'SceneServer', 'layers', '0');
+
+                this._formLayers0(tilesetName);
+
+                this.materialDefinitions = [];
+                this.materialMap = new Map();
+                sourceRootTile = this.sourceTileset.root;
+                boundingVolumes = (0, _coordinateConverter.createBoundingVolumes)(sourceRootTile, this.geoidHeightModel);
+                parentId = this.nodePages.push({
+                  lodThreshold: 0,
+                  obb: boundingVolumes.obb,
+                  children: []
+                });
+                isCreateSlpk = this.options.slpk;
+                root0 = this._formRootNodeIndexDocument(boundingVolumes);
+                _context2.next = 19;
+                return this._convertNodesTree(root0, sourceRootTile, parentId, boundingVolumes);
+
+              case 19:
+                this.layers0.materialDefinitions = this.materialDefinitions;
+                _context2.next = 22;
+                return this._writeLayers0();
+
+              case 22:
+                (0, _createSceneServerPath.createSceneServerPath)(tilesetName, this.layers0, tilesetPath);
+                _context2.next = 25;
+                return this._writeNodeIndexDocument(root0, 'root', (0, _path.join)(this.layers0Path, 'nodes', 'root'));
+
+              case 25:
+                _context2.next = 27;
+                return this.nodePages.save(this.layers0Path, this.fileMap, isCreateSlpk);
+
+              case 27:
+                _context2.next = 29;
+                return this._createSlpk(tilesetPath);
+
+              case 29:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this, [[1, 6]]);
+      }));
+
+      function _createAndSaveTileset(_x2, _x3) {
+        return _createAndSaveTileset2.apply(this, arguments);
+      }
 
-    if (preloadOptions.headers) {
-      tilesetOptions.loadOptions.fetch = {
-        headers: preloadOptions.headers
+      return _createAndSaveTileset;
+    }()
+  }, {
+    key: "_formLayers0",
+    value: function _formLayers0(tilesetName) {
+      var extent = (0, _coordinateConverter.convertCommonToI3SExtentCoordinate)(this.sourceTileset);
+      var layers0data = {
+        version: "{".concat((0, _uuid.v4)().toUpperCase(), "}"),
+        id: 0,
+        name: tilesetName,
+        href: './layers/0',
+        store: {
+          id: "{".concat((0, _uuid.v4)().toUpperCase(), "}"),
+          extent: extent
+        },
+        nodePages: {
+          nodesPerPage: HARDCODED_NODES_PER_PAGE
+        },
+        compressGeometry: this.options.draco
       };
+      this.layers0 = (0, _jsonMapTransform.default)(layers0data, _layers.LAYERS);
     }
+  }, {
+    key: "_formRootNodeIndexDocument",
+    value: function _formRootNodeIndexDocument(boundingVolumes) {
+      var root0data = _objectSpread(_objectSpread({
+        version: "{".concat((0, _uuid.v4)().toUpperCase(), "}"),
+        id: 'root',
+        level: 0,
+        lodSelection: [{
+          metricType: 'maxScreenThresholdSQ',
+          maxError: 0
+        }, {
+          metricType: 'maxScreenThreshold',
+          maxError: 0
+        }]
+      }, boundingVolumes), {}, {
+        children: []
+      });
 
-    Object.assign(tilesetOptions, preloadOptions);
-    const sourceTilesetJson = await (0, _core.load)(inputUrl, _dTiles.CesiumIonLoader, tilesetOptions.loadOptions);
-    this.sourceTileset = new _tiles.Tileset3D(sourceTilesetJson, tilesetOptions);
-    await this._createAndSaveTileset(outputPath, tilesetName);
-    await this._finishConversion({
-      slpk,
-      outputPath,
-      tilesetName
-    });
-    return sourceTilesetJson;
-  }
+      return (0, _jsonMapTransform.default)(root0data, _node.NODE);
+    }
+  }, {
+    key: "_convertNodesTree",
+    value: function () {
+      var _convertNodesTree2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(root0, sourceRootTile, parentId, boundingVolumes) {
+        var _yield$this$_createNo, _yield$this$_createNo2, child, childPath;
+
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 2;
+                return this.sourceTileset._loadTile(sourceRootTile);
+
+              case 2:
+                if (!(sourceRootTile.content && sourceRootTile.content.type === 'b3dm')) {
+                  _context3.next = 20;
+                  break;
+                }
+
+                root0.children.push(_objectSpread({
+                  id: '1',
+                  href: './1'
+                }, boundingVolumes));
+                _context3.next = 6;
+                return this._createNode(root0, sourceRootTile, parentId, 0);
+
+              case 6:
+                _yield$this$_createNo = _context3.sent;
+                _yield$this$_createNo2 = (0, _slicedToArray2.default)(_yield$this$_createNo, 1);
+                child = _yield$this$_createNo2[0];
+                childPath = (0, _path.join)(this.layers0Path, 'nodes', child.path);
+
+                if (!this.options.slpk) {
+                  _context3.next = 16;
+                  break;
+                }
+
+                _context3.next = 13;
+                return (0, _fileUtils.writeFileForSlpk)(childPath, JSON.stringify(child), '3dNodeIndexDocument.json');
+
+              case 13:
+                this.fileMap['nodes/1/3dNodeIndexDocument.json.gz'] = _context3.sent;
+                _context3.next = 18;
+                break;
+
+              case 16:
+                _context3.next = 18;
+                return (0, _fileUtils.writeFile)(childPath, JSON.stringify(child));
+
+              case 18:
+                _context3.next = 22;
+                break;
+
+              case 20:
+                _context3.next = 22;
+                return this._addChildrenWithNeighborsAndWriteFile({
+                  parentNode: root0,
+                  sourceTiles: sourceRootTile.children,
+                  parentId: parentId,
+                  level: 1
+                });
+
+              case 22:
+                _context3.next = 24;
+                return sourceRootTile.unloadContent();
+
+              case 24:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
 
-  async _createAndSaveTileset(outputPath, tilesetName) {
-    const tilesetPath = (0, _path.join)("".concat(outputPath), "".concat(tilesetName));
+      function _convertNodesTree(_x4, _x5, _x6, _x7) {
+        return _convertNodesTree2.apply(this, arguments);
+      }
 
-    try {
-      await (0, _fileUtils.removeDir)(tilesetPath);
-    } catch (e) {}
+      return _convertNodesTree;
+    }()
+  }, {
+    key: "_writeLayers0",
+    value: function () {
+      var _writeLayers = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee4() {
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                if (!this.options.slpk) {
+                  _context4.next = 6;
+                  break;
+                }
+
+                _context4.next = 3;
+                return (0, _fileUtils.writeFileForSlpk)(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json');
+
+              case 3:
+                this.fileMap['3dSceneLayer.json.gz'] = _context4.sent;
+                _context4.next = 8;
+                break;
+
+              case 6:
+                _context4.next = 8;
+                return (0, _fileUtils.writeFile)(this.layers0Path, JSON.stringify(this.layers0));
+
+              case 8:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
 
-    this.layers0Path = (0, _path.join)(tilesetPath, 'SceneServer', 'layers', '0');
+      function _writeLayers0() {
+        return _writeLayers.apply(this, arguments);
+      }
 
-    this._formLayers0(tilesetName);
+      return _writeLayers0;
+    }()
+  }, {
+    key: "_writeNodeIndexDocument",
+    value: function () {
+      var _writeNodeIndexDocument2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee5(root0, nodePath, rootPath) {
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                if (!this.options.slpk) {
+                  _context5.next = 6;
+                  break;
+                }
+
+                _context5.next = 3;
+                return (0, _fileUtils.writeFileForSlpk)(rootPath, JSON.stringify(root0), '3dNodeIndexDocument.json');
+
+              case 3:
+                this.fileMap["nodes/".concat(nodePath, "/3dNodeIndexDocument.json.gz")] = _context5.sent;
+                _context5.next = 8;
+                break;
+
+              case 6:
+                _context5.next = 8;
+                return (0, _fileUtils.writeFile)(rootPath, JSON.stringify(root0));
+
+              case 8:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
 
-    this.materialDefinitions = [];
-    this.materialMap = new Map();
-    const sourceRootTile = this.sourceTileset.root;
-    const boundingVolumes = (0, _coordinateConverter.createBoundingVolumes)(sourceRootTile, this.geoidHeightModel);
-    const parentId = this.nodePages.push({
-      lodThreshold: 0,
-      obb: boundingVolumes.obb,
-      children: []
-    });
-    const isCreateSlpk = this.options.slpk;
-
-    const root0 = this._formRootNodeIndexDocument(boundingVolumes);
-
-    await this._convertNodesTree(root0, sourceRootTile, parentId, boundingVolumes);
-    this.layers0.materialDefinitions = this.materialDefinitions;
-    await this._writeLayers0();
-    (0, _createSceneServerPath.createSceneServerPath)(tilesetName, this.layers0, tilesetPath);
-    await this._writeNodeIndexDocument(root0, 'root', (0, _path.join)(this.layers0Path, 'nodes', 'root'));
-    await this.nodePages.save(this.layers0Path, this.fileMap, isCreateSlpk);
-    await this._createSlpk(tilesetPath);
-  }
+      function _writeNodeIndexDocument(_x8, _x9, _x10) {
+        return _writeNodeIndexDocument2.apply(this, arguments);
+      }
 
-  _formLayers0(tilesetName) {
-    const extent = (0, _coordinateConverter.convertCommonToI3SExtentCoordinate)(this.sourceTileset);
-    const layers0data = {
-      version: "{".concat((0, _uuid.v4)().toUpperCase(), "}"),
-      id: 0,
-      name: tilesetName,
-      href: './layers/0',
-      store: {
-        id: "{".concat((0, _uuid.v4)().toUpperCase(), "}"),
-        extent
-      },
-      nodePages: {
-        nodesPerPage: HARDCODED_NODES_PER_PAGE
-      },
-      compressGeometry: this.options.draco
-    };
-    this.layers0 = (0, _jsonMapTransform.default)(layers0data, _layers.LAYERS);
-  }
+      return _writeNodeIndexDocument;
+    }()
+  }, {
+    key: "_createSlpk",
+    value: function () {
+      var _createSlpk2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee6(tilesetPath) {
+        var slpkTilesetPath, slpkFileName;
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                if (!this.options.slpk) {
+                  _context6.next = 12;
+                  break;
+                }
+
+                slpkTilesetPath = (0, _path.join)(tilesetPath, 'SceneServer', 'layers', '0');
+                slpkFileName = "".concat(tilesetPath, ".slpk");
+                _context6.next = 5;
+                return (0, _compressUtil.compressWithChildProcess)(slpkTilesetPath, slpkFileName, 0, '.', this.options.sevenZipExe);
+
+              case 5:
+                _context6.prev = 5;
+                _context6.next = 8;
+                return (0, _fileUtils.removeDir)(tilesetPath);
+
+              case 8:
+                _context6.next = 12;
+                break;
+
+              case 10:
+                _context6.prev = 10;
+                _context6.t0 = _context6["catch"](5);
+
+              case 12:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6, this, [[5, 10]]);
+      }));
 
-  _formRootNodeIndexDocument(boundingVolumes) {
-    const root0data = {
-      version: "{".concat((0, _uuid.v4)().toUpperCase(), "}"),
-      id: 'root',
-      level: 0,
-      lodSelection: [{
-        metricType: 'maxScreenThresholdSQ',
-        maxError: 0
-      }, {
-        metricType: 'maxScreenThreshold',
-        maxError: 0
-      }],
-      ...boundingVolumes,
-      children: []
-    };
-    return (0, _jsonMapTransform.default)(root0data, _node.NODE);
-  }
+      function _createSlpk(_x11) {
+        return _createSlpk2.apply(this, arguments);
+      }
 
-  async _convertNodesTree(root0, sourceRootTile, parentId, boundingVolumes) {
-    await this.sourceTileset._loadTile(sourceRootTile);
+      return _createSlpk;
+    }()
+  }, {
+    key: "_addChildrenWithNeighborsAndWriteFile",
+    value: function () {
+      var _addChildrenWithNeighborsAndWriteFile2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee7(data) {
+        var childNodes;
+        return _regenerator.default.wrap(function _callee7$(_context7) {
+          while (1) {
+            switch (_context7.prev = _context7.next) {
+              case 0:
+                childNodes = [];
+                _context7.next = 3;
+                return this._addChildren(_objectSpread(_objectSpread({}, data), {}, {
+                  childNodes: childNodes
+                }));
+
+              case 3:
+                _context7.next = 5;
+                return this._addNeighborsAndWriteFile(data.parentNode, childNodes);
+
+              case 5:
+              case "end":
+                return _context7.stop();
+            }
+          }
+        }, _callee7, this);
+      }));
 
-    if (sourceRootTile.content && sourceRootTile.content.type === 'b3dm') {
-      root0.children.push({
-        id: '1',
-        href: './1',
-        ...boundingVolumes
-      });
-      const [child] = await this._createNode(root0, sourceRootTile, parentId, 0);
-      const childPath = (0, _path.join)(this.layers0Path, 'nodes', child.path);
-
-      if (this.options.slpk) {
-        this.fileMap['nodes/1/3dNodeIndexDocument.json.gz'] = await (0, _fileUtils.writeFileForSlpk)(childPath, JSON.stringify(child), '3dNodeIndexDocument.json');
-      } else {
-        await (0, _fileUtils.writeFile)(childPath, JSON.stringify(child));
-      }
-    } else {
-      await this._addChildrenWithNeighborsAndWriteFile({
-        parentNode: root0,
-        sourceTiles: sourceRootTile.children,
-        parentId,
-        level: 1
-      });
-    }
+      function _addChildrenWithNeighborsAndWriteFile(_x12) {
+        return _addChildrenWithNeighborsAndWriteFile2.apply(this, arguments);
+      }
 
-    await sourceRootTile.unloadContent();
-  }
+      return _addChildrenWithNeighborsAndWriteFile;
+    }()
+  }, {
+    key: "_addChildren",
+    value: function () {
+      var _addChildren2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee8(data) {
+        var childNodes, sourceTiles, parentNode, parentId, level, _iterator, _step, sourceTile, boundingVolumes, children, _iterator2, _step2, child;
+
+        return _regenerator.default.wrap(function _callee8$(_context8) {
+          while (1) {
+            switch (_context8.prev = _context8.next) {
+              case 0:
+                childNodes = data.childNodes, sourceTiles = data.sourceTiles, parentNode = data.parentNode, parentId = data.parentId, level = data.level;
+
+                if (!(this.options.maxDepth && level > this.options.maxDepth)) {
+                  _context8.next = 3;
+                  break;
+                }
+
+                return _context8.abrupt("return");
+
+              case 3:
+                _iterator = _createForOfIteratorHelper(sourceTiles);
+                _context8.prev = 4;
+
+                _iterator.s();
+
+              case 6:
+                if ((_step = _iterator.n()).done) {
+                  _context8.next = 26;
+                  break;
+                }
+
+                sourceTile = _step.value;
+
+                if (!(sourceTile.type === 'json')) {
+                  _context8.next = 17;
+                  break;
+                }
+
+                _context8.next = 11;
+                return this.sourceTileset._loadTile(sourceTile);
+
+              case 11:
+                _context8.next = 13;
+                return this._addChildren({
+                  parentNode: parentNode,
+                  sourceTiles: sourceTile.children,
+                  childNodes: childNodes,
+                  parentId: parentId,
+                  level: level + 1
+                });
+
+              case 13:
+                _context8.next = 15;
+                return sourceTile.unloadContent();
+
+              case 15:
+                _context8.next = 23;
+                break;
+
+              case 17:
+                boundingVolumes = (0, _coordinateConverter.createBoundingVolumes)(sourceTile, this.geoidHeightModel);
+                _context8.next = 20;
+                return this._createNode(parentNode, sourceTile, parentId, level);
+
+              case 20:
+                children = _context8.sent;
+                _iterator2 = _createForOfIteratorHelper(children);
+
+                try {
+                  for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                    child = _step2.value;
+                    parentNode.children.push(_objectSpread({
+                      id: child.id,
+                      href: "../".concat(child.path)
+                    }, boundingVolumes));
+                    childNodes.push(child);
+                  }
+                } catch (err) {
+                  _iterator2.e(err);
+                } finally {
+                  _iterator2.f();
+                }
+
+              case 23:
+                if (sourceTile.id) {
+                  console.log(sourceTile.id);
+                }
+
+              case 24:
+                _context8.next = 6;
+                break;
+
+              case 26:
+                _context8.next = 31;
+                break;
+
+              case 28:
+                _context8.prev = 28;
+                _context8.t0 = _context8["catch"](4);
+
+                _iterator.e(_context8.t0);
+
+              case 31:
+                _context8.prev = 31;
+
+                _iterator.f();
+
+                return _context8.finish(31);
+
+              case 34:
+              case "end":
+                return _context8.stop();
+            }
+          }
+        }, _callee8, this, [[4, 28, 31, 34]]);
+      }));
 
-  async _writeLayers0() {
-    if (this.options.slpk) {
-      this.fileMap['3dSceneLayer.json.gz'] = await (0, _fileUtils.writeFileForSlpk)(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json');
-    } else {
-      await (0, _fileUtils.writeFile)(this.layers0Path, JSON.stringify(this.layers0));
-    }
-  }
+      function _addChildren(_x13) {
+        return _addChildren2.apply(this, arguments);
+      }
 
-  async _writeNodeIndexDocument(root0, nodePath, rootPath) {
-    if (this.options.slpk) {
-      this.fileMap["nodes/".concat(nodePath, "/3dNodeIndexDocument.json.gz")] = await (0, _fileUtils.writeFileForSlpk)(rootPath, JSON.stringify(root0), '3dNodeIndexDocument.json');
-    } else {
-      await (0, _fileUtils.writeFile)(rootPath, JSON.stringify(root0));
-    }
-  }
+      return _addChildren;
+    }()
+  }, {
+    key: "_addNeighborsAndWriteFile",
+    value: function () {
+      var _addNeighborsAndWriteFile2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee9(parentNode, childNodes) {
+        var _iterator3, _step3, node, childPath, nodePath, _iterator4, _step4, neighbor;
 
-  async _createSlpk(tilesetPath) {
-    if (this.options.slpk) {
-      const slpkTilesetPath = (0, _path.join)(tilesetPath, 'SceneServer', 'layers', '0');
-      const slpkFileName = "".concat(tilesetPath, ".slpk");
-      await (0, _compressUtil.compressWithChildProcess)(slpkTilesetPath, slpkFileName, 0, '.', this.options.sevenZipExe);
+        return _regenerator.default.wrap(function _callee9$(_context9) {
+          while (1) {
+            switch (_context9.prev = _context9.next) {
+              case 0:
+                _iterator3 = _createForOfIteratorHelper(childNodes);
+                _context9.prev = 1;
 
-      try {
-        await (0, _fileUtils.removeDir)(tilesetPath);
-      } catch (e) {}
-    }
-  }
+                _iterator3.s();
 
-  async _addChildrenWithNeighborsAndWriteFile(data) {
-    const childNodes = [];
-    await this._addChildren({ ...data,
-      childNodes
-    });
-    await this._addNeighborsAndWriteFile(data.parentNode, childNodes);
-  }
+              case 3:
+                if ((_step3 = _iterator3.n()).done) {
+                  _context9.next = 36;
+                  break;
+                }
 
-  async _addChildren(data) {
-    const {
-      childNodes,
-      sourceTiles,
-      parentNode,
-      parentId,
-      level
-    } = data;
-
-    if (this.options.maxDepth && level > this.options.maxDepth) {
-      return;
-    }
+                node = _step3.value;
+                childPath = (0, _path.join)(this.layers0Path, 'nodes', node.path);
+                nodePath = node.path;
+                delete node.path;
 
-    for (const sourceTile of sourceTiles) {
-      if (sourceTile.type === 'json') {
-        await this.sourceTileset._loadTile(sourceTile);
-        await this._addChildren({
-          parentNode,
-          sourceTiles: sourceTile.children,
-          childNodes,
-          parentId,
-          level: level + 1
-        });
-        await sourceTile.unloadContent();
-      } else {
-        const boundingVolumes = (0, _coordinateConverter.createBoundingVolumes)(sourceTile, this.geoidHeightModel);
-        const children = await this._createNode(parentNode, sourceTile, parentId, level);
-
-        for (const child of children) {
-          parentNode.children.push({
-            id: child.id,
-            href: "../".concat(child.path),
-            ...boundingVolumes
-          });
-          childNodes.push(child);
-        }
-      }
+                if (!(parentNode.children.length < 1000)) {
+                  _context9.next = 29;
+                  break;
+                }
 
-      if (sourceTile.id) {
-        console.log(sourceTile.id);
-      }
-    }
-  }
+                _iterator4 = _createForOfIteratorHelper(parentNode.children);
+                _context9.prev = 10;
 
-  async _addNeighborsAndWriteFile(parentNode, childNodes) {
-    for (const node of childNodes) {
-      const childPath = (0, _path.join)(this.layers0Path, 'nodes', node.path);
-      const nodePath = node.path;
-      delete node.path;
+                _iterator4.s();
 
-      if (parentNode.children.length < 1000) {
-        for (const neighbor of parentNode.children) {
-          if (node.id === neighbor.id) {
-            continue;
-          }
+              case 12:
+                if ((_step4 = _iterator4.n()).done) {
+                  _context9.next = 19;
+                  break;
+                }
 
-          node.neighbors.push({ ...neighbor
-          });
-        }
-      } else {
-        console.warn("Node ".concat(node.id, ": neighbors attribute is omited because of large number of neigbors"));
-        delete node.neighbors;
-      }
+                neighbor = _step4.value;
 
-      await this._writeNodeIndexDocument(node, nodePath, childPath);
-      node.neighbors = [];
-    }
-  }
+                if (!(node.id === neighbor.id)) {
+                  _context9.next = 16;
+                  break;
+                }
 
-  async _createNode(parentTile, sourceTile, parentId, level) {
-    var _sourceTile$content;
+                return _context9.abrupt("continue", 17);
 
-    if (this.validate) {
-      this._checkAddRefinementTypeForTile(sourceTile);
-    }
+              case 16:
+                node.neighbors.push(_objectSpread({}, neighbor));
 
-    await this._updateTilesetOptions();
-    await this.sourceTileset._loadTile(sourceTile);
-    const boundingVolumes = (0, _coordinateConverter.createBoundingVolumes)(sourceTile, this.geoidHeightModel);
-    const lodSelection = (0, _lodConversionUtils.convertGeometricErrorToScreenThreshold)(sourceTile, boundingVolumes);
-    const maxScreenThresholdSQ = lodSelection.find(val => val.metricType === 'maxScreenThresholdSQ') || {
-      maxError: 0
-    };
-    const batchTable = sourceTile === null || sourceTile === void 0 ? void 0 : (_sourceTile$content = sourceTile.content) === null || _sourceTile$content === void 0 ? void 0 : _sourceTile$content.batchTableJson;
+              case 17:
+                _context9.next = 12;
+                break;
 
-    if (batchTable) {
-      this._convertAttributeStorageInfo(sourceTile.content);
-    }
+              case 19:
+                _context9.next = 24;
+                break;
 
-    const resourcesData = await this._convertResources(sourceTile);
-    const nodes = [];
-    const emptyResources = {
-      geometry: null,
-      compressedGeometry: null,
-      texture: null,
-      sharedResources: null,
-      meshMaterial: null,
-      vertexCount: null,
-      attributes: null,
-      featureCount: null
-    };
+              case 21:
+                _context9.prev = 21;
+                _context9.t0 = _context9["catch"](10);
 
-    for (const resources of resourcesData || [emptyResources]) {
-      const nodeInPage = this._createNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources);
+                _iterator4.e(_context9.t0);
 
-      const node = this._createNodeIndexDocument(parentTile, boundingVolumes, lodSelection, nodeInPage, resources);
+              case 24:
+                _context9.prev = 24;
 
-      if (nodeInPage.mesh) {
-        await this._writeResources(resources, node.path);
-      }
+                _iterator4.f();
 
-      if (this.validate) {
-        this.boundingVolumeWarnings = (0, _nodeDebug.validateNodeBoundingVolumes)(node);
+                return _context9.finish(24);
 
-        if (this.boundingVolumeWarnings && this.boundingVolumeWarnings.length) {
-          console.warn('Bounding Volume Warnings: ', ...this.boundingVolumeWarnings);
-        }
-      }
+              case 27:
+                _context9.next = 31;
+                break;
 
-      nodes.push(node);
-    }
+              case 29:
+                console.warn("Node ".concat(node.id, ": neighbors attribute is omited because of large number of neigbors"));
+                delete node.neighbors;
 
-    sourceTile.unloadContent();
-    const firstNode = nodes[0];
-    await this._addChildrenWithNeighborsAndWriteFile({
-      parentNode: firstNode,
-      sourceTiles: sourceTile.children,
-      parentId: firstNode.id,
-      level: level + 1
-    });
-    return nodes;
-  }
+              case 31:
+                _context9.next = 33;
+                return this._writeNodeIndexDocument(node, nodePath, childPath);
 
-  _convertAttributeStorageInfo(sourceTileContent) {
-    const batchTable = sourceTileContent && sourceTileContent.batchTableJson;
+              case 33:
+                node.neighbors = [];
 
-    if (batchTable && !this.layers0.attributeStorageInfo.length) {
-      this._convertBatchTableInfoToNodeAttributes(batchTable);
-    }
-  }
+              case 34:
+                _context9.next = 3;
+                break;
 
-  async _convertResources(sourceTile) {
-    if (!sourceTile.content || sourceTile.content.type !== 'b3dm') {
-      return null;
-    }
+              case 36:
+                _context9.next = 41;
+                break;
 
-    const resourcesData = await (0, _geometryConverter.default)(sourceTile.content, Number(this.nodePages.nodesCounter), this.featuresHashArray, this.layers0.attributeStorageInfo, this.options.draco);
-    return resourcesData;
-  }
+              case 38:
+                _context9.prev = 38;
+                _context9.t1 = _context9["catch"](1);
 
-  _createNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
-    const {
-      meshMaterial,
-      texture,
-      vertexCount,
-      featureCount
-    } = resources;
-    const nodeInPage = {
-      lodThreshold: maxScreenThresholdSQ.maxError,
-      obb: boundingVolumes.obb,
-      children: [],
-      mesh: null
-    };
+                _iterator3.e(_context9.t1);
 
-    if (sourceTile.content && sourceTile.content.type === 'b3dm') {
-      nodeInPage.mesh = {
-        geometry: {
-          definition: texture ? 0 : 1
-        },
-        attribute: {}
-      };
-    }
+              case 41:
+                _context9.prev = 41;
 
-    const nodeId = this.nodePages.push(nodeInPage, parentId);
+                _iterator3.f();
 
-    if (meshMaterial) {
-      this.nodePages.updateMaterialByNodeId(nodeId, this._findOrCreateMaterial(meshMaterial));
-    }
+                return _context9.finish(41);
 
-    if (texture) {
-      const texelCountHint = texture.image.height * texture.image.width;
-      this.nodePages.updateTexelCountHintByNodeId(nodeId, texelCountHint);
-    }
+              case 44:
+              case "end":
+                return _context9.stop();
+            }
+          }
+        }, _callee9, this, [[1, 38, 41, 44], [10, 21, 24, 27]]);
+      }));
 
-    if (vertexCount) {
-      this.vertexCounter += vertexCount;
-      this.nodePages.updateVertexCountByNodeId(nodeId, vertexCount);
-    }
+      function _addNeighborsAndWriteFile(_x14, _x15) {
+        return _addNeighborsAndWriteFile2.apply(this, arguments);
+      }
+
+      return _addNeighborsAndWriteFile;
+    }()
+  }, {
+    key: "_createNode",
+    value: function () {
+      var _createNode2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee10(parentTile, sourceTile, parentId, level) {
+        var _sourceTile$content;
+
+        var boundingVolumes, lodSelection, maxScreenThresholdSQ, batchTable, resourcesData, nodes, emptyResources, _iterator5, _step5, resources, nodeInPage, node, _console, firstNode;
+
+        return _regenerator.default.wrap(function _callee10$(_context10) {
+          while (1) {
+            switch (_context10.prev = _context10.next) {
+              case 0:
+                if (this.validate) {
+                  this._checkAddRefinementTypeForTile(sourceTile);
+                }
+
+                _context10.next = 3;
+                return this._updateTilesetOptions();
+
+              case 3:
+                _context10.next = 5;
+                return this.sourceTileset._loadTile(sourceTile);
+
+              case 5:
+                boundingVolumes = (0, _coordinateConverter.createBoundingVolumes)(sourceTile, this.geoidHeightModel);
+                lodSelection = (0, _lodConversionUtils.convertGeometricErrorToScreenThreshold)(sourceTile, boundingVolumes);
+                maxScreenThresholdSQ = lodSelection.find(function (val) {
+                  return val.metricType === 'maxScreenThresholdSQ';
+                }) || {
+                  maxError: 0
+                };
+                batchTable = sourceTile === null || sourceTile === void 0 ? void 0 : (_sourceTile$content = sourceTile.content) === null || _sourceTile$content === void 0 ? void 0 : _sourceTile$content.batchTableJson;
+
+                if (batchTable) {
+                  this._convertAttributeStorageInfo(sourceTile.content);
+                }
+
+                _context10.next = 12;
+                return this._convertResources(sourceTile);
+
+              case 12:
+                resourcesData = _context10.sent;
+                nodes = [];
+                emptyResources = {
+                  geometry: null,
+                  compressedGeometry: null,
+                  texture: null,
+                  sharedResources: null,
+                  meshMaterial: null,
+                  vertexCount: null,
+                  attributes: null,
+                  featureCount: null
+                };
+                _iterator5 = _createForOfIteratorHelper(resourcesData || [emptyResources]);
+                _context10.prev = 16;
+
+                _iterator5.s();
+
+              case 18:
+                if ((_step5 = _iterator5.n()).done) {
+                  _context10.next = 29;
+                  break;
+                }
+
+                resources = _step5.value;
+                nodeInPage = this._createNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources);
+                node = this._createNodeIndexDocument(parentTile, boundingVolumes, lodSelection, nodeInPage, resources);
+
+                if (!nodeInPage.mesh) {
+                  _context10.next = 25;
+                  break;
+                }
+
+                _context10.next = 25;
+                return this._writeResources(resources, node.path);
+
+              case 25:
+                if (this.validate) {
+                  this.boundingVolumeWarnings = (0, _nodeDebug.validateNodeBoundingVolumes)(node);
+
+                  if (this.boundingVolumeWarnings && this.boundingVolumeWarnings.length) {
+                    (_console = console).warn.apply(_console, ['Bounding Volume Warnings: '].concat((0, _toConsumableArray2.default)(this.boundingVolumeWarnings)));
+                  }
+                }
+
+                nodes.push(node);
+
+              case 27:
+                _context10.next = 18;
+                break;
+
+              case 29:
+                _context10.next = 34;
+                break;
+
+              case 31:
+                _context10.prev = 31;
+                _context10.t0 = _context10["catch"](16);
+
+                _iterator5.e(_context10.t0);
+
+              case 34:
+                _context10.prev = 34;
+
+                _iterator5.f();
+
+                return _context10.finish(34);
+
+              case 37:
+                sourceTile.unloadContent();
+                firstNode = nodes[0];
+                _context10.next = 41;
+                return this._addChildrenWithNeighborsAndWriteFile({
+                  parentNode: firstNode,
+                  sourceTiles: sourceTile.children,
+                  parentId: firstNode.id,
+                  level: level + 1
+                });
+
+              case 41:
+                return _context10.abrupt("return", nodes);
+
+              case 42:
+              case "end":
+                return _context10.stop();
+            }
+          }
+        }, _callee10, this, [[16, 31, 34, 37]]);
+      }));
+
+      function _createNode(_x16, _x17, _x18, _x19) {
+        return _createNode2.apply(this, arguments);
+      }
 
-    this.nodePages.updateNodeAttributeByNodeId(nodeId);
+      return _createNode;
+    }()
+  }, {
+    key: "_convertAttributeStorageInfo",
+    value: function _convertAttributeStorageInfo(sourceTileContent) {
+      var batchTable = sourceTileContent && sourceTileContent.batchTableJson;
 
-    if (featureCount) {
-      this.nodePages.updateFeatureCountByNodeId(nodeId, featureCount);
+      if (batchTable && !this.layers0.attributeStorageInfo.length) {
+        this._convertBatchTableInfoToNodeAttributes(batchTable);
+      }
     }
+  }, {
+    key: "_convertResources",
+    value: function () {
+      var _convertResources2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee11(sourceTile) {
+        var resourcesData;
+        return _regenerator.default.wrap(function _callee11$(_context11) {
+          while (1) {
+            switch (_context11.prev = _context11.next) {
+              case 0:
+                if (!(!sourceTile.content || sourceTile.content.type !== 'b3dm')) {
+                  _context11.next = 2;
+                  break;
+                }
+
+                return _context11.abrupt("return", null);
+
+              case 2:
+                _context11.next = 4;
+                return (0, _geometryConverter.default)(sourceTile.content, Number(this.nodePages.nodesCounter), this.featuresHashArray, this.layers0.attributeStorageInfo, this.options.draco);
+
+              case 4:
+                resourcesData = _context11.sent;
+                return _context11.abrupt("return", resourcesData);
+
+              case 6:
+              case "end":
+                return _context11.stop();
+            }
+          }
+        }, _callee11, this);
+      }));
 
-    return nodeInPage;
-  }
+      function _convertResources(_x20) {
+        return _convertResources2.apply(this, arguments);
+      }
 
-  _createNodeIndexDocument(parentNode, boundingVolumes, lodSelection, nodeInPage, resources) {
-    const {
-      texture,
-      attributes
-    } = resources;
-    const nodeId = nodeInPage.index;
-    const nodeData = {
-      version: parentNode.version,
-      id: nodeId.toString(),
-      path: nodeId.toString(),
-      level: parentNode.level + 1,
-      ...boundingVolumes,
-      lodSelection,
-      parentNode: {
-        id: parentNode.id,
-        href: "../".concat(parentNode.id),
-        mbs: parentNode.mbs,
-        obb: parentNode.obb
-      },
-      children: [],
-      neighbors: []
-    };
-    const node = (0, _jsonMapTransform.default)(nodeData, _node.NODE);
-
-    if (nodeInPage.mesh) {
-      node.geometryData = [{
-        href: './geometries/0'
-      }];
-      node.sharedResource = {
-        href: './shared'
+      return _convertResources;
+    }()
+  }, {
+    key: "_createNodeInNodePages",
+    value: function _createNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
+      var meshMaterial = resources.meshMaterial,
+          texture = resources.texture,
+          vertexCount = resources.vertexCount,
+          featureCount = resources.featureCount;
+      var nodeInPage = {
+        lodThreshold: maxScreenThresholdSQ.maxError,
+        obb: boundingVolumes.obb,
+        children: [],
+        mesh: null
       };
 
-      if (texture) {
-        node.textureData = [{
-          href: './textures/0'
-        }];
+      if (sourceTile.content && sourceTile.content.type === 'b3dm') {
+        nodeInPage.mesh = {
+          geometry: {
+            definition: texture ? 0 : 1
+          },
+          attribute: {}
+        };
       }
 
-      if (attributes && attributes.length && this.layers0.attributeStorageInfo && this.layers0.attributeStorageInfo.length) {
-        node.attributeData = [];
+      var nodeId = this.nodePages.push(nodeInPage, parentId);
 
-        for (let index = 0; index < attributes.length; index++) {
-          const folderName = this.layers0.attributeStorageInfo[index].key;
-          node.attributeData.push({
-            href: "./attributes/".concat(folderName, "/0")
-          });
-        }
+      if (meshMaterial) {
+        this.nodePages.updateMaterialByNodeId(nodeId, this._findOrCreateMaterial(meshMaterial));
       }
-    }
 
-    return node;
-  }
+      if (texture) {
+        var texelCountHint = texture.image.height * texture.image.width;
+        this.nodePages.updateTexelCountHintByNodeId(nodeId, texelCountHint);
+      }
 
-  async _writeResources(resources, nodePath) {
-    const {
-      geometry: geometryBuffer,
-      compressedGeometry,
-      texture,
-      sharedResources,
-      attributes
-    } = resources;
-    const childPath = (0, _path.join)(this.layers0Path, 'nodes', nodePath);
-    const slpkChildPath = (0, _path.join)('nodes', nodePath);
-    await this._writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath);
-    await this._writeShared(sharedResources, childPath, slpkChildPath, nodePath);
-    await this._writeTexture(texture, childPath, slpkChildPath);
-    await this._writeAttributes(attributes, childPath, slpkChildPath);
-  }
+      if (vertexCount) {
+        this.vertexCounter += vertexCount;
+        this.nodePages.updateVertexCountByNodeId(nodeId, vertexCount);
+      }
 
-  async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath) {
-    if (this.options.slpk) {
-      const slpkGeometryPath = (0, _path.join)(childPath, 'geometries');
-      this.fileMap["".concat(slpkChildPath, "/geometries/0.bin.gz")] = await (0, _fileUtils.writeFileForSlpk)(slpkGeometryPath, geometryBuffer, '0.bin');
-    } else {
-      const geometryPath = (0, _path.join)(childPath, 'geometries/0/');
-      await (0, _fileUtils.writeFile)(geometryPath, geometryBuffer, 'index.bin');
-    }
+      this.nodePages.updateNodeAttributeByNodeId(nodeId);
 
-    if (this.options.draco) {
-      if (this.options.slpk) {
-        const slpkCompressedGeometryPath = (0, _path.join)(childPath, 'geometries');
-        this.fileMap["".concat(slpkChildPath, "/geometries/1.bin.gz")] = await (0, _fileUtils.writeFileForSlpk)(slpkCompressedGeometryPath, compressedGeometry, '1.bin');
-      } else {
-        const compressedGeometryPath = (0, _path.join)(childPath, 'geometries/1/');
-        await (0, _fileUtils.writeFile)(compressedGeometryPath, compressedGeometry, 'index.bin');
+      if (featureCount) {
+        this.nodePages.updateFeatureCountByNodeId(nodeId, featureCount);
       }
-    }
-  }
 
-  async _writeShared(sharedResources, childPath, slpkChildPath, nodePath) {
-    sharedResources.nodePath = nodePath;
-    const sharedData = (0, _jsonMapTransform.default)(sharedResources, _sharedResources.SHARED_RESOURCES_TEMPLATE);
-    const sharedDataStr = JSON.stringify(sharedData);
-
-    if (this.options.slpk) {
-      const slpkSharedPath = (0, _path.join)(childPath, 'shared');
-      this.fileMap["".concat(slpkChildPath, "/shared/sharedResource.json.gz")] = await (0, _fileUtils.writeFileForSlpk)(slpkSharedPath, sharedDataStr, 'sharedResource.json');
-    } else {
-      const sharedPath = (0, _path.join)(childPath, 'shared/');
-      await (0, _fileUtils.writeFile)(sharedPath, sharedDataStr);
+      return nodeInPage;
     }
-  }
+  }, {
+    key: "_createNodeIndexDocument",
+    value: function _createNodeIndexDocument(parentNode, boundingVolumes, lodSelection, nodeInPage, resources) {
+      var texture = resources.texture,
+          attributes = resources.attributes;
+      var nodeId = nodeInPage.index;
+
+      var nodeData = _objectSpread(_objectSpread({
+        version: parentNode.version,
+        id: nodeId.toString(),
+        path: nodeId.toString(),
+        level: parentNode.level + 1
+      }, boundingVolumes), {}, {
+        lodSelection: lodSelection,
+        parentNode: {
+          id: parentNode.id,
+          href: "../".concat(parentNode.id),
+          mbs: parentNode.mbs,
+          obb: parentNode.obb
+        },
+        children: [],
+        neighbors: []
+      });
 
-  async _writeTexture(texture, childPath, slpkChildPath) {
-    if (texture) {
-      const format = this._getFormatByMimeType(texture.mimeType);
+      var node = (0, _jsonMapTransform.default)(nodeData, _node.NODE);
 
-      if (!this.layers0.textureSetDefinitions.length) {
-        this.layers0.textureSetDefinitions.push({
-          formats: [{
-            name: '0',
-            format
-          }]
-        });
-      }
+      if (nodeInPage.mesh) {
+        node.geometryData = [{
+          href: './geometries/0'
+        }];
+        node.sharedResource = {
+          href: './shared'
+        };
+
+        if (texture) {
+          node.textureData = [{
+            href: './textures/0'
+          }];
+        }
 
-      const textureData = texture.bufferView.data;
+        if (attributes && attributes.length && this.layers0.attributeStorageInfo && this.layers0.attributeStorageInfo.length) {
+          node.attributeData = [];
 
-      if (this.options.slpk) {
-        const slpkTexturePath = (0, _path.join)(childPath, 'textures');
-        const compress = false;
-        this.fileMap["".concat(slpkChildPath, "/textures/0.").concat(format)] = await (0, _fileUtils.writeFileForSlpk)(slpkTexturePath, textureData, "0.".concat(format), compress);
-      } else {
-        const texturePath = (0, _path.join)(childPath, 'textures/0/');
-        await (0, _fileUtils.writeFile)(texturePath, textureData, "index.".concat(format));
+          for (var index = 0; index < attributes.length; index++) {
+            var folderName = this.layers0.attributeStorageInfo[index].key;
+            node.attributeData.push({
+              href: "./attributes/".concat(folderName, "/0")
+            });
+          }
+        }
       }
+
+      return node;
     }
-  }
+  }, {
+    key: "_writeResources",
+    value: function () {
+      var _writeResources2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee12(resources, nodePath) {
+        var geometryBuffer, compressedGeometry, texture, sharedResources, attributes, childPath, slpkChildPath;
+        return _regenerator.default.wrap(function _callee12$(_context12) {
+          while (1) {
+            switch (_context12.prev = _context12.next) {
+              case 0:
+                geometryBuffer = resources.geometry, compressedGeometry = resources.compressedGeometry, texture = resources.texture, sharedResources = resources.sharedResources, attributes = resources.attributes;
+                childPath = (0, _path.join)(this.layers0Path, 'nodes', nodePath);
+                slpkChildPath = (0, _path.join)('nodes', nodePath);
+                _context12.next = 5;
+                return this._writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath);
+
+              case 5:
+                _context12.next = 7;
+                return this._writeShared(sharedResources, childPath, slpkChildPath, nodePath);
+
+              case 7:
+                _context12.next = 9;
+                return this._writeTexture(texture, childPath, slpkChildPath);
+
+              case 9:
+                _context12.next = 11;
+                return this._writeAttributes(attributes, childPath, slpkChildPath);
+
+              case 11:
+              case "end":
+                return _context12.stop();
+            }
+          }
+        }, _callee12, this);
+      }));
 
-  async _writeAttributes(attributes, childPath, slpkChildPath) {
-    if (attributes.length && this.layers0.attributeStorageInfo && this.layers0.attributeStorageInfo.length) {
-      for (let index = 0; index < attributes.length; index++) {
-        const folderName = this.layers0.attributeStorageInfo[index].key;
-        const fileBuffer = new Uint8Array(attributes[index]);
-
-        if (this.options.slpk) {
-          const slpkAttributesPath = (0, _path.join)(childPath, 'attributes', folderName);
-          this.fileMap["".concat(slpkChildPath, "/attributes/").concat(folderName, ".bin.gz")] = await (0, _fileUtils.writeFileForSlpk)(slpkAttributesPath, fileBuffer, '0.bin');
-        } else {
-          const attributesPath = (0, _path.join)(childPath, "attributes/".concat(folderName, "/0"));
-          await (0, _fileUtils.writeFile)(attributesPath, fileBuffer, 'index.bin');
-        }
+      function _writeResources(_x21, _x22) {
+        return _writeResources2.apply(this, arguments);
       }
-    }
-  }
 
-  _getFormatByMimeType(mimeType) {
-    switch (mimeType) {
-      case 'image/jpeg':
-        return 'jpg';
+      return _writeResources;
+    }()
+  }, {
+    key: "_writeGeometries",
+    value: function () {
+      var _writeGeometries2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee13(geometryBuffer, compressedGeometry, childPath, slpkChildPath) {
+        var slpkGeometryPath, geometryPath, slpkCompressedGeometryPath, compressedGeometryPath;
+        return _regenerator.default.wrap(function _callee13$(_context13) {
+          while (1) {
+            switch (_context13.prev = _context13.next) {
+              case 0:
+                if (!this.options.slpk) {
+                  _context13.next = 7;
+                  break;
+                }
+
+                slpkGeometryPath = (0, _path.join)(childPath, 'geometries');
+                _context13.next = 4;
+                return (0, _fileUtils.writeFileForSlpk)(slpkGeometryPath, geometryBuffer, '0.bin');
+
+              case 4:
+                this.fileMap["".concat(slpkChildPath, "/geometries/0.bin.gz")] = _context13.sent;
+                _context13.next = 10;
+                break;
+
+              case 7:
+                geometryPath = (0, _path.join)(childPath, 'geometries/0/');
+                _context13.next = 10;
+                return (0, _fileUtils.writeFile)(geometryPath, geometryBuffer, 'index.bin');
+
+              case 10:
+                if (!this.options.draco) {
+                  _context13.next = 21;
+                  break;
+                }
+
+                if (!this.options.slpk) {
+                  _context13.next = 18;
+                  break;
+                }
+
+                slpkCompressedGeometryPath = (0, _path.join)(childPath, 'geometries');
+                _context13.next = 15;
+                return (0, _fileUtils.writeFileForSlpk)(slpkCompressedGeometryPath, compressedGeometry, '1.bin');
+
+              case 15:
+                this.fileMap["".concat(slpkChildPath, "/geometries/1.bin.gz")] = _context13.sent;
+                _context13.next = 21;
+                break;
+
+              case 18:
+                compressedGeometryPath = (0, _path.join)(childPath, 'geometries/1/');
+                _context13.next = 21;
+                return (0, _fileUtils.writeFile)(compressedGeometryPath, compressedGeometry, 'index.bin');
+
+              case 21:
+              case "end":
+                return _context13.stop();
+            }
+          }
+        }, _callee13, this);
+      }));
 
-      case 'image/png':
-        return 'png';
+      function _writeGeometries(_x23, _x24, _x25, _x26) {
+        return _writeGeometries2.apply(this, arguments);
+      }
 
-      default:
-        return 'jpg';
-    }
-  }
+      return _writeGeometries;
+    }()
+  }, {
+    key: "_writeShared",
+    value: function () {
+      var _writeShared2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee14(sharedResources, childPath, slpkChildPath, nodePath) {
+        var sharedData, sharedDataStr, slpkSharedPath, sharedPath;
+        return _regenerator.default.wrap(function _callee14$(_context14) {
+          while (1) {
+            switch (_context14.prev = _context14.next) {
+              case 0:
+                sharedResources.nodePath = nodePath;
+                sharedData = (0, _jsonMapTransform.default)(sharedResources, _sharedResources.SHARED_RESOURCES_TEMPLATE);
+                sharedDataStr = JSON.stringify(sharedData);
+
+                if (!this.options.slpk) {
+                  _context14.next = 10;
+                  break;
+                }
+
+                slpkSharedPath = (0, _path.join)(childPath, 'shared');
+                _context14.next = 7;
+                return (0, _fileUtils.writeFileForSlpk)(slpkSharedPath, sharedDataStr, 'sharedResource.json');
+
+              case 7:
+                this.fileMap["".concat(slpkChildPath, "/shared/sharedResource.json.gz")] = _context14.sent;
+                _context14.next = 13;
+                break;
+
+              case 10:
+                sharedPath = (0, _path.join)(childPath, 'shared/');
+                _context14.next = 13;
+                return (0, _fileUtils.writeFile)(sharedPath, sharedDataStr);
+
+              case 13:
+              case "end":
+                return _context14.stop();
+            }
+          }
+        }, _callee14, this);
+      }));
 
-  _findOrCreateMaterial(material) {
-    const hash = (0, _md.default)(JSON.stringify(material));
+      function _writeShared(_x27, _x28, _x29, _x30) {
+        return _writeShared2.apply(this, arguments);
+      }
 
-    if (this.materialMap.has(hash)) {
-      return this.materialMap.get(hash);
-    }
+      return _writeShared;
+    }()
+  }, {
+    key: "_writeTexture",
+    value: function () {
+      var _writeTexture2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee15(texture, childPath, slpkChildPath) {
+        var format, textureData, slpkTexturePath, compress, texturePath;
+        return _regenerator.default.wrap(function _callee15$(_context15) {
+          while (1) {
+            switch (_context15.prev = _context15.next) {
+              case 0:
+                if (!texture) {
+                  _context15.next = 15;
+                  break;
+                }
+
+                format = this._getFormatByMimeType(texture.mimeType);
+
+                if (!this.layers0.textureSetDefinitions.length) {
+                  this.layers0.textureSetDefinitions.push({
+                    formats: [{
+                      name: '0',
+                      format: format
+                    }]
+                  });
+                }
+
+                textureData = texture.bufferView.data;
+
+                if (!this.options.slpk) {
+                  _context15.next = 12;
+                  break;
+                }
+
+                slpkTexturePath = (0, _path.join)(childPath, 'textures');
+                compress = false;
+                _context15.next = 9;
+                return (0, _fileUtils.writeFileForSlpk)(slpkTexturePath, textureData, "0.".concat(format), compress);
+
+              case 9:
+                this.fileMap["".concat(slpkChildPath, "/textures/0.").concat(format)] = _context15.sent;
+                _context15.next = 15;
+                break;
+
+              case 12:
+                texturePath = (0, _path.join)(childPath, 'textures/0/');
+                _context15.next = 15;
+                return (0, _fileUtils.writeFile)(texturePath, textureData, "index.".concat(format));
+
+              case 15:
+              case "end":
+                return _context15.stop();
+            }
+          }
+        }, _callee15, this);
+      }));
 
-    const newMaterialId = this.materialDefinitions.push(material) - 1;
-    this.materialMap.set(hash, newMaterialId);
-    return newMaterialId;
-  }
+      function _writeTexture(_x31, _x32, _x33) {
+        return _writeTexture2.apply(this, arguments);
+      }
 
-  _createdStorageAttribute(attributeIndex, key, attributeType) {
-    const storageAttribute = {
-      key: "f_".concat(attributeIndex),
-      name: key,
-      ordering: ['attributeValues'],
-      header: [{
-        property: 'count',
-        valueType: 'UInt32'
-      }],
-      attributeValues: {
-        valueType: 'Int32',
-        valuesPerElement: 1
+      return _writeTexture;
+    }()
+  }, {
+    key: "_writeAttributes",
+    value: function () {
+      var _writeAttributes2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee16(attributes, childPath, slpkChildPath) {
+        var index, folderName, fileBuffer, slpkAttributesPath, attributesPath;
+        return _regenerator.default.wrap(function _callee16$(_context16) {
+          while (1) {
+            switch (_context16.prev = _context16.next) {
+              case 0:
+                if (!(attributes.length && this.layers0.attributeStorageInfo && this.layers0.attributeStorageInfo.length)) {
+                  _context16.next = 18;
+                  break;
+                }
+
+                index = 0;
+
+              case 2:
+                if (!(index < attributes.length)) {
+                  _context16.next = 18;
+                  break;
+                }
+
+                folderName = this.layers0.attributeStorageInfo[index].key;
+                fileBuffer = new Uint8Array(attributes[index]);
+
+                if (!this.options.slpk) {
+                  _context16.next = 12;
+                  break;
+                }
+
+                slpkAttributesPath = (0, _path.join)(childPath, 'attributes', folderName);
+                _context16.next = 9;
+                return (0, _fileUtils.writeFileForSlpk)(slpkAttributesPath, fileBuffer, '0.bin');
+
+              case 9:
+                this.fileMap["".concat(slpkChildPath, "/attributes/").concat(folderName, ".bin.gz")] = _context16.sent;
+                _context16.next = 15;
+                break;
+
+              case 12:
+                attributesPath = (0, _path.join)(childPath, "attributes/".concat(folderName, "/0"));
+                _context16.next = 15;
+                return (0, _fileUtils.writeFile)(attributesPath, fileBuffer, 'index.bin');
+
+              case 15:
+                index++;
+                _context16.next = 2;
+                break;
+
+              case 18:
+              case "end":
+                return _context16.stop();
+            }
+          }
+        }, _callee16, this);
+      }));
+
+      function _writeAttributes(_x34, _x35, _x36) {
+        return _writeAttributes2.apply(this, arguments);
       }
-    };
 
-    switch (attributeType) {
-      case OBJECT_ID_TYPE:
-        this._setupIdAttribute(storageAttribute);
+      return _writeAttributes;
+    }()
+  }, {
+    key: "_getFormatByMimeType",
+    value: function _getFormatByMimeType(mimeType) {
+      switch (mimeType) {
+        case 'image/jpeg':
+          return 'jpg';
 
-        break;
+        case 'image/png':
+          return 'png';
 
-      case STRING_TYPE:
-        this._setupStringAttribute(storageAttribute);
+        default:
+          return 'jpg';
+      }
+    }
+  }, {
+    key: "_findOrCreateMaterial",
+    value: function _findOrCreateMaterial(material) {
+      var hash = (0, _md.default)(JSON.stringify(material));
 
-        break;
+      if (this.materialMap.has(hash)) {
+        return this.materialMap.get(hash);
+      }
 
-      case DOUBLE_TYPE:
-        this._setupDoubleAttribute(storageAttribute);
+      var newMaterialId = this.materialDefinitions.push(material) - 1;
+      this.materialMap.set(hash, newMaterialId);
+      return newMaterialId;
+    }
+  }, {
+    key: "_createdStorageAttribute",
+    value: function _createdStorageAttribute(attributeIndex, key, attributeType) {
+      var storageAttribute = {
+        key: "f_".concat(attributeIndex),
+        name: key,
+        ordering: ['attributeValues'],
+        header: [{
+          property: 'count',
+          valueType: 'UInt32'
+        }],
+        attributeValues: {
+          valueType: 'Int32',
+          valuesPerElement: 1
+        }
+      };
 
-        break;
+      switch (attributeType) {
+        case OBJECT_ID_TYPE:
+          this._setupIdAttribute(storageAttribute);
 
-      case SHORT_INT_TYPE:
-        break;
+          break;
 
-      default:
-        this._setupStringAttribute(storageAttribute);
+        case STRING_TYPE:
+          this._setupStringAttribute(storageAttribute);
 
-    }
+          break;
 
-    return storageAttribute;
-  }
+        case DOUBLE_TYPE:
+          this._setupDoubleAttribute(storageAttribute);
 
-  getAttributeType(key, attribute) {
-    if (key === OBJECT_ID_TYPE) {
-      return OBJECT_ID_TYPE;
-    }
+          break;
 
-    if (typeof attribute === STRING_TYPE) {
-      return STRING_TYPE;
-    } else if (typeof attribute === 'number') {
-      return Number.isInteger(attribute) ? SHORT_INT_TYPE : DOUBLE_TYPE;
-    }
+        case SHORT_INT_TYPE:
+          break;
 
-    return STRING_TYPE;
-  }
+        default:
+          this._setupStringAttribute(storageAttribute);
 
-  _setupStringAttribute(storageAttribute) {
-    storageAttribute.ordering.unshift('attributeByteCounts');
-    storageAttribute.header.push({
-      property: 'attributeValuesByteCount',
-      valueType: 'UInt32'
-    });
-    storageAttribute.attributeValues = {
-      valueType: 'String',
-      encoding: 'UTF-8',
-      valuesPerElement: 1
-    };
-    storageAttribute.attributeByteCounts = {
-      valueType: 'UInt32',
-      valuesPerElement: 1
-    };
-  }
+      }
 
-  _setupIdAttribute(storageAttribute) {
-    storageAttribute.attributeValues = {
-      valueType: 'Oid32',
-      valuesPerElement: 1
-    };
-  }
+      return storageAttribute;
+    }
+  }, {
+    key: "getAttributeType",
+    value: function getAttributeType(key, attribute) {
+      if (key === OBJECT_ID_TYPE) {
+        return OBJECT_ID_TYPE;
+      }
 
-  _setupDoubleAttribute(storageAttribute) {
-    storageAttribute.attributeValues = {
-      valueType: 'Float64',
-      valuesPerElement: 1
-    };
-  }
+      if ((0, _typeof2.default)(attribute) === STRING_TYPE) {
+        return STRING_TYPE;
+      } else if (typeof attribute === 'number') {
+        return Number.isInteger(attribute) ? SHORT_INT_TYPE : DOUBLE_TYPE;
+      }
 
-  _createFieldAttribute(key, fieldAttributeType) {
-    return {
-      name: key,
-      type: fieldAttributeType,
-      alias: key
-    };
-  }
+      return STRING_TYPE;
+    }
+  }, {
+    key: "_setupStringAttribute",
+    value: function _setupStringAttribute(storageAttribute) {
+      storageAttribute.ordering.unshift('attributeByteCounts');
+      storageAttribute.header.push({
+        property: 'attributeValuesByteCount',
+        valueType: 'UInt32'
+      });
+      storageAttribute.attributeValues = {
+        valueType: 'String',
+        encoding: 'UTF-8',
+        valuesPerElement: 1
+      };
+      storageAttribute.attributeByteCounts = {
+        valueType: 'UInt32',
+        valuesPerElement: 1
+      };
+    }
+  }, {
+    key: "_setupIdAttribute",
+    value: function _setupIdAttribute(storageAttribute) {
+      storageAttribute.attributeValues = {
+        valueType: 'Oid32',
+        valuesPerElement: 1
+      };
+    }
+  }, {
+    key: "_setupDoubleAttribute",
+    value: function _setupDoubleAttribute(storageAttribute) {
+      storageAttribute.attributeValues = {
+        valueType: 'Float64',
+        valuesPerElement: 1
+      };
+    }
+  }, {
+    key: "_createFieldAttribute",
+    value: function _createFieldAttribute(key, fieldAttributeType) {
+      return {
+        name: key,
+        type: fieldAttributeType,
+        alias: key
+      };
+    }
+  }, {
+    key: "_convertBatchTableInfoToNodeAttributes",
+    value: function _convertBatchTableInfoToNodeAttributes(batchTable) {
+      var attributeIndex = 0;
 
-  _convertBatchTableInfoToNodeAttributes(batchTable) {
-    let attributeIndex = 0;
-    const batchTableWithObjectId = {
-      OBJECTID: [0],
-      ...batchTable
-    };
+      var batchTableWithObjectId = _objectSpread({
+        OBJECTID: [0]
+      }, batchTable);
 
-    for (const key in batchTableWithObjectId) {
-      const firstAttribute = batchTableWithObjectId[key][0];
-      const attributeType = this.getAttributeType(key, firstAttribute);
+      for (var _key in batchTableWithObjectId) {
+        var firstAttribute = batchTableWithObjectId[_key][0];
+        var attributeType = this.getAttributeType(_key, firstAttribute);
 
-      const storageAttribute = this._createdStorageAttribute(attributeIndex, key, attributeType);
+        var storageAttribute = this._createdStorageAttribute(attributeIndex, _key, attributeType);
 
-      const fieldAttributeType = this._getFieldAttributeType(attributeType);
+        var fieldAttributeType = this._getFieldAttributeType(attributeType);
 
-      const fieldAttribute = this._createFieldAttribute(key, fieldAttributeType);
+        var fieldAttribute = this._createFieldAttribute(_key, fieldAttributeType);
 
-      const popupInfo = this._createPopupInfo(batchTableWithObjectId);
+        var popupInfo = this._createPopupInfo(batchTableWithObjectId);
 
-      this.layers0.attributeStorageInfo.push(storageAttribute);
-      this.layers0.fields.push(fieldAttribute);
-      this.layers0.popupInfo = popupInfo;
-      this.layers0.layerType = _3D_OBJECT_LAYER_TYPE;
-      attributeIndex += 1;
+        this.layers0.attributeStorageInfo.push(storageAttribute);
+        this.layers0.fields.push(fieldAttribute);
+        this.layers0.popupInfo = popupInfo;
+        this.layers0.layerType = _3D_OBJECT_LAYER_TYPE;
+        attributeIndex += 1;
+      }
     }
-  }
-
-  _getFieldAttributeType(attributeType) {
-    switch (attributeType) {
-      case OBJECT_ID_TYPE:
-        return 'esriFieldTypeOID';
+  }, {
+    key: "_getFieldAttributeType",
+    value: function _getFieldAttributeType(attributeType) {
+      switch (attributeType) {
+        case OBJECT_ID_TYPE:
+          return 'esriFieldTypeOID';
 
-      case STRING_TYPE:
-        return 'esriFieldTypeString';
+        case STRING_TYPE:
+          return 'esriFieldTypeString';
 
-      case SHORT_INT_TYPE:
-        return 'esriFieldTypeInteger';
+        case SHORT_INT_TYPE:
+          return 'esriFieldTypeInteger';
 
-      case DOUBLE_TYPE:
-        return 'esriFieldTypeDouble';
+        case DOUBLE_TYPE:
+          return 'esriFieldTypeDouble';
 
-      default:
-        return 'esriFieldTypeString';
+        default:
+          return 'esriFieldTypeString';
+      }
     }
-  }
+  }, {
+    key: "_createPopupInfo",
+    value: function _createPopupInfo(batchTable) {
+      var title = '{OBJECTID}';
+      var mediaInfos = [];
+      var fieldInfos = [];
+      var popupElements = [];
+      var expressionInfos = [];
+
+      for (var _key2 in batchTable) {
+        fieldInfos.push({
+          fieldName: _key2,
+          visible: true,
+          isEditable: false,
+          label: _key2
+        });
+      }
 
-  _createPopupInfo(batchTable) {
-    const title = '{OBJECTID}';
-    const mediaInfos = [];
-    const fieldInfos = [];
-    const popupElements = [];
-    const expressionInfos = [];
-
-    for (const key in batchTable) {
-      fieldInfos.push({
-        fieldName: key,
-        visible: true,
-        isEditable: false,
-        label: key
+      popupElements.push({
+        fieldInfos: fieldInfos,
+        type: 'fields'
       });
+      return {
+        title: title,
+        mediaInfos: mediaInfos,
+        popupElements: popupElements,
+        fieldInfos: fieldInfos,
+        expressionInfos: expressionInfos
+      };
     }
+  }, {
+    key: "_finishConversion",
+    value: function () {
+      var _finishConversion2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee17(params) {
+        var _this$refinementCount, tilesCount, tilesWithAddRefineCount, addRefinementPercentage, filesSize, diff, conversionTime;
+
+        return _regenerator.default.wrap(function _callee17$(_context17) {
+          while (1) {
+            switch (_context17.prev = _context17.next) {
+              case 0:
+                _this$refinementCount = this.refinementCounter, tilesCount = _this$refinementCount.tilesCount, tilesWithAddRefineCount = _this$refinementCount.tilesWithAddRefineCount;
+                addRefinementPercentage = tilesWithAddRefineCount ? tilesWithAddRefineCount / tilesCount * 100 : 0;
+                _context17.next = 4;
+                return (0, _statisticUtills.calculateFilesSize)(params);
+
+              case 4:
+                filesSize = _context17.sent;
+                diff = _process.default.hrtime(this.conversionStartTime);
+                conversionTime = (0, _statisticUtills.timeConverter)(diff);
+                console.log("------------------------------------------------");
+                console.log("Finishing conversion of ".concat(_3D_TILES));
+                console.log("Total conversion time: ".concat(conversionTime));
+                console.log("Vertex count: ", this.vertexCounter);
+                console.log("File(s) size: ", filesSize, ' bytes');
+                console.log("Percentage of tiles with \"ADD\" refinement type:", addRefinementPercentage, '%');
+                console.log("------------------------------------------------");
+
+              case 14:
+              case "end":
+                return _context17.stop();
+            }
+          }
+        }, _callee17, this);
+      }));
 
-    popupElements.push({
-      fieldInfos,
-      type: 'fields'
-    });
-    return {
-      title,
-      mediaInfos,
-      popupElements,
-      fieldInfos,
-      expressionInfos
-    };
-  }
+      function _finishConversion(_x37) {
+        return _finishConversion2.apply(this, arguments);
+      }
 
-  async _finishConversion(params) {
-    const {
-      tilesCount,
-      tilesWithAddRefineCount
-    } = this.refinementCounter;
-    const addRefinementPercentage = tilesWithAddRefineCount ? tilesWithAddRefineCount / tilesCount * 100 : 0;
-    const filesSize = await (0, _statisticUtills.calculateFilesSize)(params);
-
-    const diff = _process.default.hrtime(this.conversionStartTime);
-
-    const conversionTime = (0, _statisticUtills.timeConverter)(diff);
-    console.log("------------------------------------------------");
-    console.log("Finishing conversion of ".concat(_3D_TILES));
-    console.log("Total conversion time: ".concat(conversionTime));
-    console.log("Vertex count: ", this.vertexCounter);
-    console.log("File(s) size: ", filesSize, ' bytes');
-    console.log("Percentage of tiles with \"ADD\" refinement type:", addRefinementPercentage, '%');
-    console.log("------------------------------------------------");
-  }
+      return _finishConversion;
+    }()
+  }, {
+    key: "_fetchPreloadOptions",
+    value: function () {
+      var _fetchPreloadOptions2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee18() {
+        var options, preloadOptions;
+        return _regenerator.default.wrap(function _callee18$(_context18) {
+          while (1) {
+            switch (_context18.prev = _context18.next) {
+              case 0:
+                if (this.Loader.preload) {
+                  _context18.next = 2;
+                  break;
+                }
+
+                return _context18.abrupt("return", {});
+
+              case 2:
+                options = {
+                  'cesium-ion': {
+                    accessToken: this.options.token || ION_DEFAULT_TOKEN
+                  }
+                };
+                _context18.next = 5;
+                return this.Loader.preload(this.options.inputUrl, options);
+
+              case 5:
+                preloadOptions = _context18.sent;
+                this.refreshTokenTime = _process.default.hrtime();
+                return _context18.abrupt("return", _objectSpread(_objectSpread({}, options), preloadOptions));
+
+              case 8:
+              case "end":
+                return _context18.stop();
+            }
+          }
+        }, _callee18, this);
+      }));
 
-  async _fetchPreloadOptions() {
-    const options = {
-      'cesium-ion': {
-        accessToken: this.options.token || ION_DEFAULT_TOKEN
+      function _fetchPreloadOptions() {
+        return _fetchPreloadOptions2.apply(this, arguments);
       }
-    };
-    const preloadOptions = await _dTiles.CesiumIonLoader.preload(this.options.inputUrl, options);
-    this.refreshTokenTime = _process.default.hrtime();
-    return { ...options,
-      ...preloadOptions
-    };
-  }
 
-  async _updateTilesetOptions() {
-    const diff = _process.default.hrtime(this.refreshTokenTime);
+      return _fetchPreloadOptions;
+    }()
+  }, {
+    key: "_updateTilesetOptions",
+    value: function () {
+      var _updateTilesetOptions2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee19() {
+        var diff, preloadOptions;
+        return _regenerator.default.wrap(function _callee19$(_context19) {
+          while (1) {
+            switch (_context19.prev = _context19.next) {
+              case 0:
+                diff = _process.default.hrtime(this.refreshTokenTime);
+
+                if (!(diff[0] < REFRESH_TOKEN_TIMEOUT)) {
+                  _context19.next = 3;
+                  break;
+                }
+
+                return _context19.abrupt("return");
+
+              case 3:
+                this.refreshTokenTime = _process.default.hrtime();
+                _context19.next = 6;
+                return this._fetchPreloadOptions();
+
+              case 6:
+                preloadOptions = _context19.sent;
+                this.sourceTileset.options = _objectSpread(_objectSpread({}, this.sourceTileset.options), preloadOptions);
+
+                if (preloadOptions.headers) {
+                  this.sourceTileset.loadOptions.fetch = _objectSpread(_objectSpread({}, this.sourceTileset.loadOptions.fetch), {}, {
+                    headers: preloadOptions.headers
+                  });
+                  console.log('Authorization Bearer token has been updated');
+                }
+
+              case 9:
+              case "end":
+                return _context19.stop();
+            }
+          }
+        }, _callee19, this);
+      }));
 
-    if (diff[0] < REFRESH_TOKEN_TIMEOUT) {
-      return;
-    }
+      function _updateTilesetOptions() {
+        return _updateTilesetOptions2.apply(this, arguments);
+      }
 
-    this.refreshTokenTime = _process.default.hrtime();
-    const preloadOptions = await this._fetchPreloadOptions();
-    this.sourceTileset.options = { ...this.sourceTileset.options,
-      ...preloadOptions
-    };
+      return _updateTilesetOptions;
+    }()
+  }, {
+    key: "_checkAddRefinementTypeForTile",
+    value: function _checkAddRefinementTypeForTile(tile) {
+      var ADD_TILE_REFINEMENT = 1;
 
-    if (preloadOptions.headers) {
-      this.sourceTileset.loadOptions.fetch = { ...this.sourceTileset.loadOptions.fetch,
-        headers: preloadOptions.headers
-      };
-      console.log('Authorization Bearer token has been updated');
-    }
-  }
-
-  _checkAddRefinementTypeForTile(tile) {
-    const ADD_TILE_REFINEMENT = 1;
+      if (tile.refine === ADD_TILE_REFINEMENT) {
+        this.refinementCounter.tilesWithAddRefineCount += 1;
+        console.warn('This tile uses "ADD" type of refinement');
+      }
 
-    if (tile.refine === ADD_TILE_REFINEMENT) {
-      this.refinementCounter.tilesWithAddRefineCount += 1;
-      console.warn('This tile uses "ADD" type of refinement');
+      this.refinementCounter.tilesCount += 1;
     }
-
-    this.refinementCounter.tilesCount += 1;
-  }
-
-}
+  }]);
+  return I3SConverter;
+}();
 
 exports.default = I3SConverter;
 //# sourceMappingURL=i3s-converter.js.map