@loaders.gl/tile-converter 4.0.0-alpha.23 → 4.0.0-alpha.24

package/dist/dist.min.js

@@ -45517,9 +45517,9 @@ var require_geoid = __commonJS({
     var stencilsize_ = 12;
     var nterms_ = (3 + 1) * (3 + 2) / 2;
     var PIXEL_SIZE = 2;
-    var Geoid = function() {
-      function Geoid2(options) {
-        (0, _classCallCheck2.default)(this, Geoid2);
+    var Geoid2 = function() {
+      function Geoid3(options) {
+        (0, _classCallCheck2.default)(this, Geoid3);
         (0, _defineProperty2.default)(this, "_v00", 0);
         (0, _defineProperty2.default)(this, "_v01", 0);
         (0, _defineProperty2.default)(this, "_v10", 0);
@@ -45532,7 +45532,7 @@ var require_geoid = __commonJS({
         this._ix = this.options._width;
         this._iy = this.options._height;
       }
-      (0, _createClass2.default)(Geoid2, [{
+      (0, _createClass2.default)(Geoid3, [{
         key: "getHeight",
         value: function getHeight(lat, lon) {
           lat = Math.abs(lat) > 90 ? NaN : lat;
@@ -45625,9 +45625,9 @@ var require_geoid = __commonJS({
           return r;
         }
       }]);
-      return Geoid2;
+      return Geoid3;
     }();
-    exports.default = Geoid;
+    exports.default = Geoid2;
     function remainder(x, y) {
       y = Math.abs(y);
       var z = fmod(x, y);
@@ -47861,37 +47861,20 @@ __export(fs_exports, {
   writeFileSync: () => writeFileSync
 });
 var import_fs2 = __toModule(require("fs"));
-var readdir;
-var stat;
-var statSync;
-var readFile;
-var readFileSync;
-var writeFile;
-var writeFileSync;
-var open;
-var close;
-var read;
-var fstat;
-var createReadStream;
-var createWriteStream;
+var readdir = promisify2(import_fs2.default.readdir);
+var stat = promisify2(import_fs2.default.stat);
+var statSync = import_fs2.default.statSync;
+var readFile = import_fs2.default.readFile;
+var readFileSync = import_fs2.default.readFileSync;
+var writeFile = promisify3(import_fs2.default.writeFile);
+var writeFileSync = import_fs2.default.writeFileSync;
+var open = import_fs2.default.open;
+var close = (fd) => new Promise((resolve2, reject) => import_fs2.default.close(fd, (err) => err ? reject(err) : resolve2()));
+var read = import_fs2.default.read;
+var fstat = import_fs2.default.fstat;
+var createReadStream = import_fs2.default.createReadStream;
+var createWriteStream = import_fs2.default.createWriteStream;
 var isSupported = Boolean(import_fs2.default);
-try {
-  readdir = promisify2(import_fs2.default.readdir);
-  stat = promisify2(import_fs2.default.stat);
-  statSync = import_fs2.default.statSync;
-  readFile = import_fs2.default.readFile;
-  readFileSync = import_fs2.default.readFileSync;
-  writeFile = promisify3(import_fs2.default.writeFile);
-  writeFileSync = import_fs2.default.writeFileSync;
-  open = import_fs2.default.open;
-  close = (fd) => new Promise((resolve2, reject) => import_fs2.default.close(fd, (err) => err ? reject(err) : resolve2()));
-  read = import_fs2.default.read;
-  fstat = import_fs2.default.fstat;
-  createReadStream = import_fs2.default.createReadStream;
-  createWriteStream = import_fs2.default.createWriteStream;
-  isSupported = Boolean(import_fs2.default);
-} catch {
-}
 async function _readToArrayBuffer(fd, start, length) {
   const buffer = Buffer.alloc(length);
   const { bytesRead } = await read(fd, buffer, 0, length, start);
@@ -50121,7 +50104,7 @@ function getUint32Array(dracoArray) {
 }
 
 // ../draco/src/lib/draco-module-loader.ts
-var DRACO_DECODER_VERSION = "1.5.5";
+var DRACO_DECODER_VERSION = "1.5.6";
 var DRACO_ENCODER_VERSION = "1.4.1";
 var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
 var DRACO_EXTERNAL_LIBRARIES = {
@@ -52340,7 +52323,7 @@ var GLTFScenegraph = class {
   }
 };
 
-// ../gltf/src/lib/extensions/data-processing.ts
+// ../gltf/src/lib/extensions/utils/3d-tiles-utils.ts
 var ATTRIBUTE_TYPE_TO_COMPONENTS2 = {
   SCALAR: 1,
   VEC2: 2,
@@ -52380,13 +52363,31 @@ var ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2 = {
 function getArrayElementByteSize(attributeType, componentType) {
   return ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2[componentType] * ATTRIBUTE_TYPE_TO_COMPONENTS2[attributeType];
 }
-function convertRawBufferToMetadataArray(typedArray, attributeType, componentType, elementCount = 1) {
+function getOffsetsForProperty(scenegraph, bufferViewIndex, offsetType, numberOfElements) {
+  if (offsetType !== "UINT8" && offsetType !== "UINT16" && offsetType !== "UINT32" && offsetType !== "UINT64") {
+    return null;
+  }
+  const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);
+  const arrayOffsets = convertRawBufferToMetadataArray(arrayOffsetsBytes, "SCALAR", offsetType, numberOfElements + 1);
+  if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {
+    return null;
+  }
+  return arrayOffsets;
+}
+function convertRawBufferToMetadataArray(data, attributeType, componentType, elementCount = 1) {
   const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS2[attributeType];
   const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY2[componentType];
-  const length = elementCount * numberOfComponents;
   const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE2[componentType];
-  const offset = typedArray.byteOffset % size ? Math.ceil(typedArray.byteOffset / size) * size : typedArray.byteOffset;
-  return new ArrayType(typedArray.buffer, offset, length);
+  const length = elementCount * numberOfComponents;
+  const byteLength = length * size;
+  let buffer = data.buffer;
+  let offset = data.byteOffset;
+  if (offset % size !== 0) {
+    const bufferArray = new Uint8Array(buffer);
+    buffer = bufferArray.slice(offset, offset + byteLength).buffer;
+    offset = 0;
+  }
+  return new ArrayType(buffer, offset, length);
 }
 function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
   const json = scenegraph.gltf.json;
@@ -52521,6 +52522,15 @@ function decodeExtStructuralMetadata(scenegraph, options) {
     }
   }
 }
+function findPropertyTableByClass(propertyTables, schemaClassName) {
+  for (let i = 0, len = propertyTables.length; i < len; i++) {
+    const propertyTable = propertyTables[i];
+    if (propertyTable.class === schemaClassName) {
+      return propertyTable;
+    }
+  }
+  return null;
+}
 function processPrimitivePropertyTextures(scenegraph, propertyTextures, primitive, extension) {
   if (!propertyTextures) {
     return;
@@ -52581,14 +52591,8 @@ function getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numb
   let data = [];
   const valuesBufferView = propertyTableProperty.values;
   const valuesDataBytes = scenegraph.getTypedArrayForBufferView(valuesBufferView);
-  let arrayOffsets = null;
-  if (classProperty.array && typeof classProperty.count === "undefined" && typeof propertyTableProperty.arrayOffsets !== "undefined" && typeof propertyTableProperty.arrayOffsetType !== "undefined") {
-    arrayOffsets = getOffsetArray(scenegraph, propertyTableProperty.arrayOffsets, propertyTableProperty.arrayOffsetType, numberOfElements);
-  }
-  let stringOffsets = null;
-  if (typeof propertyTableProperty.stringOffsets !== "undefined" && typeof propertyTableProperty.stringOffsetType !== "undefined") {
-    stringOffsets = getOffsetArray(scenegraph, propertyTableProperty.stringOffsets, propertyTableProperty.stringOffsetType, numberOfElements);
-  }
+  const arrayOffsets = getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements);
+  const stringOffsets = getStringOffsetsForProperty(scenegraph, propertyTableProperty, numberOfElements);
   switch (classProperty.type) {
     case "SCALAR":
     case "VEC2":
@@ -52616,11 +52620,17 @@ function getPropertyDataFromBinarySource(scenegraph, schema, classProperty, numb
   }
   return data;
 }
-function getOffsetArray(scenegraph, offsets, offsetType, numberOfElements) {
-  const arrayOffsetsBufferView = offsets;
-  const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(arrayOffsetsBufferView);
-  const arrayOffsets = convertRawBufferToMetadataArray(arrayOffsetsBytes, "SCALAR", offsetType, numberOfElements + 1);
-  return arrayOffsets;
+function getArrayOffsetsForProperty(scenegraph, classProperty, propertyTableProperty, numberOfElements) {
+  if (classProperty.array && typeof classProperty.count === "undefined" && typeof propertyTableProperty.arrayOffsets !== "undefined" && typeof propertyTableProperty.arrayOffsetType !== "undefined") {
+    return getOffsetsForProperty(scenegraph, propertyTableProperty.arrayOffsets, propertyTableProperty.arrayOffsetType, numberOfElements);
+  }
+  return null;
+}
+function getStringOffsetsForProperty(scenegraph, propertyTableProperty, numberOfElements) {
+  if (typeof propertyTableProperty.stringOffsets !== "undefined" && typeof propertyTableProperty.stringOffsetType !== "undefined") {
+    return getOffsetsForProperty(scenegraph, propertyTableProperty.stringOffsets, propertyTableProperty.stringOffsetType, numberOfElements);
+  }
+  return null;
 }
 function getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
   const isArray = classProperty.array;
@@ -52630,52 +52640,42 @@ function getPropertyDataNumeric(classProperty, numberOfElements, valuesDataBytes
   let valuesData;
   if (classProperty.componentType) {
     valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, classProperty.componentType, elementCount);
+    if (!valuesData) {
+      valuesData = valuesDataBytes;
+    }
   } else {
     valuesData = valuesDataBytes;
   }
   if (isArray) {
     if (arrayOffsets) {
-      return handleVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
+      return parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize);
     }
     if (arrayCount) {
-      return handleFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
+      return parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
     }
     return [];
   }
-  const attributeValueArray = [];
-  for (let index = 0; index < numberOfElements; index++) {
-    const value = valuesData[index];
-    attributeValueArray.push(value);
-  }
-  return attributeValueArray;
+  return valuesData;
 }
-function handleVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize) {
+function parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, valueSize) {
   const attributeValueArray = [];
   for (let index = 0; index < numberOfElements; index++) {
-    const array = [];
     const arrayOffset = arrayOffsets[index];
     const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
-    if (arrayByteSize + arrayOffset <= valuesDataBytesLength) {
-      const typedArrayOffset = arrayOffset / elementSize;
-      const elementCount = arrayByteSize / elementSize;
-      for (let i = 0; i < elementCount; i++) {
-        const value = valuesData[typedArrayOffset + i];
-        array.push(value);
-      }
+    if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
+      break;
     }
-    attributeValueArray.push(array);
+    const typedArrayOffset = arrayOffset / valueSize;
+    const elementCount = arrayByteSize / valueSize;
+    attributeValueArray.push(valuesData.slice(typedArrayOffset, typedArrayOffset + elementCount));
   }
   return attributeValueArray;
 }
-function handleFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount) {
+function parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount) {
   const attributeValueArray = [];
   for (let index = 0; index < numberOfElements; index++) {
-    const array = [];
-    for (let i = 0; i < arrayCount; i++) {
-      const value = valuesData[i];
-      array.push(value);
-    }
-    attributeValueArray.push(array);
+    const elementOffset = index * arrayCount;
+    attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + arrayCount));
   }
   return attributeValueArray;
 }
@@ -52701,9 +52701,6 @@ function getPropertyDataString(classProperty, numberOfElements, valuesDataBytes,
   return [];
 }
 function getPropertyDataENUM(schema, classProperty, numberOfElements, valuesDataBytes, arrayOffsets) {
-  const data = [];
-  const isArray = classProperty.array;
-  const arrayCount = classProperty.count;
   const enumType = classProperty.enumType;
   if (!enumType) {
     throw new Error("Incorrect data in the EXT_structural_metadata extension: classProperty.enumType is not set for type ENUM");
@@ -52715,69 +52712,77 @@ function getPropertyDataENUM(schema, classProperty, numberOfElements, valuesData
   const enumValueType = enumEntry.valueType || "UINT16";
   const elementSize = getArrayElementByteSize(classProperty.type, enumValueType);
   const elementCount = valuesDataBytes.byteLength / elementSize;
-  const valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, enumValueType, elementCount);
-  if (isArray) {
+  let valuesData = convertRawBufferToMetadataArray(valuesDataBytes, classProperty.type, enumValueType, elementCount);
+  if (!valuesData) {
+    valuesData = valuesDataBytes;
+  }
+  if (classProperty.array) {
     if (arrayOffsets) {
-      return handleVariableLengthArrayENUM(valuesData, numberOfElements, arrayOffsets, valuesDataBytes.length, elementSize, enumEntry);
+      return parseVariableLengthArrayENUM({
+        valuesData,
+        numberOfElements,
+        arrayOffsets,
+        valuesDataBytesLength: valuesDataBytes.length,
+        elementSize,
+        enumEntry
+      });
     }
+    const arrayCount = classProperty.count;
     if (arrayCount) {
-      return handleFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry);
+      return parseFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry);
     }
     return [];
   }
-  for (let index = 0; index < numberOfElements; index++) {
-    const enumValue = valuesData[index];
-    const enumObject = getEnumByValue(enumEntry, enumValue);
-    if (enumObject) {
-      data.push(enumObject.name);
-    }
-  }
-  return data;
+  return getEnumsArray(valuesData, 0, numberOfElements, enumEntry);
 }
-function handleVariableLengthArrayENUM(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, elementSize, enumEntry) {
+function parseVariableLengthArrayENUM(params) {
+  const {
+    valuesData,
+    numberOfElements,
+    arrayOffsets,
+    valuesDataBytesLength,
+    elementSize,
+    enumEntry
+  } = params;
   const attributeValueArray = [];
   for (let index = 0; index < numberOfElements; index++) {
-    const array = [];
     const arrayOffset = arrayOffsets[index];
     const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
-    if (arrayByteSize + arrayOffset <= valuesDataBytesLength) {
-      const typedArrayOffset = arrayOffset / elementSize;
-      const elementCount = arrayByteSize / elementSize;
-      for (let i = 0; i < elementCount; i++) {
-        const value = valuesData[typedArrayOffset + i];
-        const enumObject = getEnumByValue(enumEntry, value);
-        if (enumObject) {
-          array.push(enumObject.name);
-        }
-      }
+    if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
+      break;
     }
+    const typedArrayOffset = arrayOffset / elementSize;
+    const elementCount = arrayByteSize / elementSize;
+    const array = getEnumsArray(valuesData, typedArrayOffset, elementCount, enumEntry);
     attributeValueArray.push(array);
   }
   return attributeValueArray;
 }
-function handleFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry) {
+function parseFixedLengthArrayENUM(valuesData, numberOfElements, arrayCount, enumEntry) {
   const attributeValueArray = [];
   for (let index = 0; index < numberOfElements; index++) {
-    const array = [];
-    for (let i = 0; i < arrayCount; i++) {
-      const value = valuesData[i];
-      const enumObject = getEnumByValue(enumEntry, value);
-      if (enumObject) {
-        array.push(enumObject.name);
-      }
-    }
+    const elementOffset = arrayCount * index;
+    const array = getEnumsArray(valuesData, elementOffset, arrayCount, enumEntry);
     attributeValueArray.push(array);
   }
   return attributeValueArray;
 }
-function findPropertyTableByClass(propertyTables, schemaClassName) {
-  for (let i = 0, len = propertyTables.length; i < len; i++) {
-    const propertyTable = propertyTables[i];
-    if (propertyTable.class === schemaClassName) {
-      return propertyTable;
+function getEnumsArray(valuesData, offset, count, enumEntry) {
+  const array = [];
+  for (let i = 0; i < count; i++) {
+    if (valuesData instanceof BigInt64Array || valuesData instanceof BigUint64Array) {
+      array.push("");
+    } else {
+      const value = valuesData[offset + i];
+      const enumObject = getEnumByValue(enumEntry, value);
+      if (enumObject) {
+        array.push(enumObject.name);
+      } else {
+        array.push("");
+      }
     }
   }
-  return null;
+  return array;
 }
 function getEnumByValue(enumEntry, value) {
   for (const enumValue of enumEntry.values) {
@@ -52903,16 +52908,43 @@ function handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass)
 function getPropertyDataFromBinarySource2(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
   const bufferView = featureTableProperty.bufferView;
   const dataArray = scenegraph.getTypedArrayForBufferView(bufferView);
-  switch (schemaProperty.type) {
-    case "STRING": {
-      const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
-      const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
-      return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
+  if (schemaProperty.type === "STRING") {
+    const offsetsData = getStringOffsets(scenegraph, featureTableProperty, numberOfFeatures);
+    if (!offsetsData) {
+      return [];
     }
-    default:
+    return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
+  } else if (isNumericProperty(schemaProperty.type)) {
+    return getNumericAttributes(dataArray, schemaProperty.type, numberOfFeatures);
   }
   return dataArray;
 }
+function isNumericProperty(schemaPropertyType) {
+  return [
+    "UINT8",
+    "INT16",
+    "UINT16",
+    "INT32",
+    "UINT32",
+    "INT64",
+    "UINT64",
+    "FLOAT32",
+    "FLOAT64"
+  ].includes(schemaPropertyType);
+}
+function getStringOffsets(scenegraph, featureTableProperty, numberOfElements) {
+  if (typeof featureTableProperty.stringOffsetBufferView !== "undefined") {
+    return getOffsetsForProperty(scenegraph, featureTableProperty.stringOffsetBufferView, featureTableProperty.offsetType || "UINT32", numberOfElements);
+  }
+  return null;
+}
+function getNumericAttributes(valuesDataBytes, propertyType, elementCount) {
+  let valuesData = convertRawBufferToMetadataArray(valuesDataBytes, "SCALAR", propertyType, elementCount);
+  if (!valuesData) {
+    valuesData = valuesDataBytes;
+  }
+  return valuesData;
+}
 function getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName) {
   const json = scenegraph.gltf.json;
   if (!json.meshes) {
@@ -53030,14 +53062,10 @@ function findFeatureTextureByName(featureTextures, schemaClassName) {
 function getStringAttributes(data, offsetsData, stringsCount) {
   const stringsArray = [];
   const textDecoder = new TextDecoder("utf8");
-  let stringOffset = 0;
-  const bytesPerStringSize = 4;
   for (let index = 0; index < stringsCount; index++) {
-    const stringByteSize = offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
-    const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
+    const stringData = data.slice(offsetsData[index], offsetsData[index + 1]);
     const stringAttribute = textDecoder.decode(stringData);
     stringsArray.push(stringAttribute);
-    stringOffset += stringByteSize;
   }
   return stringsArray;
 }
@@ -59433,6 +59461,11 @@ function makeAttributeObjects(attributes) {
   let colorsList = new Uint8Array(colors);
   let texCoordsList = new Float32Array(texCoords);
   let uvRegionsList = new Uint16Array(uvRegions);
+  let positionsOffset = 0;
+  let normalsOffset = 0;
+  let colorsOffset = 0;
+  let uvRegionsOffset = 0;
+  let texCoordsOffset = 0;
   for (let index = 0; index < featureIds.length; index++) {
     const startIndex = faceRange[index * 2];
     const endIndex = faceRange[index * 2 + 1];
@@ -59443,19 +59476,19 @@ function makeAttributeObjects(attributes) {
     const texCoordsCount = getSliceAttributeCount("texCoords", startIndex, endIndex);
     groupedData.push({
       featureId: featureIds[index],
-      positions: positionsList.slice(0, positionsCount),
-      normals: normalsList.slice(0, normalsCount),
-      colors: colorsList.slice(0, colorsCount),
-      uvRegions: uvRegionsList.slice(0, uvRegionsCount),
-      texCoords: texCoordsList.slice(0, texCoordsCount)
+      positions: positionsList.subarray(positionsOffset, positionsOffset + positionsCount),
+      normals: normalsList.subarray(normalsOffset, normalsOffset + normalsCount),
+      colors: colorsList.subarray(colorsOffset, colorsOffset + colorsCount),
+      uvRegions: uvRegionsList.subarray(uvRegionsOffset, uvRegionsOffset + uvRegionsCount),
+      texCoords: texCoordsList.subarray(texCoordsOffset, texCoordsOffset + texCoordsCount)
     });
-    positionsList = positionsList.slice(positionsCount);
-    normalsList = normalsList.slice(normalsCount);
-    colorsList = colorsList.slice(colorsCount);
-    uvRegionsList = uvRegionsList.slice(uvRegionsCount);
-    texCoordsList = texCoordsList.slice(texCoordsCount);
+    positionsOffset += positionsCount;
+    normalsOffset += normalsCount;
+    colorsOffset += colorsCount;
+    uvRegionsOffset += uvRegionsCount;
+    texCoordsOffset += texCoordsCount;
   }
-  return groupedData.sort((first, second) => first.featureId - second.featureId);
+  return groupedData;
 }
 function getSliceAttributeCount(attributeName, startIndex, endIndex) {
   const itemsPerVertex4 = 4;
@@ -59476,50 +59509,66 @@ function getSliceAttributeCount(attributeName, startIndex, endIndex) {
   }
 }
 function unifyObjectsByFeatureId(sortedData) {
-  const uniqueObjects = [];
-  for (let index = 0; index < sortedData.length; index++) {
-    const currentObject = sortedData[index];
-    const existingObject = uniqueObjects.find((obj) => obj.featureId === currentObject.featureId);
+  const groupedMetadata = [];
+  for (const data of sortedData) {
+    const existingObject = groupedMetadata.find((obj) => obj.featureId === data.featureId);
     if (existingObject) {
-      existingObject.positions = concatenateTypedArrays(existingObject.positions, currentObject.positions);
-      existingObject.normals = concatenateTypedArrays(existingObject.normals, currentObject.normals);
-      existingObject.colors = concatenateTypedArrays(existingObject.colors, currentObject.colors);
-      existingObject.texCoords = concatenateTypedArrays(existingObject.texCoords, currentObject.texCoords);
-      existingObject.uvRegions = concatenateTypedArrays(existingObject.uvRegions, currentObject.uvRegions);
+      existingObject.attributes.push(data);
     } else {
-      uniqueObjects.push(currentObject);
+      groupedMetadata.push({
+        featureId: data.featureId,
+        attributes: [data]
+      });
     }
   }
+  const uniqueObjects = [];
+  for (const metatada of groupedMetadata) {
+    const attributes = concatenateAttributes(metatada.attributes);
+    uniqueObjects.push({
+      featureId: metatada.featureId,
+      ...attributes
+    });
+  }
   return uniqueObjects;
 }
 function groupAttributesAndRangesByFeatureId(unifiedObjects, featureCount) {
   const firstAttributeObject = unifiedObjects[0];
   const featureIds = [firstAttributeObject.featureId || 0];
-  let positions = new Float32Array(firstAttributeObject.positions);
-  let normals = new Float32Array(firstAttributeObject.normals);
-  let colors = new Uint8Array(firstAttributeObject.colors);
-  let uvRegions = new Uint16Array(firstAttributeObject.uvRegions);
-  let texCoords = new Float32Array(firstAttributeObject.texCoords);
   const range = [0];
   let objIndex = 0;
   let sum = 0;
   for (let index = 1; index < unifiedObjects.length; index++) {
     const currentAttributesObject = unifiedObjects[index];
     featureIds.push(currentAttributesObject.featureId || 0);
-    positions = concatenateTypedArrays(positions, currentAttributesObject.positions);
-    normals = concatenateTypedArrays(normals, currentAttributesObject.normals);
-    colors = concatenateTypedArrays(colors, currentAttributesObject.colors);
-    uvRegions = concatenateTypedArrays(uvRegions, currentAttributesObject.uvRegions);
-    texCoords = concatenateTypedArrays(texCoords, currentAttributesObject.texCoords);
     const groupedObject = unifiedObjects[objIndex];
     range.push(groupedObject.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1 + sum);
     range.push(groupedObject.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE + sum);
     sum += groupedObject.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE;
     objIndex += 1;
   }
-  range.push(positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
+  const attributes = concatenateAttributes(unifiedObjects);
+  range.push(attributes.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
   const faceRange = new Uint32Array(range);
-  return { faceRange, featureIds, positions, normals, colors, uvRegions, texCoords, featureCount };
+  return { faceRange, featureIds, featureCount, ...attributes };
+}
+function concatenateAttributes(attributes) {
+  const positionGroups = attributes.map(({ positions: positions2 }) => positions2);
+  const positions = positionGroups.length > 1 ? concatenateTypedArrays(...positionGroups) : positionGroups[0];
+  const normalGroups = attributes.map(({ normals: normals2 }) => normals2);
+  const normals = normalGroups.length > 1 ? concatenateTypedArrays(...normalGroups) : normalGroups[0];
+  const colorGroups = attributes.map(({ colors: colors2 }) => colors2);
+  const colors = colorGroups.length > 1 ? concatenateTypedArrays(...colorGroups) : colorGroups[0];
+  const texCoordGroups = attributes.map(({ texCoords: texCoords2 }) => texCoords2);
+  const texCoords = texCoordGroups.length > 1 ? concatenateTypedArrays(...texCoordGroups) : texCoordGroups[0];
+  const uvRegionGroups = attributes.map(({ uvRegions: uvRegions2 }) => uvRegions2);
+  const uvRegions = uvRegionGroups.length > 1 ? concatenateTypedArrays(...uvRegionGroups) : uvRegionGroups[0];
+  return {
+    positions,
+    normals,
+    colors,
+    texCoords,
+    uvRegions
+  };
 }
 
 // src/i3s-converter/helpers/coordinate-converter.ts
@@ -59818,19 +59867,19 @@ function generateBatchIdsFromTexture(featureIdTexture, textureCoordinates, image
 }
 
 // src/i3s-converter/helpers/feature-attributes.ts
-function flattenPropertyTableByFeatureIds(featureIds, propertyTable) {
+function flattenPropertyTableByFeatureIds(featureIdsMap, propertyTable) {
   const resultPropertyTable = {};
   for (const propertyName in propertyTable) {
     const properties = propertyTable[propertyName];
-    resultPropertyTable[propertyName] = getPropertiesByFeatureIds(properties, featureIds);
+    resultPropertyTable[propertyName] = getPropertiesByFeatureIds(properties, featureIdsMap);
   }
   return resultPropertyTable;
 }
-function getPropertiesByFeatureIds(properties, featureIds) {
+function getPropertiesByFeatureIds(properties, featureIdsMap) {
   const resultProperties = [];
   if (properties) {
-    for (const featureId of featureIds) {
-      const property = properties[featureId] || null;
+    for (const featureIdKey in featureIdsMap) {
+      const property = properties[featureIdKey] || null;
       resultProperties.push(property);
     }
   }
@@ -60047,8 +60096,9 @@ async function _makeNodeResources({
   const boundingVolumes = convertedAttributes.boundingVolumes;
   const vertexCount = convertedAttributes.positions.length / VALUES_PER_VERTEX2;
   const { faceRange, featureIds, positions, normals, colors, uvRegions, texCoords, featureCount } = generateAttributes(convertedAttributes);
-  if (tileContent.batchTableJson) {
-    makeFeatureIdsUnique(featureIds, convertedAttributes.featureIndices, featuresHashArray, tileContent.batchTableJson);
+  let featureIdsMap = {};
+  if (propertyTable) {
+    featureIdsMap = makeFeatureIdsUnique(featureIds, convertedAttributes.featureIndices, featuresHashArray, propertyTable);
   }
   const header = new Uint32Array(2);
   const typedFeatureIds = generateBigUint64Array(featureIds);
@@ -60065,7 +60115,7 @@ async function _makeNodeResources({
   }, libraries) : null;
   let attributes = [];
   if (attributeStorageInfo && propertyTable) {
-    attributes = convertPropertyTableToAttributeBuffers(featureIds, propertyTable, attributeStorageInfo);
+    attributes = convertPropertyTableToAttributeBuffers(featureIds, featureIdsMap, propertyTable, attributeStorageInfo);
   }
   return {
     nodeId,
@@ -60529,6 +60579,7 @@ function makeFeatureIdsUnique(featureIds, featureIndices, featuresHashArray, bat
   const replaceMap = getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray);
   replaceIndicesByUnique(featureIndices, replaceMap);
   replaceIndicesByUnique(featureIds, replaceMap);
+  return replaceMap;
 }
 function getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray) {
   const featureMap = {};
@@ -60559,10 +60610,10 @@ function replaceIndicesByUnique(indicesArray, featureMap) {
     indicesArray[index] = featureMap[indicesArray[index]];
   }
 }
-function convertPropertyTableToAttributeBuffers(featureIds, propertyTable, attributeStorageInfo) {
+function convertPropertyTableToAttributeBuffers(featureIds, featureIdsMap, propertyTable, attributeStorageInfo) {
   const attributeBuffers = [];
   const needFlattenPropertyTable = checkPropertiesLength(featureIds, propertyTable);
-  const properties = needFlattenPropertyTable ? flattenPropertyTableByFeatureIds(featureIds, propertyTable) : propertyTable;
+  const properties = needFlattenPropertyTable ? flattenPropertyTableByFeatureIds(featureIdsMap, propertyTable) : propertyTable;
   const propertyTableWithObjectIds = {
     OBJECTID: featureIds,
     ...properties
@@ -60906,10 +60957,12 @@ var PGMLoader = {
   module: "tile-converter",
   version: VERSION12,
   mimeTypes: ["image/x-portable-graymap"],
-  parse: async (arrayBuffer, options) => (0, import_geoid.parsePGM)(new Uint8Array(arrayBuffer), options),
+  parse: async (arrayBuffer, options) => (0, import_geoid.parsePGM)(new Uint8Array(arrayBuffer), options?.pgm || {}),
   extensions: ["pgm"],
   options: {
-    cubic: false
+    pgm: {
+      cubic: false
+    }
   }
 };
 
@@ -63342,9 +63395,6 @@ var import_geospatial9 = __toModule(require_es52());
 
 // ../i3s/src/i3s-node-page-loader.ts
 var VERSION15 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-async function parseNodePage(data, options) {
-  return JSON.parse(new TextDecoder().decode(data));
-}
 var I3SNodePageLoader = {
   name: "I3S Node Page",
   id: "i3s-node-page",
@@ -63353,8 +63403,13 @@ var I3SNodePageLoader = {
   mimeTypes: ["application/json"],
   parse: parseNodePage,
   extensions: ["json"],
-  options: {}
+  options: {
+    i3s: {}
+  }
 };
+async function parseNodePage(data, options) {
+  return JSON.parse(new TextDecoder().decode(data));
+}
 
 // ../i3s/src/lib/helpers/i3s-nodepages-tiles.ts
 var I3SNodePagesTiles = class {