@loaders.gl/tile-converter 3.3.0-alpha.4 → 3.3.0-alpha.6

package/dist/esm/i3s-converter/helpers/geometry-converter.js

@@ -9,6 +9,7 @@ import { createBoundingVolumesFromGeometry } from './coordinate-converter';
 import { prepareDataForAttributesConversion } from './gltf-attributes';
 import { handleBatchIdsExtensions } from './batch-ids-extensions';
 import { checkPropertiesLength, flattenPropertyTableByFeatureIds } from './feature-attributes';
+
 const DEFAULT_ROUGHNESS_FACTOR = 1;
 const DEFAULT_METALLIC_FACTOR = 1;
 const VALUES_PER_VERTEX = 3;
@@ -22,9 +23,9 @@ const BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES = ['CUSTOM_ATTRIBUTE_2', '_BATCHID', '
 const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
 const EXT_MESH_FEATURES = 'EXT_mesh_features';
 let scratchVector = new Vector3();
+
 export default async function convertB3dmToI3sGeometry(tileContent, addNodeToNodePage, propertyTable, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, geoidHeightModel, workerSource) {
   var _tileContent$gltf;
-
   const useCartesianPositions = generateBoundingVolumes;
   const materialAndTextureList = convertMaterials((_tileContent$gltf = tileContent.gltf) === null || _tileContent$gltf === void 0 ? void 0 : _tileContent$gltf.materials);
   const dataForAttributesConversion = prepareDataForAttributesConversion(tileContent);
@@ -33,39 +34,32 @@ export default async function convertB3dmToI3sGeometry(tileContent, addNodeToNod
   if (generateBoundingVolumes) {
     _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeightModel);
   }
-
   if (convertedAttributesMap.has('default')) {
     materialAndTextureList.push({
       material: getDefaultMaterial()
     });
   }
-
   const result = [];
   let {
     materials = []
   } = tileContent.gltf || {
     materials: []
   };
-
   if (!(materials !== null && materials !== void 0 && materials.length)) {
     materials.push({
       id: 'default'
     });
   }
-
   for (let i = 0; i < materials.length; i++) {
     const sourceMaterial = materials[i];
-
     if (!convertedAttributesMap.has(sourceMaterial.id)) {
       continue;
     }
 
     const convertedAttributes = convertedAttributesMap.get(sourceMaterial.id);
-
     if (!convertedAttributes) {
       continue;
     }
-
     const {
       material,
       texture
@@ -84,11 +78,9 @@ export default async function convertB3dmToI3sGeometry(tileContent, addNodeToNod
       workerSource
     }));
   }
-
   if (!result.length) {
     return null;
   }
-
   return result;
 }
 
@@ -97,7 +89,6 @@ function _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeigh
     const boundingVolumes = createBoundingVolumesFromGeometry(attributes.positions, geoidHeightModel);
     attributes.boundingVolumes = boundingVolumes;
     const cartographicOrigin = boundingVolumes.obb.center;
-
     for (let index = 0; index < attributes.positions.length; index += VALUES_PER_VERTEX) {
       const vertex = attributes.positions.subarray(index, index + VALUES_PER_VERTEX);
       Ellipsoid.WGS84.cartesianToCartographic(Array.from(vertex), scratchVector);
@@ -108,20 +99,20 @@ function _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeigh
   }
 }
 
-async function _makeNodeResources({
-  convertedAttributes,
-  material,
-  texture,
-  tileContent,
-  nodeId,
-  featuresHashArray,
-  propertyTable,
-  attributeStorageInfo,
-  draco,
-  workerSource
-}) {
+async function _makeNodeResources(_ref) {
   var _tileContent$gltf2;
-
+  let {
+    convertedAttributes,
+    material,
+    texture,
+    tileContent,
+    nodeId,
+    featuresHashArray,
+    propertyTable,
+    attributeStorageInfo,
+    draco,
+    workerSource
+  } = _ref;
   const boundingVolumes = convertedAttributes.boundingVolumes;
   const vertexCount = convertedAttributes.positions.length / VALUES_PER_VERTEX;
   const {
@@ -133,11 +124,9 @@ async function _makeNodeResources({
     texCoords,
     featureCount
   } = generateAttributes(convertedAttributes);
-
   if (tileContent.batchTableJson) {
     makeFeatureIdsUnique(featureIds, convertedAttributes.featureIndices, featuresHashArray, tileContent.batchTableJson);
   }
-
   const header = new Uint32Array(2);
   const typedFeatureIds = generateBigUint64Array(featureIds);
   header.set([vertexCount, featureCount], 0);
@@ -151,11 +140,9 @@ async function _makeNodeResources({
     faceRange
   }, workerSource.draco) : null;
   let attributes = [];
-
   if (attributeStorageInfo && propertyTable) {
     attributes = convertPropertyTableToAttributeBuffers(featureIds, propertyTable, attributeStorageInfo);
   }
-
   return {
     nodeId,
     geometry: fileBuffer,
@@ -179,7 +166,6 @@ export async function convertAttributes(attributesData, useCartesianPositions) {
     cartesianModelMatrix
   } = attributesData;
   const attributesMap = new Map();
-
   for (const material of gltfMaterials || [{
     id: 'default'
   }]) {
@@ -193,16 +179,12 @@ export async function convertAttributes(attributesData, useCartesianPositions) {
       boundingVolumes: null
     });
   }
-
   convertNodes(nodes, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions);
-
   for (const attrKey of attributesMap.keys()) {
     const attributes = attributesMap.get(attrKey);
-
     if (!attributes) {
       continue;
     }
-
     if (attributes.positions.length === 0) {
       attributesMap.delete(attrKey);
       continue;
@@ -213,11 +195,11 @@ export async function convertAttributes(attributesData, useCartesianPositions) {
       delete attributes.featureIndicesGroups;
     }
   }
-
   return attributesMap;
 }
 
-function convertNodes(nodes, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new 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) {
+  let matrix = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
   if (nodes) {
     for (const node of nodes) {
       convertNode(node, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix);
@@ -233,56 +215,47 @@ function getCompositeTransformationMatrix(node, matrix) {
     scale,
     translation
   } = node;
-
   if (nodeMatrix) {
     transformationMatrix = matrix.multiplyRight(nodeMatrix);
   }
-
   if (translation) {
     transformationMatrix = transformationMatrix.translate(translation);
   }
-
   if (rotation) {
     transformationMatrix = transformationMatrix.rotateXYZ(rotation);
   }
-
   if (scale) {
     transformationMatrix = transformationMatrix.scale(scale);
   }
-
   return transformationMatrix;
 }
 
-function convertNode(node, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertNode(node, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions) {
+  let matrix = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
   const transformationMatrix = getCompositeTransformationMatrix(node, matrix);
   const mesh = node.mesh;
-
   if (mesh) {
     convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix);
   }
-
   convertNodes(node.children || [], images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix);
 }
 
-function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions = false, matrix = new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, attributesMap) {
+  let useCartesianPositions = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+  let matrix = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
   for (const primitive of mesh.primitives) {
     var _primitive$indices, _primitive$indices2, _primitive$indices3, _primitive$indices4, _primitive$indices5;
-
     let outputAttributes = null;
-
     if (primitive.material) {
       outputAttributes = attributesMap.get(primitive.material.id);
     } else if (attributesMap.has('default')) {
       outputAttributes = attributesMap.get('default');
     }
-
     assert(outputAttributes !== null, 'Primitive - material mapping failed');
     const attributes = primitive.attributes;
-
     if (!outputAttributes) {
       continue;
     }
-
     outputAttributes.positions = concatenateTypedArrays(outputAttributes.positions, transformVertexArray({
       vertices: attributes.POSITION.value,
       cartographicOrigin,
@@ -315,11 +288,9 @@ function transformVertexArray(args) {
     attributeSpecificTransformation
   } = args;
   const newVertices = new Float32Array(indices.length * VALUES_PER_VERTEX);
-
   if (!vertices) {
     return newVertices;
   }
-
   for (let i = 0; i < indices.length; i++) {
     const coordIndex = indices[i] * VALUES_PER_VERTEX;
     const vertex = vertices.subarray(coordIndex, coordIndex + VALUES_PER_VERTEX);
@@ -329,7 +300,6 @@ function transformVertexArray(args) {
     newVertices[i * VALUES_PER_VERTEX + 1] = vertexVector.y;
     newVertices[i * VALUES_PER_VERTEX + 2] = vertexVector.z;
   }
-
   return newVertices;
 }
 
@@ -340,17 +310,13 @@ function transformVertexPositions(vertexVector, calleeArgs) {
     nodeMatrix,
     useCartesianPositions
   } = calleeArgs;
-
   if (nodeMatrix) {
     vertexVector = vertexVector.transform(nodeMatrix);
   }
-
   vertexVector = vertexVector.transform(cartesianModelMatrix);
-
   if (useCartesianPositions) {
     return vertexVector;
   }
-
   Ellipsoid.WGS84.cartesianToCartographic([vertexVector[0], vertexVector[1], vertexVector[2]], vertexVector);
   vertexVector = vertexVector.subtract(cartographicOrigin);
   return vertexVector;
@@ -361,56 +327,45 @@ function transformVertexNormals(vertexVector, calleeArgs) {
     cartesianModelMatrix,
     nodeMatrix
   } = calleeArgs;
-
   if (nodeMatrix) {
     vertexVector = vertexVector.transformAsVector(nodeMatrix);
   }
-
   vertexVector = vertexVector.transformAsVector(cartesianModelMatrix);
   return vertexVector;
 }
 
 function flattenTexCoords(texCoords, indices) {
   const newTexCoords = new Float32Array(indices.length * VALUES_PER_TEX_COORD);
-
   if (!texCoords) {
     newTexCoords.fill(1);
     return newTexCoords;
   }
-
   for (let i = 0; i < indices.length; i++) {
     const coordIndex = indices[i] * VALUES_PER_TEX_COORD;
     const texCoord = texCoords.subarray(coordIndex, coordIndex + VALUES_PER_TEX_COORD);
     newTexCoords[i * VALUES_PER_TEX_COORD] = texCoord[0];
     newTexCoords[i * VALUES_PER_TEX_COORD + 1] = texCoord[1];
   }
-
   return newTexCoords;
 }
 
 function flattenColors(colorsAttribute, indices) {
   const components = (colorsAttribute === null || colorsAttribute === void 0 ? void 0 : colorsAttribute.components) || VALUES_PER_COLOR_ELEMENT;
   const newColors = new Uint8Array(indices.length * components);
-
   if (!colorsAttribute) {
     newColors.fill(255);
     return newColors;
   }
-
   const colors = colorsAttribute.value;
-
   for (let i = 0; i < indices.length; i++) {
     const colorIndex = indices[i] * components;
     const color = colors.subarray(colorIndex, colorIndex + components);
     const colorUint8 = new Uint8Array(components);
-
     for (let j = 0; j < color.length; j++) {
       colorUint8[j] = color[j] * 255;
     }
-
     newColors.set(colorUint8, i * components);
   }
-
   return newColors;
 }
 
@@ -418,48 +373,39 @@ function flattenBatchIds(batchedIds, indices) {
   if (!batchedIds.length || !indices.length) {
     return [];
   }
-
   const newBatchIds = [];
-
   for (let i = 0; i < indices.length; i++) {
     const coordIndex = indices[i];
     newBatchIds.push(batchedIds[coordIndex]);
   }
-
   return newBatchIds;
 }
 
 function getBatchIds(attributes, primitive, images) {
   const batchIds = handleBatchIdsExtensions(attributes, primitive, images);
-
   if (batchIds.length) {
     return batchIds;
   }
-
   for (let index = 0; index < BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES.length; index++) {
     const possibleBatchIdAttributeName = BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES[index];
-
     if (attributes[possibleBatchIdAttributeName] && attributes[possibleBatchIdAttributeName].value) {
       return attributes[possibleBatchIdAttributeName].value;
     }
   }
-
   return [];
 }
 
-function convertMaterials(sourceMaterials = []) {
+function convertMaterials() {
+  let sourceMaterials = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   const result = [];
-
   for (const sourceMaterial of sourceMaterials) {
     result.push(convertMaterial(sourceMaterial));
   }
-
   return result;
 }
 
 function convertMaterial(sourceMaterial) {
   var _sourceMaterial$emiss, _sourceMaterial$pbrMe, _sourceMaterial$pbrMe2, _sourceMaterial$pbrMe3;
-
   const material = {
     doubleSided: sourceMaterial.doubleSided,
     emissiveFactor: (_sourceMaterial$emiss = sourceMaterial.emissiveFactor) === null || _sourceMaterial$emiss === void 0 ? void 0 : _sourceMaterial$emiss.map(c => Math.round(c * 255)),
@@ -470,7 +416,6 @@ function convertMaterial(sourceMaterial) {
     }
   };
   let texture;
-
   if (sourceMaterial !== null && sourceMaterial !== void 0 && (_sourceMaterial$pbrMe3 = sourceMaterial.pbrMetallicRoughness) !== null && _sourceMaterial$pbrMe3 !== void 0 && _sourceMaterial$pbrMe3.baseColorTexture) {
     texture = sourceMaterial.pbrMetallicRoughness.baseColorTexture.texture.source;
     material.pbrMetallicRoughness.baseColorTexture = {
@@ -482,14 +427,11 @@ function convertMaterial(sourceMaterial) {
       textureSetDefinitionId: 0
     };
   }
-
   if (!texture) {
     var _sourceMaterial$pbrMe4;
-
     const baseColorFactor = sourceMaterial === null || sourceMaterial === void 0 ? void 0 : (_sourceMaterial$pbrMe4 = sourceMaterial.pbrMetallicRoughness) === null || _sourceMaterial$pbrMe4 === void 0 ? void 0 : _sourceMaterial$pbrMe4.baseColorFactor;
     material.pbrMetallicRoughness.baseColorFactor = baseColorFactor && baseColorFactor.map(c => Math.round(c * 255)) || undefined;
   }
-
   return {
     material,
     texture
@@ -500,13 +442,10 @@ function convertAlphaMode(gltfAlphaMode) {
   switch (gltfAlphaMode) {
     case 'OPAQUE':
       return 'opaque';
-
     case 'MASK':
       return 'mask';
-
     case 'BLEND':
       return 'blend';
-
     default:
       return 'opaque';
   }
@@ -524,57 +463,48 @@ function getDefaultMaterial() {
 
 function getSharedResources(gltfMaterials, nodeId) {
   const i3sResources = {};
-
   if (!gltfMaterials || !gltfMaterials.length) {
     return i3sResources;
   }
-
   i3sResources.materialDefinitionInfos = [];
-
   for (const gltfMaterial of gltfMaterials) {
     const {
       materialDefinitionInfo,
       textureDefinitionInfo
     } = convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId);
     i3sResources.materialDefinitionInfos.push(materialDefinitionInfo);
-
     if (textureDefinitionInfo) {
       i3sResources.textureDefinitionInfos = i3sResources.textureDefinitionInfos || [];
       i3sResources.textureDefinitionInfos.push(textureDefinitionInfo);
     }
   }
-
   return i3sResources;
 }
 
 function convertGLTFMaterialToI3sSharedResources(gltfMaterial, nodeId) {
   var _gltfMaterial$pbrMeta;
-
   const texture = (gltfMaterial === null || gltfMaterial === void 0 ? void 0 : (_gltfMaterial$pbrMeta = gltfMaterial.pbrMetallicRoughness) === null || _gltfMaterial$pbrMeta === void 0 ? void 0 : _gltfMaterial$pbrMeta.baseColorTexture) || gltfMaterial.emissiveTexture;
   let textureDefinitionInfo = null;
-
   if (texture) {
     textureDefinitionInfo = extractSharedResourcesTextureInfo(texture.texture, nodeId);
   }
-
   const {
     baseColorFactor,
     metallicFactor
   } = (gltfMaterial === null || gltfMaterial === void 0 ? void 0 : gltfMaterial.pbrMetallicRoughness) || {};
   let colorFactor = baseColorFactor;
-
   if ((!baseColorFactor || baseColorFactor[3] === 0) && gltfMaterial.emissiveFactor) {
     colorFactor = gltfMaterial.emissiveFactor;
     colorFactor[3] = colorFactor[3] || 1;
   }
-
   return {
     materialDefinitionInfo: extractSharedResourcesMaterialInfo(colorFactor || [1, 1, 1, 1], metallicFactor),
     textureDefinitionInfo
   };
 }
 
-function extractSharedResourcesMaterialInfo(baseColorFactor, metallicFactor = 1) {
+function extractSharedResourcesMaterialInfo(baseColorFactor) {
+  let metallicFactor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
   const matDielectricColorComponent = 0.04 / 255;
   const black = new Vector4(0, 0, 0, 1);
   const unitVector = new Vector4(1, 1, 1, 1);
@@ -595,7 +525,6 @@ function extractSharedResourcesMaterialInfo(baseColorFactor, metallicFactor = 1)
 
 function extractSharedResourcesTextureInfo(texture, nodeId) {
   var _texture$source, _texture$source2, _texture$source3;
-
   return {
     encoding: texture !== null && texture !== void 0 && (_texture$source = texture.source) !== null && _texture$source !== void 0 && _texture$source.mimeType ? [texture.source.mimeType] : undefined,
     images: [{
@@ -608,7 +537,6 @@ function extractSharedResourcesTextureInfo(texture, nodeId) {
 
 function generateImageId(texture, nodeId) {
   var _texture$source4;
-
   const {
     width,
     height
@@ -635,34 +563,28 @@ function makeFeatureIdsUnique(featureIds, featureIndices, featuresHashArray, bat
 
 function getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray) {
   const featureMap = {};
-
   for (let index = 0; index < featureIds.length; index++) {
     const oldFeatureId = featureIds[index];
     const uniqueFeatureId = getOrCreateUniqueFeatureId(index, batchTable, featuresHashArray);
     featureMap[oldFeatureId.toString()] = uniqueFeatureId;
   }
-
   return featureMap;
 }
 
 function generateStringFromBatchTableByIndex(batchTable, index) {
   let str = '';
-
   for (const key in batchTable) {
     str += batchTable[key][index];
   }
-
   return str;
 }
 
 function getOrCreateUniqueFeatureId(index, batchTable, featuresHashArray) {
   const batchTableStr = generateStringFromBatchTableByIndex(batchTable, index);
   const hash = md5(batchTableStr);
-
   if (featuresHashArray.includes(hash)) {
     return featuresHashArray.indexOf(hash);
   }
-
   return featuresHashArray.push(hash) - 1;
 }
 
@@ -680,38 +602,31 @@ function convertPropertyTableToAttributeBuffers(featureIds, propertyTable, attri
     OBJECTID: featureIds,
     ...properties
   };
-
   for (const propertyName in propertyTableWithObjectIds) {
     const type = getAttributeType(propertyName, attributeStorageInfo);
     const value = propertyTableWithObjectIds[propertyName];
     const attributeBuffer = generateAttributeBuffer(type, value);
     attributeBuffers.push(attributeBuffer);
   }
-
   return attributeBuffers;
 }
 
 function generateAttributeBuffer(type, value) {
   let attributeBuffer;
-
   switch (type) {
     case OBJECT_ID_TYPE:
     case SHORT_INT_TYPE:
       attributeBuffer = generateShortIntegerAttributeBuffer(value);
       break;
-
     case DOUBLE_TYPE:
       attributeBuffer = generateDoubleAttributeBuffer(value);
       break;
-
     case STRING_TYPE:
       attributeBuffer = generateStringAttributeBuffer(value);
       break;
-
     default:
       attributeBuffer = generateStringAttributeBuffer(value);
   }
-
   return attributeBuffer;
 }
 
@@ -738,7 +653,6 @@ function generateStringAttributeBuffer(batchAttributes) {
   let totalNumberOfBytes = 0;
   const stringSizesArray = new Uint32Array(batchAttributes.length);
   const stringBufferArray = [];
-
   for (let index = 0; index < batchAttributes.length; index++) {
     const currentString = "".concat(String(batchAttributes[index]), "\0");
     const currentStringBuffer = Buffer.from(currentString);
@@ -747,18 +661,15 @@ function generateStringAttributeBuffer(batchAttributes) {
     stringSizesArray[index] = currentStringSize;
     stringBufferArray.push(currentStringBuffer);
   }
-
   const totalBytes = new Uint32Array([totalNumberOfBytes]);
   return concatenateArrayBuffers(stringCountArray.buffer, totalBytes.buffer, stringSizesArray.buffer, ...stringBufferArray);
 }
 
 function generateBigUint64Array(featureIds) {
   const typedFeatureIds = new BigUint64Array(featureIds.length);
-
   for (let index = 0; index < featureIds.length; index++) {
     typedFeatureIds[index] = BigInt(featureIds[index]);
   }
-
   return typedFeatureIds;
 }
 
@@ -772,11 +683,9 @@ async function generateCompressedGeometry(vertexCount, convertedAttributes, attr
     faceRange
   } = attributes;
   const indices = new Uint32Array(vertexCount);
-
   for (let index = 0; index < indices.length; index++) {
     indices.set([index], index);
   }
-
   const featureIndices = new Uint32Array(convertedAttributes.featureIndices.length ? convertedAttributes.featureIndices : vertexCount);
   const featureIndex = generateFeatureIndexAttribute(featureIndices, faceRange);
   const compressedAttributes = {
@@ -785,11 +694,9 @@ async function generateCompressedGeometry(vertexCount, convertedAttributes, attr
     colors,
     'feature-index': featureIndex
   };
-
   if (texCoords.length) {
     compressedAttributes.texCoords = texCoords;
   }
-
   const attributesMetadata = {
     'feature-index': {
       'i3s-attribute-type': 'feature-index',
@@ -799,7 +706,8 @@ async function generateCompressedGeometry(vertexCount, convertedAttributes, attr
   return encode({
     attributes: compressedAttributes,
     indices
-  }, DracoWriterWorker, { ...DracoWriterWorker.options,
+  }, DracoWriterWorker, {
+    ...DracoWriterWorker.options,
     source: dracoWorkerSoure,
     reuseWorkers: true,
     _nodeWorkers: true,
@@ -814,41 +722,34 @@ function generateFeatureIndexAttribute(featureIndex, faceRange) {
   const orderedFeatureIndices = new Uint32Array(featureIndex.length);
   let fillIndex = 0;
   let startIndex = 0;
-
   for (let index = 1; index < faceRange.length; index += 2) {
     const endIndex = (faceRange[index] + 1) * VALUES_PER_VERTEX;
     orderedFeatureIndices.fill(fillIndex, startIndex, endIndex);
     fillIndex++;
     startIndex = endIndex + 1;
   }
-
   return orderedFeatureIndices;
 }
 
 export function getPropertyTable(tileContent) {
   const batchTableJson = tileContent === null || tileContent === void 0 ? void 0 : tileContent.batchTableJson;
-
   if (batchTableJson) {
     return batchTableJson;
   }
-
   const {
     extensionName,
     extension
   } = getPropertyTableExtension(tileContent);
-
   switch (extensionName) {
     case EXT_MESH_FEATURES:
       {
         console.warn('The I3S converter does not yet support the EXT_mesh_features extension');
         return null;
       }
-
     case EXT_FEATURE_METADATA:
       {
         return getPropertyTableFromExtFeatureMetadata(extension);
       }
-
     default:
       return null;
   }
@@ -856,28 +757,22 @@ export function getPropertyTable(tileContent) {
 
 function getPropertyTableExtension(tileContent) {
   var _tileContent$gltf3, _tileContent$gltf5, _tileContent$gltf5$ex;
-
   const extensionsWithPropertyTables = [EXT_FEATURE_METADATA, EXT_MESH_FEATURES];
   const extensionsUsed = tileContent === null || tileContent === void 0 ? void 0 : (_tileContent$gltf3 = tileContent.gltf) === null || _tileContent$gltf3 === void 0 ? void 0 : _tileContent$gltf3.extensionsUsed;
-
   if (!extensionsUsed) {
     return {
       extensionName: null,
       extension: null
     };
   }
-
   let extensionName = '';
-
   for (const extensionItem of (tileContent === null || tileContent === void 0 ? void 0 : (_tileContent$gltf4 = tileContent.gltf) === null || _tileContent$gltf4 === void 0 ? void 0 : _tileContent$gltf4.extensionsUsed) || []) {
     var _tileContent$gltf4;
-
     if (extensionsWithPropertyTables.includes(extensionItem)) {
       extensionName = extensionItem;
       break;
     }
   }
-
   const extension = tileContent === null || tileContent === void 0 ? void 0 : (_tileContent$gltf5 = tileContent.gltf) === null || _tileContent$gltf5 === void 0 ? void 0 : (_tileContent$gltf5$ex = _tileContent$gltf5.extensions) === null || _tileContent$gltf5$ex === void 0 ? void 0 : _tileContent$gltf5$ex[extensionName];
   return {
     extensionName,
@@ -890,24 +785,18 @@ function getPropertyTableFromExtFeatureMetadata(extension) {
     console.warn('The I3S converter does not yet support the EXT_feature_metadata feature textures');
     return null;
   }
-
   if (extension !== null && extension !== void 0 && extension.featureTables) {
     var _Object$keys;
-
     const firstFeatureTableName = (_Object$keys = Object.keys(extension.featureTables)) === null || _Object$keys === void 0 ? void 0 : _Object$keys[0];
-
     if (firstFeatureTableName) {
       const featureTable = extension === null || extension === void 0 ? void 0 : extension.featureTables[firstFeatureTableName];
       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");
   return null;
 }