@loaders.gl/tile-converter 4.0.0-alpha.7 → 4.0.0-alpha.9

package/dist/dist.min.js

@@ -2173,15 +2173,15 @@ var require_vector3 = __commonJS({
     }
     var ORIGIN = [0, 0, 0];
     var ZERO2;
-    var Vector322 = function(_Vector) {
-      (0, _inherits2.default)(Vector323, _Vector);
-      var _super = _createSuper(Vector323);
-      function Vector323() {
+    var Vector323 = function(_Vector) {
+      (0, _inherits2.default)(Vector324, _Vector);
+      var _super = _createSuper(Vector324);
+      function Vector324() {
         var _this;
         var x = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
         var y = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
         var z = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
-        (0, _classCallCheck2.default)(this, Vector323);
+        (0, _classCallCheck2.default)(this, Vector324);
         _this = _super.call(this, -0, -0, -0);
         if (arguments.length === 1 && (0, _common.isArray)(x)) {
           _this.copy(x);
@@ -2197,7 +2197,7 @@ var require_vector3 = __commonJS({
         }
         return _this;
       }
-      (0, _createClass2.default)(Vector323, [{
+      (0, _createClass2.default)(Vector324, [{
         key: "set",
         value: function set(x, y, z) {
           this[0] = x;
@@ -2318,15 +2318,15 @@ var require_vector3 = __commonJS({
         key: "ZERO",
         get: function get() {
           if (!ZERO2) {
-            ZERO2 = new Vector323(0, 0, 0);
+            ZERO2 = new Vector324(0, 0, 0);
             Object.freeze(ZERO2);
           }
           return ZERO2;
         }
       }]);
-      return Vector323;
+      return Vector324;
     }(_vector.default);
-    exports.default = Vector322;
+    exports.default = Vector323;
   }
 });
 
@@ -5290,12 +5290,12 @@ var require_matrix4 = __commonJS({
     var DEFAULT_NEAR = 0.1;
     var DEFAULT_FAR = 500;
     var IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-    var Matrix410 = function(_Matrix) {
-      (0, _inherits2.default)(Matrix411, _Matrix);
-      var _super = _createSuper(Matrix411);
-      function Matrix411(array) {
+    var Matrix412 = function(_Matrix) {
+      (0, _inherits2.default)(Matrix413, _Matrix);
+      var _super = _createSuper(Matrix413);
+      function Matrix413(array) {
         var _this;
-        (0, _classCallCheck2.default)(this, Matrix411);
+        (0, _classCallCheck2.default)(this, Matrix413);
         _this = _super.call(this, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0);
         if (arguments.length === 1 && Array.isArray(array)) {
           _this.copy(array);
@@ -5304,7 +5304,7 @@ var require_matrix4 = __commonJS({
         }
         return _this;
       }
-      (0, _createClass2.default)(Matrix411, [{
+      (0, _createClass2.default)(Matrix413, [{
         key: "ELEMENTS",
         get: function get() {
           return 16;
@@ -5685,21 +5685,21 @@ var require_matrix4 = __commonJS({
           return getZeroMatrix();
         }
       }]);
-      return Matrix411;
+      return Matrix413;
     }(_matrix.default);
-    exports.default = Matrix410;
+    exports.default = Matrix412;
     var ZERO2;
     var IDENTITY;
     function getZeroMatrix() {
       if (!ZERO2) {
-        ZERO2 = new Matrix410([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+        ZERO2 = new Matrix412([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
         Object.freeze(ZERO2);
       }
       return ZERO2;
     }
     function getIdentityMatrix() {
       if (!IDENTITY) {
-        IDENTITY = new Matrix410();
+        IDENTITY = new Matrix412();
         Object.freeze(IDENTITY);
       }
       return IDENTITY;
@@ -8167,12 +8167,12 @@ var require_ellipsoid = __commonJS({
     var scratchPosition3 = new _core.Vector3();
     var scratchHeight = new _core.Vector3();
     var scratchCartesian = new _core.Vector3();
-    var Ellipsoid15 = function() {
-      function Ellipsoid16() {
+    var Ellipsoid16 = function() {
+      function Ellipsoid17() {
         var x = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 0;
         var y = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
         var z = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
-        (0, _classCallCheck2.default)(this, Ellipsoid16);
+        (0, _classCallCheck2.default)(this, Ellipsoid17);
         (0, _defineProperty2.default)(this, "radii", void 0);
         (0, _defineProperty2.default)(this, "radiiSquared", void 0);
         (0, _defineProperty2.default)(this, "radiiToTheFourth", void 0);
@@ -8197,7 +8197,7 @@ var require_ellipsoid = __commonJS({
         }
         Object.freeze(this);
       }
-      (0, _createClass2.default)(Ellipsoid16, [{
+      (0, _createClass2.default)(Ellipsoid17, [{
         key: "equals",
         value: function equals2(right) {
           return this === right || Boolean(right && this.radii.equals(right.radii));
@@ -8318,10 +8318,10 @@ var require_ellipsoid = __commonJS({
           return scratchPosition3.set(0, 0, z).to(result);
         }
       }]);
-      return Ellipsoid16;
+      return Ellipsoid17;
     }();
-    exports.default = Ellipsoid15;
-    (0, _defineProperty2.default)(Ellipsoid15, "WGS84", new Ellipsoid15(_constants.WGS84_RADIUS_X, _constants.WGS84_RADIUS_Y, _constants.WGS84_RADIUS_Z));
+    exports.default = Ellipsoid16;
+    (0, _defineProperty2.default)(Ellipsoid16, "WGS84", new Ellipsoid16(_constants.WGS84_RADIUS_X, _constants.WGS84_RADIUS_Y, _constants.WGS84_RADIUS_Z));
   }
 });
 
@@ -47225,8 +47225,10 @@ var ChildProcessProxy = class {
         });
         childProcess.stderr.on("data", (data) => {
           console.log(`Child process wrote to stderr: "${data}".`);
-          this._clearTimeout();
-          reject(new Error(data));
+          if (!props.ignoreStderr) {
+            this._clearTimeout();
+            reject(new Error(data));
+          }
         });
         childProcess.on("error", (error) => {
           console.log(`Child process errored with ${error}`);
@@ -50030,24 +50032,28 @@ var TILE_CONTENT_STATE = {
   EXPIRED: 4,
   FAILED: 5
 };
-var TILE_REFINEMENT = {
-  ADD: 1,
-  REPLACE: 2
-};
-var TILE_TYPE = {
-  EMPTY: "empty",
-  SCENEGRAPH: "scenegraph",
-  POINTCLOUD: "pointcloud",
-  MESH: "mesh"
-};
-var TILESET_TYPE = {
-  I3S: "I3S",
-  TILES3D: "TILES3D"
-};
-var LOD_METRIC_TYPE = {
-  GEOMETRIC_ERROR: "geometricError",
-  MAX_SCREEN_THRESHOLD: "maxScreenThreshold"
-};
+var TILE_REFINEMENT;
+(function(TILE_REFINEMENT2) {
+  TILE_REFINEMENT2[TILE_REFINEMENT2["ADD"] = 1] = "ADD";
+  TILE_REFINEMENT2[TILE_REFINEMENT2["REPLACE"] = 2] = "REPLACE";
+})(TILE_REFINEMENT || (TILE_REFINEMENT = {}));
+var TILE_TYPE;
+(function(TILE_TYPE2) {
+  TILE_TYPE2["EMPTY"] = "empty";
+  TILE_TYPE2["SCENEGRAPH"] = "scenegraph";
+  TILE_TYPE2["POINTCLOUD"] = "pointcloud";
+  TILE_TYPE2["MESH"] = "mesh";
+})(TILE_TYPE || (TILE_TYPE = {}));
+var TILESET_TYPE;
+(function(TILESET_TYPE2) {
+  TILESET_TYPE2["I3S"] = "I3S";
+  TILESET_TYPE2["TILES3D"] = "TILES3D";
+})(TILESET_TYPE || (TILESET_TYPE = {}));
+var LOD_METRIC_TYPE;
+(function(LOD_METRIC_TYPE2) {
+  LOD_METRIC_TYPE2["GEOMETRIC_ERROR"] = "geometricError";
+  LOD_METRIC_TYPE2["MAX_SCREEN_THRESHOLD"] = "maxScreenThreshold";
+})(LOD_METRIC_TYPE || (LOD_METRIC_TYPE = {}));
 var TILE3D_OPTIMIZATION_HINT = {
   NOT_COMPUTED: -1,
   USE_OPTIMIZATION: 1,
@@ -51700,7 +51706,7 @@ var Tileset3D = class {
       throw new Error("Tileset must have an asset property.");
     }
     if (this.asset.version !== "0.0" && this.asset.version !== "1.0" && this.asset.version !== "1.1") {
-      throw new Error("The tileset must be 3D Tiles version 0.0 or 1.0.");
+      throw new Error("The tileset must be 3D Tiles version either 0.0 or 1.0 or 1.1.");
     }
     if ("tilesetVersion" in this.asset) {
       this._queryParams.v = this.asset.tilesetVersion;
@@ -53096,26 +53102,26 @@ function parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options) {
   return byteOffset;
 }
 function parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options) {
-  const { featureTableJsonByteLength, featureTableBinaryByteLength, batchLength } = tile.header;
+  const { featureTableJsonByteLength, featureTableBinaryByteLength, batchLength } = tile.header || {};
   tile.featureTableJson = {
     BATCH_LENGTH: batchLength || 0
   };
-  if (featureTableJsonByteLength > 0) {
+  if (featureTableJsonByteLength && featureTableJsonByteLength > 0) {
     const featureTableString = getStringFromArrayBuffer(arrayBuffer, byteOffset, featureTableJsonByteLength);
     tile.featureTableJson = JSON.parse(featureTableString);
   }
-  byteOffset += featureTableJsonByteLength;
+  byteOffset += featureTableJsonByteLength || 0;
   tile.featureTableBinary = new Uint8Array(arrayBuffer, byteOffset, featureTableBinaryByteLength);
-  byteOffset += featureTableBinaryByteLength;
+  byteOffset += featureTableBinaryByteLength || 0;
   return byteOffset;
 }
 function parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options) {
-  const { batchTableJsonByteLength, batchTableBinaryByteLength } = tile.header;
-  if (batchTableJsonByteLength > 0) {
+  const { batchTableJsonByteLength, batchTableBinaryByteLength } = tile.header || {};
+  if (batchTableJsonByteLength && batchTableJsonByteLength > 0) {
     const batchTableString = getStringFromArrayBuffer(arrayBuffer, byteOffset, batchTableJsonByteLength);
     tile.batchTableJson = JSON.parse(batchTableString);
     byteOffset += batchTableJsonByteLength;
-    if (batchTableBinaryByteLength > 0) {
+    if (batchTableBinaryByteLength && batchTableBinaryByteLength > 0) {
       tile.batchTableBinary = new Uint8Array(arrayBuffer, byteOffset, batchTableBinaryByteLength);
       tile.batchTableBinary = new Uint8Array(tile.batchTableBinary);
       byteOffset += batchTableBinaryByteLength;
@@ -53129,7 +53135,7 @@ function normalize3DTileColorAttribute(tile, colors, batchTable) {
   if (!colors && (!tile || !tile.batchIds || !batchTable)) {
     return null;
   }
-  const { batchIds, isRGB565, pointCount } = tile;
+  const { batchIds, isRGB565, pointCount = 0 } = tile;
   if (batchIds && batchTable) {
     const colorArray = new Uint8ClampedArray(pointCount * 3);
     for (let i = 0; i < pointCount; i++) {
@@ -53147,7 +53153,7 @@ function normalize3DTileColorAttribute(tile, colors, batchTable) {
       normalized: true
     };
   }
-  if (isRGB565) {
+  if (colors && isRGB565) {
     const colorArray = new Uint8ClampedArray(pointCount * 3);
     for (let i = 0; i < pointCount; i++) {
       const color = decodeRGB565(colors[i]);
@@ -53172,7 +53178,7 @@ function normalize3DTileColorAttribute(tile, colors, batchTable) {
   }
   return {
     type: GL2.UNSIGNED_BYTE,
-    value: colors,
+    value: colors || new Uint8ClampedArray(),
     size: 4,
     normalized: true
   };
@@ -53186,8 +53192,8 @@ function normalize3DTileNormalAttribute(tile, normals) {
     return null;
   }
   if (tile.isOctEncoded16P) {
-    const decodedArray = new Float32Array(tile.pointsLength * 3);
-    for (let i = 0; i < tile.pointsLength; i++) {
+    const decodedArray = new Float32Array((tile.pointsLength || 0) * 3);
+    for (let i = 0; i < (tile.pointsLength || 0); i++) {
       octDecode(normals[i * 2], normals[i * 2 + 1], scratchNormal);
       scratchNormal.toArray(decodedArray, i * 3);
     }
@@ -53270,6 +53276,12 @@ function parsePointCloudTables(tile) {
   return { featureTable, batchTable };
 }
 function parsePositions(tile, featureTable, options) {
+  tile.attributes = tile.attributes || {
+    positions: null,
+    colors: null,
+    normals: null,
+    batchIds: null
+  };
   if (!tile.attributes.positions) {
     if (featureTable.hasProperty("POSITION")) {
       tile.attributes.positions = featureTable.getPropertyArray("POSITION", GL2.FLOAT, 3);
@@ -53293,6 +53305,12 @@ function parsePositions(tile, featureTable, options) {
   }
 }
 function parseColors(tile, featureTable, batchTable) {
+  tile.attributes = tile.attributes || {
+    positions: null,
+    colors: null,
+    normals: null,
+    batchIds: null
+  };
   if (!tile.attributes.colors) {
     let colors = null;
     if (featureTable.hasProperty("RGBA")) {
@@ -53311,6 +53329,12 @@ function parseColors(tile, featureTable, batchTable) {
   }
 }
 function parseNormals(tile, featureTable) {
+  tile.attributes = tile.attributes || {
+    positions: null,
+    colors: null,
+    normals: null,
+    batchIds: null
+  };
   if (!tile.attributes.normals) {
     let normals = null;
     if (featureTable.hasProperty("NORMAL")) {
@@ -53353,7 +53377,7 @@ async function parseDraco(tile, featureTable, batchTable, options, context) {
     if (!dracoFeatureTableProperties || !Number.isFinite(dracoByteOffset) || !dracoByteLength) {
       throw new Error("Draco properties, byteOffset, and byteLength must be defined");
     }
-    dracoBuffer = tile.featureTableBinary.slice(dracoByteOffset, dracoByteOffset + dracoByteLength);
+    dracoBuffer = (tile.featureTableBinary || []).slice(dracoByteOffset, dracoByteOffset + dracoByteLength);
     tile.hasPositions = Number.isFinite(dracoFeatureTableProperties.POSITION);
     tile.hasColors = Number.isFinite(dracoFeatureTableProperties.RGB) || Number.isFinite(dracoFeatureTableProperties.RGBA);
     tile.hasNormals = Number.isFinite(dracoFeatureTableProperties.NORMAL);
@@ -53373,11 +53397,14 @@ async function parseDraco(tile, featureTable, batchTable, options, context) {
   return await loadDraco(tile, dracoData, options, context);
 }
 async function loadDraco(tile, dracoData, options, context) {
+  if (!context) {
+    return;
+  }
   const { parse: parse7 } = context;
   const dracoOptions = {
     ...options,
     draco: {
-      ...options.draco,
+      ...options?.draco,
       extraAttributes: dracoData.batchTableProperties || {}
     }
   };
@@ -55023,7 +55050,8 @@ var GLTFScenegraph = class {
   constructor(gltf) {
     this.gltf = {
       json: gltf?.json || makeDefaultGLTFJson(),
-      buffers: gltf?.buffers || []
+      buffers: gltf?.buffers || [],
+      images: gltf?.images || []
     };
     this.sourceBuffers = [];
     this.byteLength = 0;
@@ -55279,14 +55307,14 @@ var GLTFScenegraph = class {
     this.json.images.push(glTFImage);
     return this.json.images.length - 1;
   }
-  addBufferView(buffer) {
+  addBufferView(buffer, bufferIndex = 0, byteOffset = this.byteLength) {
     const byteLength = buffer.byteLength;
     assert6(Number.isFinite(byteLength));
     this.sourceBuffers = this.sourceBuffers || [];
     this.sourceBuffers.push(buffer);
     const glTFBufferView = {
-      buffer: 0,
-      byteOffset: this.byteLength,
+      buffer: bufferIndex,
+      byteOffset,
       byteLength
     };
     this.byteLength += padToNBytes(byteLength, 4);
@@ -56171,18 +56199,16 @@ __export(EXT_feature_metadata_exports, {
 });
 var EXT_FEATURE_METADATA = "EXT_feature_metadata";
 var name9 = EXT_FEATURE_METADATA;
-async function decode8(gltfData) {
+async function decode8(gltfData, options) {
   const scenegraph = new GLTFScenegraph(gltfData);
-  decodeExtFeatureMetadata(scenegraph);
+  decodeExtFeatureMetadata(scenegraph, options);
 }
-function decodeExtFeatureMetadata(scenegraph) {
+function decodeExtFeatureMetadata(scenegraph, options) {
   const extension = scenegraph.getExtension(EXT_FEATURE_METADATA);
-  const schemaClasses = extension?.schema?.classes;
-  const featureTables = extension?.featureTables;
-  const featureTextures = extension?.featureTextures;
-  if (featureTextures) {
-    console.warn('featureTextures is not yet supported in the "EXT_feature_metadata" extension.');
-  }
+  if (!extension)
+    return;
+  const schemaClasses = extension.schema?.classes;
+  const { featureTables } = extension;
   if (schemaClasses && featureTables) {
     for (const schemaName in schemaClasses) {
       const schemaClass = schemaClasses[schemaName];
@@ -56192,6 +56218,16 @@ function decodeExtFeatureMetadata(scenegraph) {
       }
     }
   }
+  const { featureTextures } = extension;
+  if (schemaClasses && featureTextures && options.gltf?.loadImages) {
+    for (const schemaName in schemaClasses) {
+      const schemaClass = schemaClasses[schemaName];
+      const featureTexture = findFeatureTextureByName(featureTextures, schemaName);
+      if (featureTexture) {
+        handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass);
+      }
+    }
+  }
 }
 function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
   for (const propertyName in schemaClass.properties) {
@@ -56204,19 +56240,128 @@ function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
     }
   }
 }
+function handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass) {
+  const attributeName = featureTexture.class;
+  for (const propertyName in schemaClass.properties) {
+    const featureTextureProperty = featureTexture?.properties?.[propertyName];
+    if (featureTextureProperty) {
+      const data = getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName);
+      featureTextureProperty.data = data;
+    }
+  }
+}
 function getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
   const bufferView = featureTableProperty.bufferView;
-  let data = scenegraph.getTypedArrayForBufferView(bufferView);
+  const dataArray = scenegraph.getTypedArrayForBufferView(bufferView);
   switch (schemaProperty.type) {
     case "STRING": {
       const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
       const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
-      data = getStringAttributes(data, offsetsData, numberOfFeatures);
-      break;
+      return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
     }
     default:
   }
-  return data;
+  return dataArray;
+}
+function getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName) {
+  const json = scenegraph.gltf.json;
+  if (!json.meshes) {
+    return [];
+  }
+  const featureTextureTable = [];
+  for (const mesh of json.meshes) {
+    for (const primitive of mesh.primitives) {
+      processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive);
+    }
+  }
+  return featureTextureTable;
+}
+function processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive) {
+  const json = scenegraph.gltf.json;
+  const textureData = [];
+  const texCoordAccessorKey = `TEXCOORD_${featureTextureProperty.texture.texCoord}`;
+  const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
+  const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
+  const texCoordArray = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
+  const textureCoordinates = new Float32Array(texCoordArray.buffer, texCoordArray.byteOffset, texCoordArray.length / 4);
+  const textureIndex = featureTextureProperty.texture.index;
+  const texture = json.textures?.[textureIndex];
+  const imageIndex = texture?.source;
+  if (typeof imageIndex !== "undefined") {
+    const image = json.images?.[imageIndex];
+    const mimeType = image?.mimeType;
+    const parsedImage = scenegraph.gltf.images?.[imageIndex];
+    if (parsedImage) {
+      for (let index = 0; index < textureCoordinates.length; index += 2) {
+        const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, featureTextureProperty.channels);
+        textureData.push(value);
+      }
+    }
+  }
+  const featureIndices = [];
+  for (const texelData of textureData) {
+    let index = featureTextureTable.findIndex((item) => item === texelData);
+    if (index === -1) {
+      index = featureTextureTable.push(texelData) - 1;
+    }
+    featureIndices.push(index);
+  }
+  const typedArray = new Uint32Array(featureIndices);
+  const bufferIndex = scenegraph.gltf.buffers.push({
+    arrayBuffer: typedArray.buffer,
+    byteOffset: 0,
+    byteLength: typedArray.byteLength
+  }) - 1;
+  const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
+  const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+    size: 1,
+    componentType: getComponentTypeFromArray(typedArray),
+    count: typedArray.length
+  });
+  primitive.attributes[attributeName] = accessorIndex;
+}
+function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels) {
+  const CHANNELS_MAP = {
+    r: { offset: 0, shift: 0 },
+    g: { offset: 1, shift: 8 },
+    b: { offset: 2, shift: 16 },
+    a: { offset: 3, shift: 24 }
+  };
+  const u = textureCoordinates[index];
+  const v = textureCoordinates[index + 1];
+  let components = 1;
+  if (mimeType && (mimeType.indexOf("image/jpeg") !== -1 || mimeType.indexOf("image/png") !== -1))
+    components = 4;
+  const offset = coordinatesToOffset(u, v, parsedImage, components);
+  let value = 0;
+  for (const c of channels) {
+    const map = CHANNELS_MAP[c];
+    const val = getVal(parsedImage, offset + map.offset);
+    value |= val << map.shift;
+  }
+  return value;
+}
+function getVal(parsedImage, offset) {
+  const imageData = getImageData(parsedImage);
+  if (imageData.data.length <= offset) {
+    throw new Error(`${imageData.data.length} <= ${offset}`);
+  }
+  return imageData.data[offset];
+}
+function coordinatesToOffset(u, v, parsedImage, componentsCount = 1) {
+  const w = parsedImage.width;
+  const iX = emod(u) * (w - 1);
+  const indX = Math.round(iX);
+  const h = parsedImage.height;
+  const iY = emod(v) * (h - 1);
+  const indY = Math.round(iY);
+  const components = parsedImage.components ? parsedImage.components : componentsCount;
+  const offset = (indY * w + indX) * components;
+  return offset;
+}
+function emod(n) {
+  const a = (n % 1 + 1) % 1;
+  return a;
 }
 function findFeatureTableByName(featureTables, schemaClassName) {
   for (const featureTableName in featureTables) {
@@ -56227,6 +56372,15 @@ function findFeatureTableByName(featureTables, schemaClassName) {
   }
   return null;
 }
+function findFeatureTextureByName(featureTextures, schemaClassName) {
+  for (const featureTexturesName in featureTextures) {
+    const featureTable = featureTextures[featureTexturesName];
+    if (featureTable.class === schemaClassName) {
+      return featureTable;
+    }
+  }
+  return null;
+}
 function getStringAttributes(data, offsetsData, stringsCount) {
   const stringsArray = [];
   const textDecoder = new TextDecoder("utf8");
@@ -56489,17 +56643,13 @@ async function parseGLTF(gltf, arrayBufferOrString, byteOffset = 0, options, con
   parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);
   normalizeGLTFV1(gltf, { normalize: options?.gltf?.normalize });
   preprocessExtensions(gltf, options, context);
-  const promises = [];
   if (options?.gltf?.loadBuffers && gltf.json.buffers) {
     await loadBuffers(gltf, options, context);
   }
   if (options?.gltf?.loadImages) {
-    const promise2 = loadImages(gltf, options, context);
-    promises.push(promise2);
+    await loadImages(gltf, options, context);
   }
-  const promise = decodeExtensions(gltf, options, context);
-  promises.push(promise);
-  await Promise.all(promises);
+  await decodeExtensions(gltf, options, context);
   return gltf;
 }
 function parseGLTFContainerSync(gltf, data, byteOffset, options) {
@@ -57022,11 +57172,11 @@ var GLTF_FORMAT = {
 };
 function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options) {
   tile.rotateYtoZ = true;
-  const gltfByteLength = tile.byteOffset + tile.byteLength - byteOffset;
+  const gltfByteLength = (tile.byteOffset || 0) + (tile.byteLength || 0) - byteOffset;
   if (gltfByteLength === 0) {
     throw new Error("glTF byte length must be greater than 0.");
   }
-  tile.gltfUpAxis = options["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
+  tile.gltfUpAxis = options?.["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
   tile.gltfArrayBuffer = sliceArrayBuffer(arrayBuffer, byteOffset, gltfByteLength);
   tile.gltfByteOffset = 0;
   tile.gltfByteLength = gltfByteLength;
@@ -57034,15 +57184,19 @@ function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options) {
   } else {
     console.warn(`${tile.type}: embedded glb is not aligned to a 4-byte boundary.`);
   }
-  return tile.byteOffset + tile.byteLength;
+  return (tile.byteOffset || 0) + (tile.byteLength || 0);
 }
 async function extractGLTF(tile, gltfFormat, options, context) {
-  const tile3DOptions = options["3d-tiles"] || {};
+  const tile3DOptions = options?.["3d-tiles"] || {};
   extractGLTFBufferOrURL(tile, gltfFormat, options);
   if (tile3DOptions.loadGLTF) {
+    if (!context) {
+      return;
+    }
     const { parse: parse7, fetch: fetch2 } = context;
     if (tile.gltfUrl) {
-      tile.gltfArrayBuffer = await fetch2(tile.gltfUrl, options);
+      const response = await fetch2(tile.gltfUrl, options);
+      tile.gltfArrayBuffer = await response.arrayBuffer();
       tile.gltfByteOffset = 0;
     }
     if (tile.gltfArrayBuffer) {
@@ -57058,10 +57212,12 @@ async function extractGLTF(tile, gltfFormat, options, context) {
 function extractGLTFBufferOrURL(tile, gltfFormat, options) {
   switch (gltfFormat) {
     case GLTF_FORMAT.URI:
-      const gltfUrlBytes = new Uint8Array(tile.gltfArrayBuffer, tile.gltfByteOffset);
-      const textDecoder = new TextDecoder();
-      const gltfUrl = textDecoder.decode(gltfUrlBytes);
-      tile.gltfUrl = gltfUrl.replace(/[\s\0]+$/, "");
+      if (tile.gltfArrayBuffer) {
+        const gltfUrlBytes = new Uint8Array(tile.gltfArrayBuffer, tile.gltfByteOffset);
+        const textDecoder = new TextDecoder();
+        const gltfUrl = textDecoder.decode(gltfUrlBytes);
+        tile.gltfUrl = gltfUrl.replace(/[\s\0]+$/, "");
+      }
       delete tile.gltfArrayBuffer;
       delete tile.gltfByteOffset;
       delete tile.gltfByteLength;
@@ -57098,7 +57254,7 @@ var import_core16 = __toModule(require_es5());
 var import_geospatial7 = __toModule(require_es52());
 async function parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
   byteOffset = parseInstancedModel(tile, arrayBuffer, byteOffset, options, context);
-  await extractGLTF(tile, tile.gltfFormat, options, context);
+  await extractGLTF(tile, tile.gltfFormat || 0, options, context);
   return byteOffset;
 }
 function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
@@ -57112,7 +57268,7 @@ function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
   byteOffset += 4;
   byteOffset = parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options);
   byteOffset = parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options);
-  if (tile.featureTableJsonByteLength === 0) {
+  if (!tile?.header?.featureTableJsonByteLength || tile.header.featureTableJsonByteLength === 0) {
     throw new Error("i3dm parser: featureTableJsonByteLength is zero.");
   }
   const featureTable = new Tile3DFeatureTable(tile.featureTableJson, tile.featureTableBinary);
@@ -57128,17 +57284,7 @@ function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
   return byteOffset;
 }
 function extractInstancedAttributes(tile, featureTable, batchTable, instancesLength) {
-  const collectionOptions = {
-    instances: new Array(instancesLength),
-    batchTable: tile._batchTable,
-    cull: false,
-    url: void 0,
-    gltf: void 0,
-    basePath: void 0,
-    incrementallyLoadTextures: false,
-    forwardAxis: [1, 0, 0]
-  };
-  const instances = collectionOptions.instances;
+  const instances = new Array(instancesLength);
   const instancePosition = new import_core16.Vector3();
   const instanceNormalRight = new import_core16.Vector3();
   const instanceNormalUp = new import_core16.Vector3();
@@ -57150,19 +57296,19 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
   const instanceTransform = new import_core16.Matrix4();
   const scratch1 = [];
   const scratch2 = [];
-  const scratchVector1 = new import_core16.Vector3();
-  const scratchVector23 = new import_core16.Vector3();
+  const scratch3 = [];
+  const scratch4 = [];
   for (let i = 0; i < instancesLength; i++) {
     let position;
     if (featureTable.hasProperty("POSITION")) {
       position = featureTable.getProperty("POSITION", GL2.FLOAT, 3, i, instancePosition);
     } else if (featureTable.hasProperty("POSITION_QUANTIZED")) {
       position = featureTable.getProperty("POSITION_QUANTIZED", GL2.UNSIGNED_SHORT, 3, i, instancePosition);
-      const quantizedVolumeOffset = featureTable.getGlobalProperty("QUANTIZED_VOLUME_OFFSET", GL2.FLOAT, 3, scratchVector1);
+      const quantizedVolumeOffset = featureTable.getGlobalProperty("QUANTIZED_VOLUME_OFFSET", GL2.FLOAT, 3);
       if (!quantizedVolumeOffset) {
         throw new Error("i3dm parser: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions.");
       }
-      const quantizedVolumeScale = featureTable.getGlobalProperty("QUANTIZED_VOLUME_SCALE", GL2.FLOAT, 3, scratchVector23);
+      const quantizedVolumeScale = featureTable.getGlobalProperty("QUANTIZED_VOLUME_SCALE", GL2.FLOAT, 3);
       if (!quantizedVolumeScale) {
         throw new Error("i3dm parser: QUANTIZED_VOLUME_SCALE must be defined for quantized positions.");
       }
@@ -57185,8 +57331,8 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
       }
       tile.hasCustomOrientation = true;
     } else {
-      tile.octNormalUp = featureTable.getProperty("NORMAL_UP_OCT32P", GL2.UNSIGNED_SHORT, 2, scratch1);
-      tile.octNormalRight = featureTable.getProperty("NORMAL_RIGHT_OCT32P", GL2.UNSIGNED_SHORT, 2, scratch2);
+      tile.octNormalUp = featureTable.getProperty("NORMAL_UP_OCT32P", GL2.UNSIGNED_SHORT, 2, i, scratch1);
+      tile.octNormalRight = featureTable.getProperty("NORMAL_RIGHT_OCT32P", GL2.UNSIGNED_SHORT, 2, i, scratch2);
       if (tile.octNormalUp) {
         if (!tile.octNormalRight) {
           throw new Error("i3dm: oct-encoded orientation requires NORMAL_UP_OCT32P and NORMAL_RIGHT_OCT32P");
@@ -57208,7 +57354,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
     instanceQuaternion.fromMatrix3(instanceRotation);
     instanceTranslationRotationScale.rotation = instanceQuaternion;
     instanceScale.set(1, 1, 1);
-    const scale = featureTable.getProperty("SCALE", GL2.FLOAT, 1, i);
+    const scale = featureTable.getProperty("SCALE", GL2.FLOAT, 1, i, scratch3);
     if (Number.isFinite(scale)) {
       instanceScale.multiplyByScalar(scale);
     }
@@ -57217,7 +57363,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
       instanceScale.scale(nonUniformScale);
     }
     instanceTranslationRotationScale.scale = instanceScale;
-    let batchId = featureTable.getProperty("BATCH_ID", GL2.UNSIGNED_SHORT, 1, i);
+    let batchId = featureTable.getProperty("BATCH_ID", GL2.UNSIGNED_SHORT, 1, i, scratch4);
     if (batchId === void 0) {
       batchId = i;
     }
@@ -57242,7 +57388,7 @@ async function parseComposite3DTile(tile, arrayBuffer, byteOffset, options, cont
   tile.tilesLength = view.getUint32(byteOffset, true);
   byteOffset += 4;
   tile.tiles = [];
-  while (tile.tiles.length < tile.tilesLength && tile.byteLength - byteOffset > 12) {
+  while (tile.tiles.length < tile.tilesLength && (tile.byteLength || 0) - byteOffset > 12) {
     const subtile = {};
     tile.tiles.push(subtile);
     byteOffset = await parse3DTile2(arrayBuffer, byteOffset, options, context, subtile);
@@ -57253,11 +57399,18 @@ async function parseComposite3DTile(tile, arrayBuffer, byteOffset, options, cont
 // ../3d-tiles/src/lib/parsers/parse-3d-tile-gltf.ts
 async function parseGltf3DTile(tile, arrayBuffer, options, context) {
   tile.rotateYtoZ = true;
-  tile.gltfUpAxis = options["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
-  const { parse: parse7 } = context;
-  const gltfWithBuffers = await parse7(arrayBuffer, GLTFLoader, options, context);
-  tile.gltf = postProcessGLTF(gltfWithBuffers);
-  tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
+  tile.gltfUpAxis = options?.["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
+  if (options?.["3d-tiles"]?.loadGLTF) {
+    if (!context) {
+      return;
+    }
+    const { parse: parse7 } = context;
+    const gltfWithBuffers = await parse7(arrayBuffer, GLTFLoader, options, context);
+    tile.gltf = postProcessGLTF(gltfWithBuffers);
+    tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
+  } else {
+    tile.gltfArrayBuffer = arrayBuffer;
+  }
 }
 
 // ../3d-tiles/src/lib/parsers/parse-3d-tile.ts
@@ -58735,11 +58888,11 @@ function getBooleanValueFromBitstream(availabilityIndex, availabilityBuffer) {
 }
 
 // ../3d-tiles/src/lib/parsers/parse-3d-tile-header.ts
-function getTileType(tile) {
-  if (!tile.contentUrl) {
+function getTileType(tile, tileContentUrl = "") {
+  if (!tileContentUrl) {
     return TILE_TYPE.EMPTY;
   }
-  const contentUrl = tile.contentUrl.split("?")[0];
+  const contentUrl = tileContentUrl.split("?")[0];
   const fileExtension = contentUrl.split(".").pop();
   switch (fileExtension) {
     case "pnts":
@@ -58750,7 +58903,7 @@ function getTileType(tile) {
     case "gltf":
       return TILE_TYPE.SCENEGRAPH;
     default:
-      return fileExtension;
+      return fileExtension || TILE_TYPE.EMPTY;
   }
 }
 function getRefine(refine) {
@@ -58765,7 +58918,7 @@ function getRefine(refine) {
       return refine;
   }
 }
-function resolveUri(uri, basePath) {
+function resolveUri(uri = "", basePath) {
   const urlSchemeRegex = /^[a-z][0-9a-z+.-]*:/i;
   if (urlSchemeRegex.test(basePath)) {
     const url = new URL(uri, `${basePath}/`);
@@ -58775,50 +58928,59 @@ function resolveUri(uri, basePath) {
   }
   return `${basePath}/${uri}`;
 }
-function normalizeTileData(tile, options) {
+function normalizeTileData(tile, basePath) {
   if (!tile) {
     return null;
   }
+  let tileContentUrl;
   if (tile.content) {
-    const contentUri = tile.content.uri || tile.content.url;
-    tile.contentUrl = resolveUri(contentUri, options.basePath);
-  }
-  tile.id = tile.contentUrl;
-  tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-  tile.lodMetricValue = tile.geometricError;
-  tile.transformMatrix = tile.transform;
-  tile.type = getTileType(tile);
-  tile.refine = getRefine(tile.refine);
-  return tile;
+    const contentUri = tile.content.uri || tile.content?.url;
+    tileContentUrl = resolveUri(contentUri, basePath);
+  }
+  const tilePostprocessed = {
+    ...tile,
+    id: tileContentUrl,
+    contentUrl: tileContentUrl,
+    lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+    lodMetricValue: tile.geometricError,
+    transformMatrix: tile.transform,
+    type: getTileType(tile, tileContentUrl),
+    refine: getRefine(tile.refine)
+  };
+  return tilePostprocessed;
 }
-async function normalizeTileHeaders(tileset, options) {
-  const basePath = tileset.basePath;
-  let root;
-  const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset?.root);
+async function normalizeTileHeaders(tileset, basePath, options) {
+  let root = null;
+  const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset.root);
   if (rootImplicitTilingExtension && tileset.root) {
-    root = await normalizeImplicitTileHeaders(tileset.root, tileset, rootImplicitTilingExtension, options);
+    root = await normalizeImplicitTileHeaders(tileset.root, tileset, basePath, rootImplicitTilingExtension, options);
   } else {
-    root = normalizeTileData(tileset.root, tileset);
+    root = normalizeTileData(tileset.root, basePath);
   }
   const stack2 = [];
   stack2.push(root);
   while (stack2.length > 0) {
     const tile = stack2.pop() || {};
     const children = tile.children || [];
-    for (let childHeader of children) {
+    const childrenPostprocessed = [];
+    for (const childHeader of children) {
       const childImplicitTilingExtension = getImplicitTilingExtensionData(childHeader);
+      let childHeaderPostprocessed;
       if (childImplicitTilingExtension) {
-        childHeader = await normalizeImplicitTileHeaders(childHeader, tileset, childImplicitTilingExtension, options);
+        childHeaderPostprocessed = await normalizeImplicitTileHeaders(childHeader, tileset, basePath, childImplicitTilingExtension, options);
       } else {
-        normalizeTileData(childHeader, { basePath });
+        childHeaderPostprocessed = normalizeTileData(childHeader, basePath);
+      }
+      if (childHeaderPostprocessed) {
+        childrenPostprocessed.push(childHeaderPostprocessed);
+        stack2.push(childHeaderPostprocessed);
       }
-      stack2.push(childHeader);
     }
+    tile.children = childrenPostprocessed;
   }
   return root;
 }
-async function normalizeImplicitTileHeaders(tile, tileset, implicitTilingExtension, options) {
-  const basePath = tileset.basePath;
+async function normalizeImplicitTileHeaders(tile, tileset, basePath, implicitTilingExtension, options) {
   const {
     subdivisionScheme,
     maximumLevel,
@@ -58828,7 +58990,7 @@ async function normalizeImplicitTileHeaders(tile, tileset, implicitTilingExtensi
   const replacedUrlTemplate = replaceContentUrlTemplate(subtreesUriTemplate, 0, 0, 0, 0);
   const subtreeUrl = resolveUri(replacedUrlTemplate, basePath);
   const subtree = await load(subtreeUrl, Tile3DSubtreeLoader, options);
-  const contentUrlTemplate = resolveUri(tile.content.uri, basePath);
+  const contentUrlTemplate = resolveUri(tile.content?.uri, basePath);
   const refine = tileset?.root?.refine;
   const rootLodMetricValue = tile.geometricError;
   const s2VolumeInfo = tile.boundingVolume.extensions?.["3DTILES_bounding_volume_S2"];
@@ -58852,29 +59014,35 @@ async function normalizeImplicitTileHeaders(tile, tileset, implicitTilingExtensi
     getTileType,
     getRefine
   };
-  return await normalizeImplicitTileData(tile, subtree, implicitOptions);
+  return await normalizeImplicitTileData(tile, basePath, subtree, implicitOptions);
 }
-async function normalizeImplicitTileData(tile, rootSubtree, options) {
+async function normalizeImplicitTileData(tile, basePath, rootSubtree, options) {
   if (!tile) {
     return null;
   }
-  tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-  tile.lodMetricValue = tile.geometricError;
-  tile.transformMatrix = tile.transform;
   const { children, contentUrl } = await parseImplicitTiles({
     subtree: rootSubtree,
-    options,
-    s2VolumeBox: tile
+    options
   });
+  let tileContentUrl;
+  let tileContent = null;
   if (contentUrl) {
-    tile.contentUrl = contentUrl;
-    tile.content = { uri: contentUrl.replace(`${options.basePath}/`, "") };
+    tileContentUrl = contentUrl;
+    tileContent = { uri: contentUrl.replace(`${basePath}/`, "") };
   }
-  tile.refine = getRefine(tile.refine);
-  tile.type = getTileType(tile);
-  tile.children = children;
-  tile.id = tile.contentUrl;
-  return tile;
+  const tilePostprocessed = {
+    ...tile,
+    id: tileContentUrl,
+    contentUrl: tileContentUrl,
+    lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+    lodMetricValue: tile.geometricError,
+    transformMatrix: tile.transform,
+    type: getTileType(tile, tileContentUrl),
+    refine: getRefine(tile.refine),
+    content: tileContent || tile.content,
+    children
+  };
+  return tilePostprocessed;
 }
 function getImplicitTilingExtensionData(tile) {
   return tile?.extensions?.["3DTILES_implicit_tiling"] || tile?.implicitTiling;
@@ -58907,19 +59075,25 @@ async function parse4(data, options = {}, context) {
   } else {
     isTileset = loaderOptions.isTileset;
   }
-  return await isTileset ? parseTileset(data, options, context) : parseTile(data, options, context);
+  return isTileset ? parseTileset(data, options, context) : parseTile(data, options, context);
 }
 async function parseTileset(data, options, context) {
   const tilesetJson = JSON.parse(new TextDecoder().decode(data));
-  tilesetJson.loader = options?.loader || Tiles3DLoader;
-  tilesetJson.url = context?.url || "";
-  tilesetJson.queryString = context?.queryString || "";
-  tilesetJson.basePath = getBaseUri(tilesetJson);
-  tilesetJson.root = await normalizeTileHeaders(tilesetJson, options || {});
-  tilesetJson.type = TILESET_TYPE.TILES3D;
-  tilesetJson.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-  tilesetJson.lodMetricValue = tilesetJson.root?.lodMetricValue || 0;
-  return tilesetJson;
+  const tilesetUrl = context?.url || "";
+  const basePath = getBaseUri(tilesetUrl);
+  const normalizedRoot = await normalizeTileHeaders(tilesetJson, basePath, options || {});
+  const tilesetJsonPostprocessed = {
+    ...tilesetJson,
+    loader: Tiles3DLoader,
+    url: tilesetUrl,
+    queryString: context?.queryString || "",
+    basePath,
+    root: normalizedRoot || tilesetJson.root,
+    type: TILESET_TYPE.TILES3D,
+    lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+    lodMetricValue: tilesetJson.root?.geometricError || 0
+  };
+  return tilesetJsonPostprocessed;
 }
 async function parseTile(arrayBuffer, options, context) {
   const tile = {
@@ -58931,8 +59105,8 @@ async function parseTile(arrayBuffer, options, context) {
   await parse3DTile(arrayBuffer, byteOffset, options, context, tile.content);
   return tile.content;
 }
-function getBaseUri(tileset) {
-  return path_exports.dirname(tileset.url);
+function getBaseUri(tilesetUrl) {
+  return path_exports.dirname(tilesetUrl);
 }
 
 // ../3d-tiles/src/lib/ion/ion.ts
@@ -59193,7 +59367,7 @@ async function isFileExists(fileName) {
   }
 }
 function removeDir(path2) {
-  return import_fs3.promises.rmdir(path2, { recursive: true });
+  return import_fs3.promises.rm(path2, { recursive: true });
 }
 function removeFile(path2) {
   return import_fs3.promises.unlink(path2);
@@ -59440,8 +59614,8 @@ async function getTotalFilesSize(dirPath) {
 }
 
 // src/i3s-converter/helpers/geometry-converter.ts
-var import_core24 = __toModule(require_es5());
-var import_geospatial10 = __toModule(require_es52());
+var import_core25 = __toModule(require_es5());
+var import_geospatial11 = __toModule(require_es52());
 var import_md5 = __toModule(require_md52());
 
 // src/i3s-converter/helpers/geometry-attributes.ts
@@ -59615,19 +59789,18 @@ function groupAttributesAndRangesByFeatureId(unifiedObjects, featureCount) {
 var import_core23 = __toModule(require_es5());
 var import_geospatial9 = __toModule(require_es52());
 var import_culling6 = __toModule(require_es53());
-function createBoundingVolumes(tile, geoidHeightModel) {
+function createBoundingVolumes(sourceBoundingVolume, geoidHeightModel) {
   let radius;
   let halfSize;
   let quaternion;
-  const boundingVolume = tile.boundingVolume;
-  const cartographicCenter = import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(boundingVolume.center, new import_core23.Vector3());
+  const cartographicCenter = import_geospatial9.Ellipsoid.WGS84.cartesianToCartographic(sourceBoundingVolume.center, new import_core23.Vector3());
   cartographicCenter[2] = cartographicCenter[2] - geoidHeightModel.getHeight(cartographicCenter[1], cartographicCenter[0]);
-  if (boundingVolume instanceof import_culling6.OrientedBoundingBox) {
-    halfSize = boundingVolume.halfSize;
+  if (sourceBoundingVolume instanceof import_culling6.OrientedBoundingBox) {
+    halfSize = sourceBoundingVolume.halfSize;
     radius = new import_core23.Vector3(halfSize[0], halfSize[1], halfSize[2]).len();
-    quaternion = boundingVolume.quaternion;
+    quaternion = sourceBoundingVolume.quaternion;
   } else {
-    radius = tile.boundingVolume.radius;
+    radius = sourceBoundingVolume.radius;
     halfSize = [radius, radius, radius];
     quaternion = new import_core23.Quaternion().fromMatrix3(new import_core23.Matrix3([halfSize[0], 0, 0, 0, halfSize[1], 0, 0, 0, halfSize[2]])).normalize();
   }
@@ -59693,16 +59866,9 @@ function createObbFromMbs(mbs) {
 }
 
 // src/i3s-converter/helpers/gltf-attributes.ts
-function getB3DMAttributesWithoutBufferView(attributes) {
-  const attributesWithoutBufferView = {};
-  for (const attributeName in attributes) {
-    attributesWithoutBufferView[attributeName] = {
-      value: attributes[attributeName].value
-    };
-  }
-  return attributesWithoutBufferView;
-}
-function prepareDataForAttributesConversion(tileContent) {
+var import_core24 = __toModule(require_es5());
+var import_geospatial10 = __toModule(require_es52());
+function prepareDataForAttributesConversion(tileContent, tileTransform, boundingVolume) {
   let nodes = tileContent.gltf?.scene?.nodes || tileContent.gltf?.scenes?.[0]?.nodes || tileContent.gltf?.nodes || [];
   const images = tileContent.gltf?.images?.map((imageObject) => {
     if (imageObject?.image?.compressed) {
@@ -59722,8 +59888,7 @@ function prepareDataForAttributesConversion(tileContent) {
     }
   }) || [];
   prepareNodes(nodes);
-  const cartographicOrigin = tileContent.cartographicOrigin;
-  const cartesianModelMatrix = tileContent.cartesianModelMatrix;
+  const { cartographicOrigin, modelMatrix: cartesianModelMatrix } = calculateTransformProps2(tileContent, tileTransform, boundingVolume);
   return {
     nodes,
     images,
@@ -59731,6 +59896,40 @@ function prepareDataForAttributesConversion(tileContent) {
     cartesianModelMatrix
   };
 }
+function getB3DMAttributesWithoutBufferView(attributes) {
+  const attributesWithoutBufferView = {};
+  for (const attributeName in attributes) {
+    attributesWithoutBufferView[attributeName] = {
+      value: attributes[attributeName].value
+    };
+  }
+  return attributesWithoutBufferView;
+}
+function calculateTransformProps2(tileContent, tileTransform, boundingVolume) {
+  const { rtcCenter, gltfUpAxis } = tileContent;
+  const { center } = boundingVolume;
+  let modelMatrix = new import_core24.Matrix4(tileTransform);
+  if (rtcCenter) {
+    modelMatrix.translate(rtcCenter);
+  }
+  switch (gltfUpAxis) {
+    case "Z":
+      break;
+    case "Y":
+      const rotationY = new import_core24.Matrix4().rotateX(Math.PI / 2);
+      modelMatrix = modelMatrix.multiplyRight(rotationY);
+      break;
+    case "X":
+      const rotationX = new import_core24.Matrix4().rotateY(-Math.PI / 2);
+      modelMatrix = modelMatrix.multiplyRight(rotationX);
+      break;
+    default:
+      break;
+  }
+  const cartesianOrigin = new import_core24.Vector3(center);
+  const cartographicOrigin = import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new import_core24.Vector3());
+  return { modelMatrix, cartographicOrigin };
+}
 function prepareNodes(nodes) {
   for (let index = 0; index < nodes.length; index++) {
     const node2 = nodes[index];
@@ -59797,8 +59996,8 @@ function handleExtFeatureMetadataExtension(attributes, extFeatureMetadata, image
   }
   const featureTexture = extFeatureMetadata?.featureTextures && extFeatureMetadata?.featureTextures[0];
   if (featureTexture) {
-    console.warn("EXT_feature_metadata doesn't yet support featureTextures in primitive");
-    return [];
+    const batchIdsAttribute = attributes[featureTexture];
+    return batchIdsAttribute.value;
   }
   return [];
 }
@@ -59842,8 +60041,8 @@ function generateBatchIdsFromTexture(featureIdTexture, textureCoordinates, image
     for (let index = 0; index < textureCoordinates.length; index += 2) {
       const u = textureCoordinates[index];
       const v = textureCoordinates[index + 1];
-      const tx = Math.min(emod(u) * image.width | 0, image.width - 1);
-      const ty = Math.min(emod(v) * image.height | 0, image.height - 1);
+      const tx = Math.min(emod2(u) * image.width | 0, image.width - 1);
+      const ty = Math.min(emod2(v) * image.height | 0, image.height - 1);
       const offset = (ty * image.width + tx) * image.components + channels;
       const batchId = new Uint8Array(image.data)[offset];
       batchIds.push(batchId);
@@ -59853,7 +60052,7 @@ function generateBatchIdsFromTexture(featureIdTexture, textureCoordinates, image
   }
   return batchIds;
 }
-function emod(n) {
+function emod2(n) {
   return (n % 1 + 1) % 1;
 }
 
@@ -60018,11 +60217,11 @@ var OBJECT_ID_TYPE2 = "Oid32";
 var BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES = ["CUSTOM_ATTRIBUTE_2", "_BATCHID", "BATCHID"];
 var EXT_FEATURE_METADATA3 = "EXT_feature_metadata";
 var EXT_MESH_FEATURES2 = "EXT_mesh_features";
-var scratchVector5 = new import_core24.Vector3();
-async function convertB3dmToI3sGeometry(tileContent, addNodeToNodePage, propertyTable, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, shouldMergeMaterials, geoidHeightModel, workerSource) {
+var scratchVector5 = new import_core25.Vector3();
+async function convertB3dmToI3sGeometry(tileContent, tileTransform, tileBoundingVolume, addNodeToNodePage, propertyTable, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, shouldMergeMaterials, geoidHeightModel, workerSource) {
   const useCartesianPositions = generateBoundingVolumes;
   const materialAndTextureList = await convertMaterials(tileContent.gltf?.materials, shouldMergeMaterials);
-  const dataForAttributesConversion = prepareDataForAttributesConversion(tileContent);
+  const dataForAttributesConversion = prepareDataForAttributesConversion(tileContent, tileTransform, tileBoundingVolume);
   const convertedAttributesMap = await convertAttributes(dataForAttributesConversion, materialAndTextureList, useCartesianPositions);
   if (generateBoundingVolumes) {
     _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeightModel);
@@ -60064,7 +60263,7 @@ function _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeigh
     const cartographicOrigin = boundingVolumes.obb.center;
     for (let index = 0; index < attributes.positions.length; index += VALUES_PER_VERTEX2) {
       const vertex = attributes.positions.subarray(index, index + VALUES_PER_VERTEX2);
-      import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic(Array.from(vertex), scratchVector5);
+      import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(Array.from(vertex), scratchVector5);
       scratchVector5[2] = scratchVector5[2] - geoidHeightModel.getHeight(scratchVector5[1], scratchVector5[0]);
       scratchVector5 = scratchVector5.subtract(cartographicOrigin);
       attributes.positions.set(scratchVector5, index);
@@ -60156,7 +60355,7 @@ async function convertAttributes(attributesData, materialAndTextureList, useCart
   }
   return attributesMap;
 }
-function convertNodes(nodes, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new import_core24.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertNodes(nodes, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new import_core25.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
   if (nodes) {
     for (const node2 of nodes) {
       convertNode(node2, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix);
@@ -60180,7 +60379,7 @@ function getCompositeTransformationMatrix(node2, matrix) {
   }
   return transformationMatrix;
 }
-function convertNode(node2, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new import_core24.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertNode(node2, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new import_core25.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
   const transformationMatrix = getCompositeTransformationMatrix(node2, matrix);
   const mesh = node2.mesh;
   if (mesh) {
@@ -60188,7 +60387,7 @@ function convertNode(node2, images, cartographicOrigin, cartesianModelMatrix, at
   }
   convertNodes(node2.children || [], images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix);
 }
-function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions = false, matrix = new import_core24.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions = false, matrix = new import_core25.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
   for (const primitive of mesh.primitives) {
     let outputAttributes = null;
     let materialUvRegion;
@@ -60199,7 +60398,7 @@ function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, att
       outputAttributes = attributesMap.get("default");
     }
     assert2(outputAttributes !== null, "Primitive - material mapping failed");
-    assert2(primitive.mode === GL2.TRIANGLES || primitive.mode === GL2.TRIANGLE_STRIP, `Primitive - unsupported mode ${primitive.mode}`);
+    assert2(primitive.mode === void 0 || primitive.mode === GL2.TRIANGLES || primitive.mode === GL2.TRIANGLE_STRIP, `Primitive - unsupported mode ${primitive.mode}`);
     const attributes = primitive.attributes;
     if (!outputAttributes) {
       continue;
@@ -60266,7 +60465,7 @@ function transformVertexArray(args) {
   for (let i = 0; i < indices.length; i++) {
     const coordIndex = indices[i] * VALUES_PER_VERTEX2;
     const vertex = vertices.subarray(coordIndex, coordIndex + VALUES_PER_VERTEX2);
-    let vertexVector = new import_core24.Vector3(Array.from(vertex));
+    let vertexVector = new import_core25.Vector3(Array.from(vertex));
     vertexVector = attributeSpecificTransformation(vertexVector, args);
     newVertices[i * VALUES_PER_VERTEX2] = vertexVector.x;
     newVertices[i * VALUES_PER_VERTEX2 + 1] = vertexVector.y;
@@ -60283,7 +60482,7 @@ function transformVertexPositions(vertexVector, calleeArgs) {
   if (useCartesianPositions) {
     return vertexVector;
   }
-  import_geospatial10.Ellipsoid.WGS84.cartesianToCartographic([vertexVector[0], vertexVector[1], vertexVector[2]], vertexVector);
+  import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic([vertexVector[0], vertexVector[1], vertexVector[2]], vertexVector);
   vertexVector = vertexVector.subtract(cartographicOrigin);
   return vertexVector;
 }
@@ -60518,10 +60717,10 @@ function convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId) {
 }
 function extractSharedResourcesMaterialInfo(baseColorFactor, metallicFactor = 1) {
   const matDielectricColorComponent = 0.04 / 255;
-  const black = new import_core24.Vector4(0, 0, 0, 1);
-  const unitVector = new import_core24.Vector4(1, 1, 1, 1);
-  const dielectricSpecular = new import_core24.Vector4(matDielectricColorComponent, matDielectricColorComponent, matDielectricColorComponent, 0);
-  const baseColorVector = new import_core24.Vector4(baseColorFactor);
+  const black = new import_core25.Vector4(0, 0, 0, 1);
+  const unitVector = new import_core25.Vector4(1, 1, 1, 1);
+  const dielectricSpecular = new import_core25.Vector4(matDielectricColorComponent, matDielectricColorComponent, matDielectricColorComponent, 0);
+  const baseColorVector = new import_core25.Vector4(baseColorFactor);
   const firstOperand = unitVector.subtract(dielectricSpecular).multiply(baseColorVector);
   const diffuse = firstOperand.lerp(firstOperand, black, metallicFactor);
   dielectricSpecular[3] = 1;
@@ -60723,6 +60922,9 @@ function generateFeatureIndexAttribute(featureIndex, faceRange) {
   return orderedFeatureIndices;
 }
 function getPropertyTable(tileContent) {
+  if (!tileContent) {
+    return null;
+  }
   const batchTableJson = tileContent?.batchTableJson;
   if (batchTableJson) {
     return batchTableJson;
@@ -60757,10 +60959,6 @@ function getPropertyTableExtension(tileContent) {
   return { extensionName, extension };
 }
 function getPropertyTableFromExtFeatureMetadata(extension) {
-  if (extension?.featureTextures) {
-    console.warn("The I3S converter does not yet support the EXT_feature_metadata feature textures");
-    return null;
-  }
   if (extension?.featureTables) {
     const firstFeatureTableName = Object.keys(extension.featureTables)?.[0];
     if (firstFeatureTableName) {
@@ -60772,7 +60970,18 @@ function getPropertyTableFromExtFeatureMetadata(extension) {
       return propertyTable;
     }
   }
-  console.warn("The I3S converter couldn't handle EXT_feature_metadata extension");
+  if (extension?.featureTextures) {
+    const firstTextureName = Object.keys(extension.featureTextures)?.[0];
+    if (firstTextureName) {
+      const featureTable = extension?.featureTextures[firstTextureName];
+      const propertyTable = {};
+      for (const propertyName in featureTable.properties) {
+        propertyTable[propertyName] = featureTable.properties[propertyName].data;
+      }
+      return propertyTable;
+    }
+  }
+  console.warn("The I3S converter couldn't handle EXT_feature_metadata extension: There is neither featureTables, no featureTextures in the extension.");
   return null;
 }
 
@@ -61320,8 +61529,8 @@ function transfromTextureDefinitions(textureDefinitionInfos, thisObject, origina
 
 // src/i3s-converter/helpers/node-debug.ts
 var import_culling7 = __toModule(require_es53());
-var import_core26 = __toModule(require_es5());
-var import_geospatial11 = __toModule(require_es52());
+var import_core27 = __toModule(require_es5());
+var import_geospatial12 = __toModule(require_es52());
 var CUBE_POSITIONS = new Float32Array([
   -1,
   -1,
@@ -61434,10 +61643,10 @@ function createBoundingBoxFromTileObb(obb) {
 function getTileObbVertices(node2) {
   const halfSize = node2.obb.halfSize;
   const positions = CUBE_POSITIONS;
-  const obbCenterCartesian = import_geospatial11.Ellipsoid.WGS84.cartographicToCartesian(node2.obb.center);
+  const obbCenterCartesian = import_geospatial12.Ellipsoid.WGS84.cartographicToCartesian(node2.obb.center);
   let vertices = [];
   for (let i = 0; i < positions.length; i += 3) {
-    const positionsVector = new import_core26.Vector3(positions[i] *= halfSize[0], positions[i + 1] *= halfSize[1], positions[i + 2] *= halfSize[2]);
+    const positionsVector = new import_core27.Vector3(positions[i] *= halfSize[0], positions[i + 1] *= halfSize[1], positions[i + 2] *= halfSize[2]);
     const rotatedPositions = positionsVector.transformByQuaternion(node2.obb.quaternion).add(obbCenterCartesian);
     vertices = vertices.concat(rotatedPositions);
   }
@@ -61447,7 +61656,7 @@ function isAllVerticesInsideBoundingVolume(boundingVolume, positions) {
   let isVerticesInsideObb = true;
   for (let index = 0; index < positions.length / 3; index += 3) {
     const point = [positions[index], positions[index + 1], positions[index + 2]];
-    const cartographicPoint = import_geospatial11.Ellipsoid.WGS84.cartesianToCartographic(point);
+    const cartographicPoint = import_geospatial12.Ellipsoid.WGS84.cartesianToCartographic(point);
     const distance = boundingVolume.distanceTo(cartographicPoint);
     if (distance > 0) {
       isVerticesInsideObb = false;
@@ -61457,6 +61666,18 @@ function isAllVerticesInsideBoundingVolume(boundingVolume, positions) {
   return isVerticesInsideObb;
 }
 
+// src/i3s-converter/types.ts
+var GltfPrimitiveModeString;
+(function(GltfPrimitiveModeString2) {
+  GltfPrimitiveModeString2["POINTS"] = "POINTS";
+  GltfPrimitiveModeString2["LINES"] = "LINES";
+  GltfPrimitiveModeString2["LINE_LOOP"] = "LINE_LOOP";
+  GltfPrimitiveModeString2["LINE_STRIP"] = "LINE_STRIP";
+  GltfPrimitiveModeString2["TRIANGLES"] = "TRIANGLES";
+  GltfPrimitiveModeString2["TRIANGLE_STRIP"] = "TRIANGLE_STRIP";
+  GltfPrimitiveModeString2["TRIANGLE_FAN"] = "TRIANGLE_FAN";
+})(GltfPrimitiveModeString || (GltfPrimitiveModeString = {}));
+
 // src/lib/utils/queue.ts
 var Queue = class extends Array {
   enqueue(val) {
@@ -61653,10 +61874,14 @@ var NodeIndexDocument = class {
   constructor(id, converter) {
     this.data = null;
     this.children = [];
+    this._finalized = false;
     this.inPageId = id;
     this.id = id === 0 ? "root" : id.toString();
     this.converter = converter;
   }
+  get finalized() {
+    return this._finalized;
+  }
   async addData(data) {
     if (this.converter.options.instantNodeWriting) {
       await this.write(data);
@@ -61690,6 +61915,9 @@ var NodeIndexDocument = class {
     }
   }
   async addNeighbors() {
+    if (this.finalized) {
+      return;
+    }
     const nodeData = await this.load();
     for (const childNode of this.children) {
       const childNodeData = await childNode.load();
@@ -61709,14 +61937,20 @@ var NodeIndexDocument = class {
         await childNode.write(childNodeData);
       }
       await childNode.save();
-      childNode.flush();
     }
+    this.finalize();
   }
   async save() {
     if (this.data) {
       await this.write(this.data);
     }
   }
+  finalize() {
+    this._finalized = true;
+    for (const child of this.children) {
+      child.flush();
+    }
+  }
   async write(node2) {
     const path2 = (0, import_path7.join)(this.converter.layers0Path, "nodes", this.id);
     if (this.converter.options.slpk) {
@@ -61811,6 +62045,105 @@ var NodeIndexDocument = class {
   }
 };
 
+// src/i3s-converter/helpers/load-3d-tiles.ts
+var loadNestedTileset = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
+  const isTileset = sourceTile.type === "json";
+  if (!sourceTileset || !sourceTile.contentUrl || !isTileset) {
+    return;
+  }
+  const loadOptions = {
+    ...tilesetLoadOptions,
+    [sourceTileset.loader.id]: {
+      isTileset,
+      assetGltfUpAxis: sourceTileset.asset && sourceTileset.asset.gltfUpAxis || "Y"
+    }
+  };
+  const tileContent = await load(sourceTile.contentUrl, sourceTileset.loader, loadOptions);
+  if (tileContent.root) {
+    sourceTile.children = [tileContent.root];
+  }
+};
+var loadTile3DContent = async (sourceTileset, sourceTile, tilesetLoadOptions) => {
+  const isTileset = sourceTile.type === "json";
+  if (!sourceTileset || !sourceTile.contentUrl || isTileset) {
+    return null;
+  }
+  const loadOptions = {
+    ...tilesetLoadOptions,
+    [sourceTileset.loader.id]: {
+      ...tilesetLoadOptions[sourceTileset.loader.id] || {},
+      isTileset,
+      assetGltfUpAxis: sourceTileset.asset && sourceTileset.asset.gltfUpAxis || "Y"
+    }
+  };
+  const tileContent = await load(sourceTile.contentUrl, sourceTileset.loader, loadOptions);
+  return tileContent;
+};
+
+// src/i3s-converter/i3s-converter.ts
+var import_core31 = __toModule(require_es5());
+
+// src/i3s-converter/helpers/tileset-traversal.ts
+var traverseDatasetWith = async (tile, traversalProps, processTile, postprocessTile, maxDepth, level = 0) => {
+  if (maxDepth && level > maxDepth) {
+    return;
+  }
+  const processResults = [];
+  const newTraversalProps = await processTile(tile, traversalProps);
+  processResults.push(newTraversalProps);
+  for (const childTile of tile.children) {
+    await traverseDatasetWith(childTile, newTraversalProps, processTile, postprocessTile, maxDepth, level + 1);
+  }
+  postprocessTile && await postprocessTile(processResults, traversalProps);
+};
+
+// src/i3s-converter/helpers/preprocess-3d-tiles.ts
+var GLTF_PRIMITIVE_MODES = [
+  GltfPrimitiveModeString.POINTS,
+  GltfPrimitiveModeString.LINES,
+  GltfPrimitiveModeString.LINE_LOOP,
+  GltfPrimitiveModeString.LINE_STRIP,
+  GltfPrimitiveModeString.TRIANGLES,
+  GltfPrimitiveModeString.TRIANGLE_STRIP,
+  GltfPrimitiveModeString.TRIANGLE_FAN
+];
+var analyzeTileContent = async (tile, tileContent) => {
+  const result = {
+    meshTopologyTypes: new Set()
+  };
+  if (!tileContent?.gltfArrayBuffer) {
+    return result;
+  }
+  const gltfData = await parse(tileContent.gltfArrayBuffer, GLTFLoader, {
+    gltf: { normalize: false, loadBuffers: false, loadImages: false, decompressMeshes: false }
+  });
+  const gltf = gltfData.json;
+  if (!gltf) {
+    return result;
+  }
+  const meshTypes = getMeshTypesFromGltf(gltf);
+  result.meshTopologyTypes = meshTypes;
+  return result;
+};
+var getMeshTypesFromGltf = (gltfJson) => {
+  const result = new Set();
+  for (const mesh of gltfJson.meshes || []) {
+    for (const primitive of mesh.primitives) {
+      let { mode } = primitive;
+      if (typeof mode !== "number") {
+        mode = 4;
+      }
+      result.add(GLTF_PRIMITIVE_MODES[mode]);
+    }
+  }
+  return result;
+};
+var mergePreprocessData = (object1, object2) => {
+  for (const type of object2.meshTopologyTypes) {
+    object1.meshTopologyTypes.add(type);
+  }
+};
+
 // src/i3s-converter/i3s-converter.ts
 var ION_DEFAULT_TOKEN = import_process2.default.env?.IonToken || "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ";
 var HARDCODED_NODES_PER_PAGE = 64;
@@ -61824,11 +62157,24 @@ var I3SConverter = class {
     this.conversionStartTime = [0, 0];
     this.refreshTokenTime = [0, 0];
     this.sourceTileset = null;
+    this.loadOptions = {
+      _nodeWorkers: true,
+      reuseWorkers: true,
+      basis: {
+        format: "rgba32",
+        workerUrl: "./modules/textures/dist/basis-worker-node.js"
+      },
+      draco: { workerUrl: "./modules/draco/dist/draco-worker-node.js" },
+      fetch: {}
+    };
     this.geoidHeightModel = null;
     this.Loader = Tiles3DLoader;
     this.workerSource = {};
     this.writeQueue = new WriteQueue();
     this.compressList = null;
+    this.preprocessData = {
+      meshTopologyTypes: new Set()
+    };
     this.nodePages = new NodePages(writeFile3, HARDCODED_NODES_PER_PAGE, this);
     this.options = {};
     this.layers0Path = "";
@@ -61898,41 +62244,69 @@ var I3SConverter = class {
     await this.loadWorkers();
     try {
       const preloadOptions = await this._fetchPreloadOptions();
-      const tilesetOptions = {
-        loadOptions: {
-          _nodeWorkers: true,
-          reuseWorkers: true,
-          basis: { format: "rgba32" }
-        }
-      };
       if (preloadOptions.headers) {
-        tilesetOptions.loadOptions.fetch = { headers: preloadOptions.headers };
-      }
-      Object.assign(tilesetOptions, preloadOptions);
-      const sourceTilesetJson = await load(inputUrl, this.Loader, tilesetOptions.loadOptions);
-      this.sourceTileset = new Tileset3D(sourceTilesetJson, tilesetOptions);
-      await this._createAndSaveTileset(outputPath, tilesetName, sourceTilesetJson?.root?.boundingVolume?.region);
-      await this._finishConversion({ slpk: Boolean(slpk), outputPath, tilesetName });
-      return sourceTilesetJson;
+        this.loadOptions.fetch = { headers: preloadOptions.headers };
+      }
+      this.sourceTileset = await load(inputUrl, this.Loader, this.loadOptions);
+      const preprocessResult = await this.preprocessConversion();
+      if (preprocessResult) {
+        await this._createAndSaveTileset(outputPath, tilesetName);
+        await this._finishConversion({ slpk: Boolean(slpk), outputPath, tilesetName });
+      }
     } catch (error) {
       throw error;
     } finally {
+      await this.writeQueue.finalize();
       const workerFarm = WorkerFarm.getWorkerFarm({});
       workerFarm.destroy();
     }
+    return "success";
+  }
+  async preprocessConversion() {
+    console.log(`Analyze source tileset`);
+    const sourceRootTile = this.sourceTileset.root;
+    await traverseDatasetWith(sourceRootTile, null, this.analyzeTile.bind(this), void 0, this.options.maxDepth);
+    const { meshTopologyTypes } = this.preprocessData;
+    console.log(`------------------------------------------------`);
+    console.log(`Preprocess results:`);
+    console.log(`glTF mesh topology types: ${Array.from(meshTopologyTypes).join(", ")}`);
+    console.log(`------------------------------------------------`);
+    if (!meshTopologyTypes.has(GltfPrimitiveModeString.TRIANGLES) && !meshTopologyTypes.has(GltfPrimitiveModeString.TRIANGLE_STRIP)) {
+      console.log("The tileset is of unsupported mesh topology types. The conversion will be interrupted.");
+      console.log(`------------------------------------------------`);
+      return false;
+    }
+    return true;
   }
-  async _createAndSaveTileset(outputPath, tilesetName, boundingVolumeRegion) {
+  async analyzeTile(sourceTile, traversalProps) {
+    if (sourceTile.type === "json") {
+      await loadNestedTileset(this.sourceTileset, sourceTile, this.loadOptions);
+      return null;
+    }
+    if (sourceTile.id) {
+      console.log(`[analyze]: ${sourceTile.id}`);
+    }
+    const tileContent = await loadTile3DContent(this.sourceTileset, sourceTile, {
+      ...this.loadOptions,
+      "3d-tiles": { ...this.loadOptions["3d-tiles"], loadGLTF: false }
+    });
+    const tilePreprocessData = await analyzeTileContent(sourceTile, tileContent);
+    mergePreprocessData(this.preprocessData, tilePreprocessData);
+    return null;
+  }
+  async _createAndSaveTileset(outputPath, tilesetName) {
     const tilesetPath = (0, import_path8.join)(`${outputPath}`, `${tilesetName}`);
     try {
       await removeDir(tilesetPath);
     } catch (e) {
     }
     this.layers0Path = (0, import_path8.join)(tilesetPath, "SceneServer", "layers", "0");
-    this._formLayers0(tilesetName, boundingVolumeRegion);
     this.materialDefinitions = [];
     this.materialMap = new Map();
     const sourceRootTile = this.sourceTileset.root;
-    const boundingVolumes = createBoundingVolumes(sourceRootTile, this.geoidHeightModel);
+    const sourceBoundingVolume = createBoundingVolume(sourceRootTile.boundingVolume, new import_core31.Matrix4(sourceRootTile.transform), null);
+    this._formLayers0(tilesetName, sourceBoundingVolume, this.sourceTileset?.root?.boundingVolume?.region);
+    const boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel);
     await this.nodePages.push({
       index: 0,
       lodThreshold: 0,
@@ -61940,7 +62314,10 @@ var I3SConverter = class {
       children: []
     });
     const rootNode = await NodeIndexDocument.createRootNode(boundingVolumes, this);
-    await this._convertNodesTree(rootNode, sourceRootTile);
+    await traverseDatasetWith(sourceRootTile, {
+      transform: new import_core31.Matrix4(sourceRootTile.transform),
+      parentNodes: [rootNode]
+    }, this.convertTile.bind(this), this.finalizeTile.bind(this), this.options.maxDepth);
     this.layers0.materialDefinitions = this.materialDefinitions;
     this.layers0.geometryDefinitions = (0, import_json_map_transform8.default)(this.geometryConfigs.map((config) => ({
       geometryConfig: { ...config, draco: this.options.draco }
@@ -61958,8 +62335,11 @@ var I3SConverter = class {
     await this.writeQueue.finalize();
     await this._createSlpk(tilesetPath);
   }
-  _formLayers0(tilesetName, boundingVolumeRegion) {
-    const fullExtent = convertBoundingVolumeToI3SFullExtent(this.sourceTileset?.boundingVolume || this.sourceTileset?.root?.boundingVolume);
+  _formLayers0(tilesetName, sourceBoundingVolume, boundingVolumeRegion) {
+    if (!this.sourceTileset?.root) {
+      return;
+    }
+    const fullExtent = convertBoundingVolumeToI3SFullExtent(sourceBoundingVolume);
     if (boundingVolumeRegion) {
       fullExtent.zmin = boundingVolumeRegion[4];
       fullExtent.zmax = boundingVolumeRegion[5];
@@ -61982,24 +62362,6 @@ var I3SConverter = class {
     };
     this.layers0 = (0, import_json_map_transform8.default)(layers0data, LAYERS());
   }
-  async _convertNodesTree(rootNode, sourceRootTile) {
-    await this.sourceTileset._loadTile(sourceRootTile);
-    if (this.isContentSupported(sourceRootTile)) {
-      const childNodes = await this._createNode(rootNode, sourceRootTile, 0);
-      for (const childNode of childNodes) {
-        await childNode.save();
-      }
-      await rootNode.addChildren(childNodes);
-    } else {
-      await this._addChildrenWithNeighborsAndWriteFile({
-        parentNode: rootNode,
-        sourceTiles: sourceRootTile.children,
-        level: 1
-      });
-    }
-    await sourceRootTile.unloadContent();
-    await rootNode.save();
-  }
   async _writeLayers0() {
     if (this.options.slpk) {
       await this.writeQueue.enqueue({
@@ -62023,57 +62385,54 @@ var I3SConverter = class {
       }
     }
   }
-  async _addChildrenWithNeighborsAndWriteFile(data) {
-    await this._addChildren(data);
-    await data.parentNode.addNeighbors();
-  }
-  async convertNestedTileset({
-    parentNode,
-    sourceTile,
-    level
-  }) {
-    await this.sourceTileset._loadTile(sourceTile);
-    await this._addChildren({
-      parentNode,
-      sourceTiles: sourceTile.children,
-      level: level + 1
-    });
-    await sourceTile.unloadContent();
-  }
-  async convertNode({
-    parentNode,
-    sourceTile,
-    level
-  }) {
-    const childNodes = await this._createNode(parentNode, sourceTile, level);
-    await parentNode.addChildren(childNodes);
-  }
-  async _addChildren(data) {
-    const { sourceTiles, parentNode, level } = data;
-    if (this.options.maxDepth && level > this.options.maxDepth) {
-      return;
-    }
-    for (const sourceTile of sourceTiles) {
+  async convertTile(sourceTile, traversalProps) {
+    if (sourceTile.type === "json" || sourceTile.type === "empty") {
       if (sourceTile.type === "json") {
-        await this.convertNestedTileset({ parentNode, sourceTile, level });
-      } else {
-        await this.convertNode({ parentNode, sourceTile, level });
+        if (sourceTile.id) {
+          console.log(`[load]: ${sourceTile.id}`);
+        }
+        await loadNestedTileset(this.sourceTileset, sourceTile, this.loadOptions);
       }
-      if (sourceTile.id) {
-        console.log(sourceTile.id);
+      return traversalProps;
+    }
+    if (sourceTile.id) {
+      console.log(`[convert]: ${sourceTile.id}`);
+    }
+    const { parentNodes, transform: transform11 } = traversalProps;
+    let transformationMatrix = transform11.clone();
+    if (sourceTile.transform) {
+      transformationMatrix = transformationMatrix.multiplyRight(sourceTile.transform);
+    }
+    const parentNode = parentNodes[0];
+    const childNodes = await this._createNode(parentNode, sourceTile, transformationMatrix);
+    await parentNode.addChildren(childNodes);
+    const newTraversalProps = {
+      transform: transformationMatrix,
+      parentNodes: childNodes
+    };
+    return newTraversalProps;
+  }
+  async finalizeTile(conversionResults, currentTraversalProps) {
+    for (const result of conversionResults) {
+      for (const node2 of result.parentNodes) {
+        await node2.addNeighbors();
       }
     }
+    for (const node2 of currentTraversalProps.parentNodes) {
+      await node2.save();
+    }
   }
-  async _createNode(parentNode, sourceTile, level) {
+  async _createNode(parentNode, sourceTile, transformationMatrix) {
     this._checkAddRefinementTypeForTile(sourceTile);
     await this._updateTilesetOptions();
-    await this.sourceTileset._loadTile(sourceTile);
-    let boundingVolumes = createBoundingVolumes(sourceTile, this.geoidHeightModel);
-    const propertyTable = getPropertyTable(sourceTile.content);
+    const tileContent = await loadTile3DContent(this.sourceTileset, sourceTile, this.loadOptions);
+    const sourceBoundingVolume = createBoundingVolume(sourceTile.boundingVolume, transformationMatrix, null);
+    let boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel);
+    const propertyTable = getPropertyTable(tileContent);
     if (propertyTable && !this.layers0?.attributeStorageInfo?.length) {
       this._convertPropertyTableToNodeAttributes(propertyTable);
     }
-    const resourcesData = await this._convertResources(sourceTile, parentNode.inPageId, propertyTable);
+    const resourcesData = await this._convertResources(sourceTile, transformationMatrix, sourceBoundingVolume, tileContent, parentNode.inPageId, propertyTable);
     const nodes = [];
     const nodeIds = [];
     const nodesInPage = [];
@@ -62112,16 +62471,10 @@ var I3SConverter = class {
       nodeIds.push(nodeInPage.index);
       nodesInPage.push(nodeInPage);
     }
-    sourceTile.unloadContent();
-    await this._addChildrenWithNeighborsAndWriteFile({
-      parentNode: nodes[0],
-      sourceTiles: sourceTile.children,
-      level: level + 1
-    });
     return nodes;
   }
-  async _convertResources(sourceTile, parentId, propertyTable) {
-    if (!this.isContentSupported(sourceTile)) {
+  async _convertResources(sourceTile, transformationMatrix, boundingVolume, tileContent, parentId, propertyTable) {
+    if (!this.isContentSupported(sourceTile) || !tileContent) {
       return null;
     }
     const draftObb = {
@@ -62129,7 +62482,7 @@ var I3SConverter = class {
       halfSize: [],
       quaternion: []
     };
-    const resourcesData = await convertB3dmToI3sGeometry(sourceTile.content, async () => (await this.nodePages.push({ index: 0, obb: draftObb }, parentId)).index, propertyTable, this.featuresHashArray, this.layers0?.attributeStorageInfo, this.options.draco, this.generateBoundingVolumes, this.options.mergeMaterials, this.geoidHeightModel, this.workerSource);
+    const resourcesData = await convertB3dmToI3sGeometry(tileContent, transformationMatrix, boundingVolume, async () => (await this.nodePages.push({ index: 0, obb: draftObb }, parentId)).index, propertyTable, this.featuresHashArray, this.layers0?.attributeStorageInfo, this.options.draco, this.generateBoundingVolumes, this.options.mergeMaterials, this.geoidHeightModel, this.workerSource);
     return resourcesData;
   }
   async _updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
@@ -62399,10 +62752,9 @@ var I3SConverter = class {
     }
     this.refreshTokenTime = import_process2.default.hrtime();
     const preloadOptions = await this._fetchPreloadOptions();
-    this.sourceTileset.options = { ...this.sourceTileset.options, ...preloadOptions };
     if (preloadOptions.headers) {
-      this.sourceTileset.loadOptions.fetch = {
-        ...this.sourceTileset.loadOptions.fetch,
+      this.loadOptions.fetch = {
+        ...this.loadOptions.fetch,
         headers: preloadOptions.headers
       };
       console.log("Authorization Bearer token has been updated");
@@ -62416,8 +62768,8 @@ var I3SConverter = class {
     }
     this.refinementCounter.tilesCount += 1;
   }
-  isContentSupported(sourceRootTile) {
-    return ["b3dm", "glTF"].includes(sourceRootTile?.content?.type);
+  isContentSupported(sourceTile) {
+    return ["b3dm", "glTF", "scenegraph"].includes(sourceTile.type || "");
   }
   async loadWorkers() {
     console.log(`Loading workers source...`);
@@ -62525,8 +62877,8 @@ var COORDINATE_SYSTEM;
 })(COORDINATE_SYSTEM || (COORDINATE_SYSTEM = {}));
 
 // ../i3s/src/lib/parsers/parse-i3s-tile-content.ts
-var import_core30 = __toModule(require_es5());
-var import_geospatial12 = __toModule(require_es52());
+var import_core34 = __toModule(require_es5());
+var import_geospatial13 = __toModule(require_es52());
 
 // ../i3s/src/lib/utils/url-utils.ts
 function getUrlWithToken(url, token = null) {
@@ -62630,7 +62982,7 @@ function getAttributeValueType(attribute) {
   return "";
 }
 
-// ../i3s/src/lib/utils/customizeColors.ts
+// ../i3s/src/lib/utils/customize-сolors.ts
 async function customizeColors(colors, featureIds, tileOptions, tilesetOptions, options) {
   if (!options?.i3s?.colorsByAttribute) {
     return colors;
@@ -62660,7 +63012,13 @@ async function customizeColors(colors, featureIds, tileOptions, tilesetOptions,
     if (!color) {
       continue;
     }
-    colors.value.set(color, i * 4);
+    if (options.i3s.colorsByAttribute.mode === "multiply") {
+      color.forEach((colorItem, index) => {
+        colors.value[i * 4 + index] = colors.value[i * 4 + index] * colorItem / 255;
+      });
+    } else {
+      colors.value.set(color, i * 4);
+    }
   }
   return colors;
 }
@@ -62691,7 +63049,7 @@ async function loadFeatureAttributeData(attributeName, { attributeUrls }, { attr
 }
 
 // ../i3s/src/lib/parsers/parse-i3s-tile-content.ts
-var scratchVector6 = new import_core30.Vector3([0, 0, 0]);
+var scratchVector6 = new import_core34.Vector3([0, 0, 0]);
 function getLoaderForTextureFormat(textureFormat) {
   switch (textureFormat) {
     case "ktx-etc2":
@@ -62712,7 +63070,7 @@ async function parseI3STileContent(arrayBuffer, tileOptions, tilesetOptions, opt
     indices: null,
     featureIds: [],
     vertexCount: 0,
-    modelMatrix: new import_core30.Matrix4(),
+    modelMatrix: new import_core34.Matrix4(),
     coordinateSystem: 0,
     byteLength: 0,
     texture: null
@@ -62937,11 +63295,11 @@ function parsePositions2(attribute, options) {
   const mbs = options.mbs;
   const value = attribute.value;
   const metadata = attribute.metadata;
-  const enuMatrix = new import_core30.Matrix4();
-  const cartographicOrigin = new import_core30.Vector3(mbs[0], mbs[1], mbs[2]);
-  const cartesianOrigin = new import_core30.Vector3();
-  import_geospatial12.Ellipsoid.WGS84.cartographicToCartesian(cartographicOrigin, cartesianOrigin);
-  import_geospatial12.Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin, enuMatrix);
+  const enuMatrix = new import_core34.Matrix4();
+  const cartographicOrigin = new import_core34.Vector3(mbs[0], mbs[1], mbs[2]);
+  const cartesianOrigin = new import_core34.Vector3();
+  import_geospatial13.Ellipsoid.WGS84.cartographicToCartesian(cartographicOrigin, cartesianOrigin);
+  import_geospatial13.Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin, enuMatrix);
   attribute.value = offsetsToCartesians(value, metadata, cartographicOrigin);
   return enuMatrix;
 }
@@ -62955,7 +63313,7 @@ function offsetsToCartesians(vertices, metadata = {}, cartographicOrigin) {
     positions[i + 2] = vertices[i + 2] + cartographicOrigin.z;
   }
   for (let i = 0; i < positions.length; i += 3) {
-    import_geospatial12.Ellipsoid.WGS84.cartographicToCartesian(positions.subarray(i, i + 3), scratchVector6);
+    import_geospatial13.Ellipsoid.WGS84.cartographicToCartesian(positions.subarray(i, i + 3), scratchVector6);
     positions[i] = scratchVector6.x;
     positions[i + 1] = scratchVector6.y;
     positions[i + 2] = scratchVector6.z;
@@ -62966,7 +63324,7 @@ function getModelMatrix(positions) {
   const metadata = positions.metadata;
   const scaleX = metadata?.["i3s-scale_x"]?.double || 1;
   const scaleY = metadata?.["i3s-scale_y"]?.double || 1;
-  const modelMatrix = new import_core30.Matrix4();
+  const modelMatrix = new import_core34.Matrix4();
   modelMatrix[0] = scaleX;
   modelMatrix[5] = scaleY;
   return modelMatrix;
@@ -63092,7 +63450,7 @@ async function parse6(data, options, context) {
 
 // ../i3s/src/lib/parsers/parse-i3s.ts
 var import_culling8 = __toModule(require_es53());
-var import_geospatial13 = __toModule(require_es52());
+var import_geospatial14 = __toModule(require_es52());
 
 // ../i3s/src/i3s-node-page-loader.ts
 var VERSION16 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
@@ -63310,12 +63668,12 @@ function normalizeTileNonUrlData(tile) {
   if (tile.mbs) {
     mbs = tile.mbs;
     boundingVolume.sphere = [
-      ...import_geospatial13.Ellipsoid.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)),
+      ...import_geospatial14.Ellipsoid.WGS84.cartographicToCartesian(tile.mbs.slice(0, 3)),
       tile.mbs[3]
     ];
   } else if (tile.obb) {
     boundingVolume.box = [
-      ...import_geospatial13.Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center),
+      ...import_geospatial14.Ellipsoid.WGS84.cartographicToCartesian(tile.obb.center),
       ...tile.obb.halfSize,
       ...tile.obb.quaternion
     ];
@@ -63437,8 +63795,8 @@ function getMagicNumber(data) {
 }
 
 // src/3d-tiles-converter/helpers/i3s-obb-to-3d-tiles-obb.ts
-var import_core34 = __toModule(require_es5());
-var import_geospatial14 = __toModule(require_es52());
+var import_core38 = __toModule(require_es5());
+var import_geospatial15 = __toModule(require_es52());
 var import_culling9 = __toModule(require_es53());
 function i3sObbTo3dTilesObb(i3SObb, geoidHeightModel) {
   const tiles3DCenter = [
@@ -63446,7 +63804,7 @@ function i3sObbTo3dTilesObb(i3SObb, geoidHeightModel) {
     i3SObb.center[1],
     i3SObb.center[2] + geoidHeightModel.getHeight(i3SObb.center[1], i3SObb.center[0])
   ];
-  const cartesianCenter = import_geospatial14.Ellipsoid.WGS84.cartographicToCartesian(tiles3DCenter, new import_core34.Vector3());
+  const cartesianCenter = import_geospatial15.Ellipsoid.WGS84.cartographicToCartesian(tiles3DCenter, new import_core38.Vector3());
   const tiles3DObb = new import_culling9.OrientedBoundingBox().fromCenterHalfSizeQuaternion(cartesianCenter, i3SObb.halfSize, i3SObb.quaternion);
   return [...tiles3DObb.center, ...tiles3DObb.halfAxes.toArray()];
 }