@loaders.gl/tile-converter 3.2.4 → 3.2.7

package/dist/dist.min.js

@@ -32723,22 +32723,22 @@ var require_zip_archive_output_stream = __commonJS({
     };
     ZipArchiveOutputStream.prototype._smartStream = function(ae, callback) {
       var deflate = ae.getMethod() === constants.METHOD_DEFLATED;
-      var process4 = deflate ? new DeflateCRC32Stream(this.options.zlib) : new CRC32Stream();
+      var process5 = deflate ? new DeflateCRC32Stream(this.options.zlib) : new CRC32Stream();
       var error = null;
       function handleStuff() {
-        var digest = process4.digest().readUInt32BE(0);
+        var digest = process5.digest().readUInt32BE(0);
         ae.setCrc(digest);
-        ae.setSize(process4.size());
-        ae.setCompressedSize(process4.size(true));
+        ae.setSize(process5.size());
+        ae.setCompressedSize(process5.size(true));
         this._afterAppend(ae);
         callback(error, ae);
       }
-      process4.once("end", handleStuff.bind(this));
-      process4.once("error", function(err) {
+      process5.once("end", handleStuff.bind(this));
+      process5.once("error", function(err) {
         error = err;
       });
-      process4.pipe(this, { end: false });
-      return process4;
+      process5.pipe(this, { end: false });
+      return process5;
     };
     ZipArchiveOutputStream.prototype._writeCentralDirectoryEnd = function() {
       var records = this._entries.length;
@@ -73572,6 +73572,22 @@ function isTransferable(object) {
   }
   return false;
 }
+function getTransferListForWriter(object) {
+  if (object === null) {
+    return {};
+  }
+  const clone2 = Object.assign({}, object);
+  Object.keys(clone2).forEach((key) => {
+    if (typeof object[key] === "object" && !ArrayBuffer.isView(object[key])) {
+      clone2[key] = getTransferListForWriter(object[key]);
+    } else if (typeof clone2[key] === "function" || clone2[key] instanceof RegExp) {
+      clone2[key] = {};
+    } else {
+      clone2[key] = object[key];
+    }
+  });
+  return clone2;
+}
 
 // ../worker-utils/src/lib/worker-farm/worker-thread.ts
 var NOOP = () => {
@@ -73821,27 +73837,6 @@ var WorkerFarm = class {
   }
 };
 
-// ../worker-utils/src/lib/worker-utils/remove-nontransferable-options.ts
-function removeNontransferableOptions(object) {
-  return JSON.parse(stringifyJSON(object));
-}
-function stringifyJSON(v) {
-  const cache = new Set();
-  return JSON.stringify(v, (key, value) => {
-    if (typeof value === "object" && value !== null) {
-      if (cache.has(value)) {
-        try {
-          return JSON.parse(JSON.stringify(value));
-        } catch (err) {
-          return void 0;
-        }
-      }
-      cache.add(value);
-    }
-    return value;
-  });
-}
-
 // ../worker-utils/src/lib/worker-api/get-worker-url.ts
 var NPM_TAG = "latest";
 var VERSION2 = typeof VERSION !== "undefined" ? VERSION : NPM_TAG;
@@ -73883,7 +73878,7 @@ async function processOnWorker(worker, data, options = {}, context = {}) {
   const workerPool = workerFarm.getWorkerPool(workerPoolProps);
   const jobName = options.jobName || worker.name;
   const job = await workerPool.startJob(jobName, onMessage.bind(null, context));
-  const transferableOptions = removeNontransferableOptions(options);
+  const transferableOptions = getTransferListForWriter(options);
   job.postMessage("process", { input: data, options: transferableOptions });
   const result = await job.result;
   return result.result;
@@ -75721,14 +75716,13 @@ var cullingVolume = new import_culling.CullingVolume([
 function getFrameState(viewport, frameNumber) {
   const { cameraDirection, cameraUp, height } = viewport;
   const { metersPerUnit } = viewport.distanceScales;
-  const viewportCenterCartographic = viewport.unprojectPosition(viewport.center);
-  const viewportCenterCartesian = import_geospatial2.Ellipsoid.WGS84.cartographicToCartesian(viewportCenterCartographic, new import_core2.Vector3());
+  const viewportCenterCartesian = worldToCartesian(viewport, viewport.center);
   const enuToFixedTransform = import_geospatial2.Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);
   const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
   const cameraPositionCartesian2 = import_geospatial2.Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new import_core2.Vector3());
   const cameraDirectionCartesian = new import_core2.Vector3(enuToFixedTransform.transformAsVector(new import_core2.Vector3(cameraDirection).scale(metersPerUnit))).normalize();
   const cameraUpCartesian = new import_core2.Vector3(enuToFixedTransform.transformAsVector(new import_core2.Vector3(cameraUp).scale(metersPerUnit))).normalize();
-  commonSpacePlanesToWGS84(viewport, viewportCenterCartesian);
+  commonSpacePlanesToWGS84(viewport);
   const ViewportClass = viewport.constructor;
   const { longitude, latitude, width, bearing, zoom } = viewport;
   const topDownViewport = new ViewportClass({
@@ -75778,18 +75772,32 @@ function limitSelectedTiles(tiles, frameState, maximumTilesSelected) {
   }
   return [selectedTiles, unselectedTiles];
 }
-function commonSpacePlanesToWGS84(viewport, viewportCenterCartesian) {
+function commonSpacePlanesToWGS84(viewport) {
   const frustumPlanes = viewport.getFrustumPlanes();
+  const nearCenterCommon = closestPointOnPlane(frustumPlanes.near, viewport.cameraPosition);
+  const nearCenterCartesian = worldToCartesian(viewport, nearCenterCommon);
+  const cameraCartesian = worldToCartesian(viewport, viewport.cameraPosition, scratchPosition);
   let i = 0;
+  cullingVolume.planes[i++].fromPointNormal(nearCenterCartesian, scratchVector.copy(nearCenterCartesian).subtract(cameraCartesian));
   for (const dir in frustumPlanes) {
+    if (dir === "near") {
+      continue;
+    }
     const plane = frustumPlanes[dir];
-    const distanceToCenter = plane.normal.dot(viewport.center);
-    scratchPosition.copy(plane.normal).scale(plane.distance - distanceToCenter).add(viewport.center);
-    const cartographicPos = viewport.unprojectPosition(scratchPosition);
-    const cartesianPos = import_geospatial2.Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, new import_core2.Vector3());
-    cullingVolume.planes[i++].fromPointNormal(cartesianPos, scratchVector.copy(viewportCenterCartesian).subtract(cartesianPos));
+    const posCommon = closestPointOnPlane(plane, nearCenterCommon, scratchPosition);
+    const cartesianPos = worldToCartesian(viewport, posCommon, scratchPosition);
+    cullingVolume.planes[i++].fromPointNormal(cartesianPos, scratchVector.copy(nearCenterCartesian).subtract(cartesianPos));
   }
 }
+function closestPointOnPlane(plane, refPoint, out = new import_core2.Vector3()) {
+  const distanceToRef = plane.normal.dot(refPoint);
+  out.copy(plane.normal).scale(plane.distance - distanceToRef).add(refPoint);
+  return out;
+}
+function worldToCartesian(viewport, point, out = new import_core2.Vector3()) {
+  const cartographicPos = viewport.unprojectPosition(point);
+  return import_geospatial2.Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, out);
+}
 
 // ../tiles/src/tileset/helpers/zoom.ts
 var import_core3 = __toModule(require_es56());
@@ -76156,7 +76164,7 @@ var TilesetTraverser = class {
     this.requestedTiles = {};
     this.emptyTiles = {};
   }
-  get traversalFinished() {
+  traversalFinished(frameState) {
     return true;
   }
   traverse(root, frameState, options) {
@@ -76207,7 +76215,7 @@ var TilesetTraverser = class {
       tile._shouldRefine = shouldRefine && parentRefines;
     }
     const newTime = new Date().getTime();
-    if (this.traversalFinished || newTime - this.lastUpdate > this.updateDebounceTime) {
+    if (this.traversalFinished(frameState) || newTime - this.lastUpdate > this.updateDebounceTime) {
       this.lastUpdate = newTime;
       this.options.onTraversalEnd(frameState);
     }
@@ -76744,21 +76752,27 @@ var Tileset3DTraverser = class extends TilesetTraverser {
   }
 };
 
-// ../tiles/src/tileset/traversers/i3s-frame-counter.ts
+// ../tiles/src/tileset/traversers/i3s-pending-tiles-register.ts
 var I3SPendingTilesRegister = class {
   constructor() {
     this.frameNumberMap = new Map();
   }
-  register(frameNumber) {
-    const oldCount = this.frameNumberMap.get(frameNumber) || 0;
-    this.frameNumberMap.set(frameNumber, oldCount + 1);
+  register(viewportId, frameNumber) {
+    const viewportMap = this.frameNumberMap.get(viewportId) || new Map();
+    const oldCount = viewportMap.get(frameNumber) || 0;
+    viewportMap.set(frameNumber, oldCount + 1);
+    this.frameNumberMap.set(viewportId, viewportMap);
   }
-  deregister(frameNumber) {
-    const oldCount = this.frameNumberMap.get(frameNumber) || 1;
-    this.frameNumberMap.set(frameNumber, oldCount - 1);
+  deregister(viewportId, frameNumber) {
+    const viewportMap = this.frameNumberMap.get(viewportId);
+    if (!viewportMap) {
+      return;
+    }
+    const oldCount = viewportMap.get(frameNumber) || 1;
+    viewportMap.set(frameNumber, oldCount - 1);
   }
-  isZero(frameNumber) {
-    const count = this.frameNumberMap.get(frameNumber) || 0;
+  isZero(viewportId, frameNumber) {
+    const count = this.frameNumberMap.get(viewportId)?.get(frameNumber) || 0;
     return count === 0;
   }
 };
@@ -76776,41 +76790,58 @@ var I3STileManager = class {
   }
   add(request, key, callback, frameState) {
     if (!this._statusMap[key]) {
-      const { frameNumber } = frameState;
+      const {
+        frameNumber,
+        viewport: { id }
+      } = frameState;
       this._statusMap[key] = { request, callback, key, frameState, status: STATUS.REQUESTED };
-      this.pendingTilesRegister.register(frameNumber);
+      this.pendingTilesRegister.register(id, frameNumber);
       request().then((data) => {
         this._statusMap[key].status = STATUS.COMPLETED;
-        const { frameNumber: actualFrameNumber } = this._statusMap[key].frameState;
-        this.pendingTilesRegister.deregister(actualFrameNumber);
+        const {
+          frameNumber: actualFrameNumber,
+          viewport: { id: id2 }
+        } = this._statusMap[key].frameState;
+        this.pendingTilesRegister.deregister(id2, actualFrameNumber);
         this._statusMap[key].callback(data, frameState);
       }).catch((error) => {
         this._statusMap[key].status = STATUS.ERROR;
-        const { frameNumber: actualFrameNumber } = this._statusMap[key].frameState;
-        this.pendingTilesRegister.deregister(actualFrameNumber);
+        const {
+          frameNumber: actualFrameNumber,
+          viewport: { id: id2 }
+        } = this._statusMap[key].frameState;
+        this.pendingTilesRegister.deregister(id2, actualFrameNumber);
         callback(error);
       });
     }
   }
   update(key, frameState) {
     if (this._statusMap[key]) {
-      this.pendingTilesRegister.deregister(this._statusMap[key].frameState.frameNumber);
-      this.pendingTilesRegister.register(frameState.frameNumber);
+      const {
+        frameNumber,
+        viewport: { id }
+      } = this._statusMap[key].frameState;
+      this.pendingTilesRegister.deregister(id, frameNumber);
+      const {
+        frameNumber: newFrameNumber,
+        viewport: { id: newViewportId }
+      } = frameState;
+      this.pendingTilesRegister.register(newViewportId, newFrameNumber);
       this._statusMap[key].frameState = frameState;
     }
   }
   find(key) {
     return this._statusMap[key];
   }
-  hasPendingTiles(frameNumber) {
-    return !this.pendingTilesRegister.isZero(frameNumber);
+  hasPendingTiles(viewportId, frameNumber) {
+    return !this.pendingTilesRegister.isZero(viewportId, frameNumber);
   }
 };
 
 // ../tiles/src/tileset/traversers/i3s-tileset-traverser.ts
 var I3STilesetTraverser = class extends TilesetTraverser {
-  get traversalFinished() {
-    return !this._tileManager.hasPendingTiles(this._frameNumber || 0);
+  traversalFinished(frameState) {
+    return !this._tileManager.hasPendingTiles(frameState.viewport.id, this._frameNumber || 0);
   }
   constructor(options) {
     super(options);
@@ -76862,7 +76893,7 @@ var I3STilesetTraverser = class extends TilesetTraverser {
     tile.children.push(childTile);
     const frameState = this._tileManager.find(childTile.id).frameState;
     this.updateTile(childTile, frameState);
-    if (this._frameNumber === frameState.frameNumber && (this.traversalFinished || new Date().getTime() - this.lastUpdate > this.updateDebounceTime)) {
+    if (this._frameNumber === frameState.frameNumber && (this.traversalFinished(frameState) || new Date().getTime() - this.lastUpdate > this.updateDebounceTime)) {
       this.executeTraversal(childTile, frameState);
     }
   }
@@ -76999,7 +77030,9 @@ var Tileset3D = class {
       } else {
         this.lastUpdatedVieports = viewports;
       }
-      this.doUpdate(viewports);
+      if (viewports) {
+        this.doUpdate(viewports);
+      }
     });
   }
   async selectTiles(viewports = null) {
@@ -77010,7 +77043,9 @@ var Tileset3D = class {
     if (!this.updatePromise) {
       this.updatePromise = new Promise((resolve) => {
         setTimeout(() => {
-          this.doUpdate(this.lastUpdatedVieports);
+          if (this.lastUpdatedVieports) {
+            this.doUpdate(this.lastUpdatedVieports);
+          }
           resolve(this._frameNumber);
           this.updatePromise = null;
         }, this.options.debounceTime);
@@ -77018,21 +77053,19 @@ var Tileset3D = class {
     }
     return this.updatePromise;
   }
-  doUpdate(viewports = null) {
+  doUpdate(viewports) {
     if ("loadTiles" in this.options && !this.options.loadTiles) {
       return;
     }
     if (this.traverseCounter > 0) {
       return;
     }
-    if (!(viewports instanceof Array)) {
-      viewports = [viewports];
-    }
+    const preparedViewports = viewports instanceof Array ? viewports : [viewports];
     this._cache.reset();
     this._frameNumber++;
-    this.traverseCounter = viewports.length;
+    this.traverseCounter = preparedViewports.length;
     const viewportsToTraverse = [];
-    for (const viewport of viewports) {
+    for (const viewport of preparedViewports) {
       const id = viewport.id;
       if (this._needTraverse(id)) {
         viewportsToTraverse.push(id);
@@ -77040,7 +77073,7 @@ var Tileset3D = class {
         this.traverseCounter--;
       }
     }
-    for (const viewport of viewports) {
+    for (const viewport of preparedViewports) {
       const id = viewport.id;
       if (!this.roots[id]) {
         this.roots[id] = this._initializeTileHeaders(this.tileset, null);
@@ -77183,7 +77216,11 @@ var Tileset3D = class {
       this.zoom = 1;
       return;
     }
-    this.cartographicCenter = import_geospatial6.Ellipsoid.WGS84.cartesianToCartographic(center, new import_core10.Vector3());
+    if (center[0] !== 0 || center[1] !== 0 || center[2] !== 0) {
+      this.cartographicCenter = import_geospatial6.Ellipsoid.WGS84.cartesianToCartographic(center, new import_core10.Vector3());
+    } else {
+      this.cartographicCenter = new import_core10.Vector3(0, 0, -import_geospatial6.Ellipsoid.WGS84.radii[0]);
+    }
     this.cartesianCenter = center;
     this.zoom = getZoomFromBoundingVolume(root.boundingVolume, this.cartographicCenter);
   }
@@ -83328,13 +83365,23 @@ function getRefine(refine) {
       return refine;
   }
 }
+function resolveUri(uri, basePath) {
+  const urlSchemeRegex = /^[a-z][0-9a-z+.-]*:/i;
+  if (urlSchemeRegex.test(basePath)) {
+    const url = new URL(uri, `${basePath}/`);
+    return decodeURI(url.toString());
+  } else if (uri.startsWith("/")) {
+    return uri;
+  }
+  return `${basePath}/${uri}`;
+}
 function normalizeTileData(tile, options) {
   if (!tile) {
     return null;
   }
   if (tile.content) {
     const contentUri = tile.content.uri || tile.content.url;
-    tile.contentUrl = `${options.basePath}/${contentUri}`;
+    tile.contentUrl = resolveUri(contentUri, options.basePath);
   }
   tile.id = tile.contentUrl;
   tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
@@ -83372,9 +83419,9 @@ async function normalizeImplicitTileHeaders(tileset) {
     subtrees: { uri: subtreesUriTemplate }
   } = implicitTilingExtension;
   const subtreeUrl = replaceContentUrlTemplate(subtreesUriTemplate, 0, 0, 0, 0);
-  const rootSubtreeUrl = `${basePath}/${subtreeUrl}`;
+  const rootSubtreeUrl = resolveUri(subtreeUrl, basePath);
   const rootSubtree = await load(rootSubtreeUrl, Tile3DSubtreeLoader);
-  const contentUrlTemplate = `${basePath}/${tileset.root.content.uri}`;
+  const contentUrlTemplate = resolveUri(tileset.root.content.uri, basePath);
   const refine = tileset.root.refine;
   const rootLodMetricValue = tileset.root.geometricError;
   const rootBoundingVolume = tileset.root.boundingVolume;
@@ -83743,7 +83790,7 @@ var stringify = import_dist.default.stringify;
 var parse5 = import_dist.default.parse;
 
 // src/i3s-converter/i3s-converter.ts
-var import_process = __toModule(require("process"));
+var import_process2 = __toModule(require("process"));
 var import_json_map_transform6 = __toModule(require_json_map_transform());
 var import_md52 = __toModule(require_md52());
 
@@ -83858,14 +83905,14 @@ var NodePages = class {
       for (const [index, nodePage] of this.nodePages.entries()) {
         const nodePageStr = JSON.stringify(nodePage);
         const slpkPath = (0, import_path2.join)(layers0Path, "nodepages");
-        writeQueue.enqueue({
+        await writeQueue.enqueue({
           archiveKey: `nodePages/${index.toString()}.json.gz`,
           writePromise: this.writeFile(slpkPath, nodePageStr, `${index.toString()}.json`)
         });
       }
       const metadata = (0, import_json_map_transform.default)({ nodeCount: this.nodesCounter }, METADATA());
       const compress = false;
-      writeQueue.enqueue({
+      await writeQueue.enqueue({
         archiveKey: "metadata.json",
         writePromise: this.writeFile(layers0Path, JSON.stringify(metadata), "metadata.json", compress)
       });
@@ -83873,7 +83920,7 @@ var NodePages = class {
       for (const [index, nodePage] of this.nodePages.entries()) {
         const nodePageStr = JSON.stringify(nodePage);
         const nodePagePath = (0, import_path2.join)(layers0Path, "nodepages", index.toString());
-        writeQueue.enqueue({ writePromise: this.writeFile(nodePagePath, nodePageStr) });
+        await writeQueue.enqueue({ writePromise: this.writeFile(nodePagePath, nodePageStr) });
       }
     }
   }
@@ -85618,6 +85665,8 @@ var Queue = class extends Array {
 };
 
 // src/lib/utils/write-queue.ts
+var import_process = __toModule(require("process"));
+var MEMORY_LIMIT = 4 * 1024 * 1024 * 1024;
 var WriteQueue = class extends Queue {
   constructor(listeningInterval = 2e3, writeConcurrency = 400) {
     super();
@@ -85626,6 +85675,12 @@ var WriteQueue = class extends Queue {
     this.listeningInterval = listeningInterval;
     this.writeConcurrency = writeConcurrency;
   }
+  async enqueue(val) {
+    super.enqueue(val);
+    if (import_process.default.memoryUsage().rss > MEMORY_LIMIT) {
+      await this.startWrite();
+    }
+  }
   startListening() {
     this.intervalId = setInterval(this.startWrite.bind(this), this.listeningInterval);
   }
@@ -85693,7 +85748,7 @@ var I3SAttributesWorker = {
 var BROWSER_ERROR_MESSAGE = "Tile converter does not work in browser, only in node js environment";
 
 // src/i3s-converter/i3s-converter.ts
-var ION_DEFAULT_TOKEN = import_process.default.env?.IonToken || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ";
+var ION_DEFAULT_TOKEN = import_process2.default.env?.IonToken || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ";
 var HARDCODED_NODES_PER_PAGE = 64;
 var _3D_TILES = "3DTILES";
 var _3D_OBJECT_LAYER_TYPE = "3DObject";
@@ -85735,7 +85790,7 @@ var I3SConverter = class {
       console.log(BROWSER_ERROR_MESSAGE);
       return BROWSER_ERROR_MESSAGE;
     }
-    this.conversionStartTime = import_process.default.hrtime();
+    this.conversionStartTime = import_process2.default.hrtime();
     const {
       tilesetName,
       slpk,
@@ -85867,12 +85922,12 @@ var I3SConverter = class {
       const [child] = await this._createNode(root0, sourceRootTile, parentId, 0);
       const childPath = (0, import_path7.join)(this.layers0Path, "nodes", child.path);
       if (this.options.slpk) {
-        this.writeQueue.enqueue({
+        await this.writeQueue.enqueue({
           archiveKey: "nodes/1/3dNodeIndexDocument.json.gz",
           writePromise: writeFileForSlpk(childPath, JSON.stringify(child), "3dNodeIndexDocument.json")
         });
       } else {
-        this.writeQueue.enqueue({ writePromise: writeFile3(childPath, JSON.stringify(child)) });
+        await this.writeQueue.enqueue({ writePromise: writeFile3(childPath, JSON.stringify(child)) });
       }
     } else {
       await this._addChildrenWithNeighborsAndWriteFile({
@@ -85886,24 +85941,24 @@ var I3SConverter = class {
   }
   async _writeLayers0() {
     if (this.options.slpk) {
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: "3dSceneLayer.json.gz",
         writePromise: writeFileForSlpk(this.layers0Path, JSON.stringify(this.layers0), "3dSceneLayer.json")
       });
     } else {
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         writePromise: writeFile3(this.layers0Path, JSON.stringify(this.layers0))
       });
     }
   }
   async _writeNodeIndexDocument(root0, nodePath, rootPath) {
     if (this.options.slpk) {
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: `nodes/${nodePath}/3dNodeIndexDocument.json.gz`,
         writePromise: writeFileForSlpk(rootPath, JSON.stringify(root0), "3dNodeIndexDocument.json")
       });
     } else {
-      this.writeQueue.enqueue({ writePromise: writeFile3(rootPath, JSON.stringify(root0)) });
+      await this.writeQueue.enqueue({ writePromise: writeFile3(rootPath, JSON.stringify(root0)) });
     }
   }
   async _createSlpk(tilesetPath) {
@@ -86140,26 +86195,26 @@ var I3SConverter = class {
   async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath) {
     if (this.options.slpk) {
       const slpkGeometryPath = (0, import_path7.join)(childPath, "geometries");
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/geometries/0.bin.gz`,
         writePromise: writeFileForSlpk(slpkGeometryPath, geometryBuffer, "0.bin")
       });
     } else {
       const geometryPath = (0, import_path7.join)(childPath, "geometries/0/");
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         writePromise: writeFile3(geometryPath, geometryBuffer, "index.bin")
       });
     }
     if (this.options.draco) {
       if (this.options.slpk) {
         const slpkCompressedGeometryPath = (0, import_path7.join)(childPath, "geometries");
-        this.writeQueue.enqueue({
+        await this.writeQueue.enqueue({
           archiveKey: `${slpkChildPath}/geometries/1.bin.gz`,
           writePromise: writeFileForSlpk(slpkCompressedGeometryPath, compressedGeometry, "1.bin")
         });
       } else {
         const compressedGeometryPath = (0, import_path7.join)(childPath, "geometries/1/");
-        this.writeQueue.enqueue({
+        await this.writeQueue.enqueue({
           writePromise: writeFile3(compressedGeometryPath, compressedGeometry, "index.bin")
         });
       }
@@ -86174,13 +86229,13 @@ var I3SConverter = class {
     const sharedDataStr = JSON.stringify(sharedData);
     if (this.options.slpk) {
       const slpkSharedPath = (0, import_path7.join)(childPath, "shared");
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/shared/sharedResource.json.gz`,
         writePromise: writeFileForSlpk(slpkSharedPath, sharedDataStr, "sharedResource.json")
       });
     } else {
       const sharedPath = (0, import_path7.join)(childPath, "shared/");
-      this.writeQueue.enqueue({ writePromise: writeFile3(sharedPath, sharedDataStr) });
+      await this.writeQueue.enqueue({ writePromise: writeFile3(sharedPath, sharedDataStr) });
     }
   }
   async _writeTexture(texture, childPath, slpkChildPath) {
@@ -86224,13 +86279,13 @@ var I3SConverter = class {
     if (this.options.slpk) {
       const slpkTexturePath = (0, import_path7.join)(childPath, "textures");
       const compress = false;
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/textures/${name8}.${format}`,
         writePromise: writeFileForSlpk(slpkTexturePath, textureData, `${name8}.${format}`, compress)
       });
     } else {
       const texturePath = (0, import_path7.join)(childPath, `textures/${name8}/`);
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         writePromise: writeFile3(texturePath, textureData, `index.${format}`)
       });
     }
@@ -86242,13 +86297,13 @@ var I3SConverter = class {
         const fileBuffer = new Uint8Array(attributes[index]);
         if (this.options.slpk) {
           const slpkAttributesPath = (0, import_path7.join)(childPath, "attributes", folderName);
-          this.writeQueue.enqueue({
+          await this.writeQueue.enqueue({
             archiveKey: `${slpkChildPath}/attributes/${folderName}.bin.gz`,
             writePromise: writeFileForSlpk(slpkAttributesPath, fileBuffer, "0.bin")
           });
         } else {
           const attributesPath = (0, import_path7.join)(childPath, `attributes/${folderName}/0`);
-          this.writeQueue.enqueue({
+          await this.writeQueue.enqueue({
             writePromise: writeFile3(attributesPath, fileBuffer, "index.bin")
           });
         }
@@ -86408,7 +86463,7 @@ var I3SConverter = class {
     const { tilesCount, tilesWithAddRefineCount } = this.refinementCounter;
     const addRefinementPercentage = tilesWithAddRefineCount ? tilesWithAddRefineCount / tilesCount * 100 : 0;
     const filesSize = await calculateFilesSize(params);
-    const diff = import_process.default.hrtime(this.conversionStartTime);
+    const diff = import_process2.default.hrtime(this.conversionStartTime);
     const conversionTime = timeConverter(diff);
     console.log(`------------------------------------------------`);
     console.log(`Finishing conversion of ${_3D_TILES}`);
@@ -86426,15 +86481,15 @@ var I3SConverter = class {
       "cesium-ion": { accessToken: this.options.token || ION_DEFAULT_TOKEN }
     };
     const preloadOptions = await this.Loader.preload(this.options.inputUrl, options);
-    this.refreshTokenTime = import_process.default.hrtime();
+    this.refreshTokenTime = import_process2.default.hrtime();
     return { ...options, ...preloadOptions };
   }
   async _updateTilesetOptions() {
-    const diff = import_process.default.hrtime(this.refreshTokenTime);
+    const diff = import_process2.default.hrtime(this.refreshTokenTime);
     if (diff[0] < REFRESH_TOKEN_TIMEOUT) {
       return;
     }
-    this.refreshTokenTime = import_process.default.hrtime();
+    this.refreshTokenTime = import_process2.default.hrtime();
     const preloadOptions = await this._fetchPreloadOptions();
     this.sourceTileset.options = { ...this.sourceTileset.options, ...preloadOptions };
     if (preloadOptions.headers) {
@@ -86480,7 +86535,7 @@ var I3SConverter = class {
 
 // src/3d-tiles-converter/3d-tiles-converter.ts
 var import_path8 = __toModule(require("path"));
-var import_process2 = __toModule(require("process"));
+var import_process3 = __toModule(require("process"));
 var import_json_map_transform8 = __toModule(require_json_map_transform());
 
 // ../i3s/src/lib/parsers/parse-i3s-tile-content.ts
@@ -87710,7 +87765,7 @@ var Tiles3DConverter = class {
       return BROWSER_ERROR_MESSAGE;
     }
     const { inputUrl, outputPath, tilesetName, maxDepth, egmFilePath } = options;
-    this.conversionStartTime = import_process2.default.hrtime();
+    this.conversionStartTime = import_process3.default.hrtime();
     this.options = { maxDepth };
     console.log("Loading egm file...");
     this.geoidHeightModel = await load(egmFilePath, PGMLoader);
@@ -87860,7 +87915,7 @@ var Tiles3DConverter = class {
   }
   async _finishConversion(params) {
     const filesSize = await calculateFilesSize(params);
-    const diff = import_process2.default.hrtime(this.conversionStartTime);
+    const diff = import_process3.default.hrtime(this.conversionStartTime);
     const conversionTime = timeConverter(diff);
     console.log(`------------------------------------------------`);
     console.log(`Finish conversion of ${I3S}`);

package/dist/es5/3d-tiles-attributes-worker.js

@@ -8,7 +8,7 @@ exports._typecheckI3SAttributesWorker = exports.Tile3dAttributesWorker = void 0;
 
 var _workerUtils = require("@loaders.gl/worker-utils");
 
-var VERSION = typeof "3.2.4" !== 'undefined' ? "3.2.4" : 'latest';
+var VERSION = typeof "3.2.7" !== 'undefined' ? "3.2.7" : 'latest';
 var Tile3dAttributesWorker = {
   id: '3d-tiles-attributes',
   name: '3DTiles Attributes Worker',

package/dist/es5/i3s-attributes-worker.js

@@ -8,7 +8,7 @@ exports._typecheckI3SAttributesWorker = exports.I3SAttributesWorker = void 0;
 
 var _workerUtils = require("@loaders.gl/worker-utils");
 
-var VERSION = typeof "3.2.4" !== 'undefined' ? "3.2.4" : 'latest';
+var VERSION = typeof "3.2.7" !== 'undefined' ? "3.2.7" : 'latest';
 var I3SAttributesWorker = {
   id: 'i3s-attributes',
   name: 'I3S Attributes Worker',