npm - @loaders.gl/tile-converter - Versions diffs - 4.0.0-alpha.7 → 4.0.0-alpha.8 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (148) hide show

package/dist/dist.min.js CHANGED Viewed

@@ -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));
   }
 });
@@ -50030,24 +50030,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 +51704,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 +53100,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 +53133,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 +53151,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 +53176,7 @@ function normalize3DTileColorAttribute(tile, colors, batchTable) {
   }
   return {
     type: GL2.UNSIGNED_BYTE,
-    value: colors,
+    value: colors || new Uint8ClampedArray(),
     size: 4,
     normalized: true
   };
@@ -53186,8 +53190,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 +53274,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 +53303,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 +53327,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 +53375,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 +53395,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 +55048,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 +55305,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 +56197,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 +56216,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 +56238,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 +56370,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 +56641,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 +57170,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 +57182,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 +57210,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 +57252,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 +57266,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 +57282,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 +57294,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 +57329,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 +57352,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 +57361,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 +57386,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 +57397,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 +58886,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 +58901,7 @@ function getTileType(tile) {
     case "gltf":
       return TILE_TYPE.SCENEGRAPH;
     default:
-      return fileExtension;
+      return fileExtension || TILE_TYPE.EMPTY;
   }
 }
 function getRefine(refine) {
@@ -58765,7 +58916,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 +58926,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 +58988,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 +59012,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 +59073,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 +59103,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 +59365,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 +59612,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 +59787,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 +59864,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 +59886,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 +59894,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 +59994,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 +60039,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 +60050,7 @@ function generateBatchIdsFromTexture(featureIdTexture, textureCoordinates, image
   }
   return batchIds;
 }
-function emod(n) {
+function emod2(n) {
   return (n % 1 + 1) % 1;
 }
@@ -60018,11 +60215,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 +60261,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 +60353,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 +60377,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 +60385,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 +60396,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 +60463,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 +60480,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 +60715,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 +60920,9 @@ function generateFeatureIndexAttribute(featureIndex, faceRange) {
   return orderedFeatureIndices;
 }
 function getPropertyTable(tileContent) {
+  if (!tileContent) {
+    return null;
+  }
   const batchTableJson = tileContent?.batchTableJson;
   if (batchTableJson) {
     return batchTableJson;
@@ -60757,10 +60957,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 +60968,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 +61527,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 +61641,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 +61654,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 +61664,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 +61872,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 +61913,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 +61935,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 +62043,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 +62155,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 +62242,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 _createAndSaveTileset(outputPath, tilesetName, boundingVolumeRegion) {
+  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 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 +62312,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 +62333,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 +62360,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 +62383,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 +62469,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 +62480,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 +62750,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 +62766,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 +62875,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 +62980,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 +63010,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 +63047,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 +63068,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 +63293,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 +63311,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 +63322,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 +63448,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 +63666,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 +63793,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 +63802,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()];
 }