@loaders.gl/tile-converter 4.4.0-alpha.1 → 4.4.0-alpha.9

package/dist/i3s-converter/helpers/feature-attributes.js

@@ -1,193 +0,0 @@
-import { AttributeType } from "../types.js";
-import { EXT_FEATURE_METADATA, EXT_STRUCTURAL_METADATA } from '@loaders.gl/gltf';
-/**
- * Takes attributes from property table based on featureIdsMap.
- * If there is no property value for particular featureId (index) the property will be null.
- * Example:
- * Initial data:
- *   OBJECTID: {0: 0, 3: 33, 4: 333}
- *   component: ['Windows', 'Frames', 'Wall', 'Roof', 'Skylight']
- * Result:
- *   OBJECTID: [0, 33, 333]
- *   component: ['Windows', 'Roof', 'Skylight']
- * @param featureIdsMap
- * @param propertyTable
- */
-export function flattenPropertyTableByFeatureIds(featureIdsMap, propertyTable) {
-    const resultPropertyTable = {};
-    for (const propertyName in propertyTable) {
-        const properties = propertyTable[propertyName];
-        resultPropertyTable[propertyName] = getPropertiesByFeatureIds(properties, featureIdsMap);
-    }
-    return resultPropertyTable;
-}
-/**
- * Getting properties by featureId index
- * @param properties
- * @param featureIdsMap
- */
-function getPropertiesByFeatureIds(properties, featureIdsMap) {
-    const resultProperties = [];
-    if (properties) {
-        for (const featureIdKey in featureIdsMap) {
-            const property = properties[featureIdKey] || null;
-            resultProperties.push(property);
-        }
-    }
-    return resultProperties;
-}
-/**
- * Check that all attributes in propertyTable have the same length as FeatureIds.
- * If there are differencies between lengths we should flatten property table based on exiesting featureIds.
- * @param featureIds
- * @param propertyTable
- * @returns
- */
-export function checkPropertiesLength(featureIds, propertyTable) {
-    let needFlatten = false;
-    for (const attribute of Object.values(propertyTable)) {
-        if (!featureIds || !attribute || featureIds.length !== attribute.length) {
-            needFlatten = true;
-        }
-    }
-    return needFlatten;
-}
-/**
- * Get the attribute type for attributeStorageInfo https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
- * @param attribute - attribute taken from propertyTable
- */
-export function getAttributeType(attribute) {
-    if (typeof attribute === 'string' || typeof attribute === 'bigint') {
-        return AttributeType.STRING_TYPE;
-    }
-    else if (typeof attribute === 'number') {
-        return Number.isInteger(attribute) ? AttributeType.SHORT_INT_TYPE : AttributeType.DOUBLE_TYPE;
-    }
-    return AttributeType.STRING_TYPE;
-}
-/**
- * Gets attribute's types based on the property table records.
- * @param propertyTable - Table with layer meta data.
- * @returns set of attribute types
- * @example of returned object:
- * {
- *   "opt_uint8":  "Int32",
- *   "opt_uint64": "string"
- * }
- */
-export function getAttributeTypesMapFromPropertyTable(propertyTable) {
-    const attributeTypesMap = {};
-    for (const key in propertyTable) {
-        // Get attribute type based on the first element of each property.
-        const firstAttribute = propertyTable[key][0];
-        const attributeType = getAttributeType(firstAttribute);
-        attributeTypesMap[key] = attributeType;
-    }
-    return attributeTypesMap;
-}
-/**
- * Gets attribute's types from the extension schema selected by the class name 'metadataClass'.
- * @param gltfJson - JSON part of GLB content
- * @param metadataClass - name of the schema class
- * @returns set of attribute's types
- * @example of returned object:
- * {
- *   "opt_uint8":  "Int32",
- *   "opt_uint64": "string"
- * }
- */
-export const getAttributeTypesMapFromSchema = (gltfJson, metadataClass) => {
-    const attributeTypesMap = {};
-    const extFeatureMetadataSchemaClass = gltfJson.extensions?.[EXT_FEATURE_METADATA]?.schema?.classes?.[metadataClass];
-    if (extFeatureMetadataSchemaClass) {
-        for (const propertyName in extFeatureMetadataSchemaClass.properties) {
-            const property = extFeatureMetadataSchemaClass.properties[propertyName];
-            const attributeProperty = getAttributeTypeFromExtFeatureMetadata(property);
-            attributeTypesMap[propertyName] = attributeProperty;
-        }
-        return attributeTypesMap;
-    }
-    const extStructuralMetadataSchemaClass = gltfJson.extensions?.[EXT_STRUCTURAL_METADATA]?.schema?.classes?.[metadataClass];
-    if (extStructuralMetadataSchemaClass) {
-        for (const propertyName in extStructuralMetadataSchemaClass.properties) {
-            const property = extStructuralMetadataSchemaClass.properties[propertyName];
-            const attributeProperty = getAttributeTypeFromExtStructuralMetadata(property);
-            attributeTypesMap[propertyName] = attributeProperty;
-        }
-        return attributeTypesMap;
-    }
-    return null;
-};
-/**
- * Gets the attribute type according to the Ext_feature_metadata extension class schema
- * @see https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
- * @param property - schema of the class property for Ext_feature_metadata
- * @returns attribute's type
- */
-// eslint-disable-next-line complexity
-const getAttributeTypeFromExtFeatureMetadata = (property) => {
-    let attributeType;
-    switch (property.type) {
-        case 'INT8':
-        case 'UINT8':
-        case 'INT16':
-        case 'UINT16':
-        case 'INT32':
-        case 'UINT32':
-            attributeType = AttributeType.SHORT_INT_TYPE;
-            break;
-        case 'FLOAT32':
-        case 'FLOAT64':
-            attributeType = AttributeType.DOUBLE_TYPE;
-            break;
-        case 'INT64':
-        case 'UINT64':
-        case 'BOOLEAN':
-        case 'ENUM':
-        case 'STRING':
-        case 'ARRAY':
-            attributeType = AttributeType.STRING_TYPE;
-            break;
-        default:
-            attributeType = AttributeType.STRING_TYPE;
-            break;
-    }
-    return attributeType;
-};
-/**
- * Gets the attribute type according to the Ext_structural_metadata extension class schema
- * @see https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
- * @param property - schema of the class property for Ext_structural_metadata
- * @returns attribute's type
- */
-// eslint-disable-next-line complexity
-const getAttributeTypeFromExtStructuralMetadata = (property) => {
-    let attributeType;
-    if (property.array) {
-        attributeType = AttributeType.STRING_TYPE;
-    }
-    else {
-        switch (property.componentType) {
-            case 'INT8':
-            case 'UINT8':
-            case 'INT16':
-            case 'UINT16':
-            case 'INT32':
-            case 'UINT32':
-                attributeType = AttributeType.SHORT_INT_TYPE;
-                break;
-            case 'FLOAT32':
-            case 'FLOAT64':
-                attributeType = AttributeType.DOUBLE_TYPE;
-                break;
-            case 'INT64':
-            case 'UINT64':
-                attributeType = AttributeType.STRING_TYPE;
-                break;
-            default:
-                attributeType = AttributeType.STRING_TYPE;
-                break;
-        }
-    }
-    return attributeType;
-};

package/dist/i3s-converter/helpers/geometry-attributes.d.ts

@@ -1,8 +0,0 @@
-import type { GeometryAttributes, ConvertedAttributes } from "../types.js";
-/**
- * Generate geometry attributes with faceRange and featureCount
- * @param attributes
- * @returns attirbutes with featureCount, featureIds and changed faceRange.
- */
-export declare function generateAttributes(attributes: ConvertedAttributes): GeometryAttributes;
-//# sourceMappingURL=geometry-attributes.d.ts.map

package/dist/i3s-converter/helpers/geometry-attributes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"geometry-attributes.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/geometry-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EAGpB,oBAAiB;AAMlB;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,mBAAmB,GAAG,kBAAkB,CAyBtF"}

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

@@ -1,226 +0,0 @@
-import { concatenateTypedArrays } from '@loaders.gl/loader-utils';
-const VALUES_PER_VERTEX = 3;
-const POSITIONS_AND_NORMALS_PER_TRIANGLE = 9;
-/**
- * Generate geometry attributes with faceRange and featureCount
- * @param attributes
- * @returns attirbutes with featureCount, featureIds and changed faceRange.
- */
-export function generateAttributes(attributes) {
-    const { positions, normals, texCoords, colors, uvRegions, featureIndices } = attributes;
-    const triangleCount = positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE;
-    if (!featureIndices.length) {
-        return {
-            faceRange: new Uint32Array([0, triangleCount - 1]),
-            featureIds: [0],
-            featureCount: 1,
-            positions,
-            normals,
-            texCoords,
-            colors,
-            uvRegions
-        };
-    }
-    const data = calculateFaceRangesAndFeaturesCount(featureIndices);
-    const attributeObjects = makeAttributeObjects({ ...data, ...attributes });
-    const unifiedAttributeObjectsByFeatureIds = unifyObjectsByFeatureId(attributeObjects);
-    const groupedAttributes = groupAttributesAndRangesByFeatureId(unifiedAttributeObjectsByFeatureIds, data.featureCount);
-    return groupedAttributes;
-}
-/**
- * Calculates face Ranges and feature count based on featureIndices.
- * @param featureIndices
- * @returns Object with featureCount, reordered attributes and changed faceRange.
- */
-function calculateFaceRangesAndFeaturesCount(featureIndices) {
-    let rangeIndex = 1;
-    let featureIndex = 1;
-    let currentFeatureId = getFrequentValue(featureIndices.slice(0, VALUES_PER_VERTEX));
-    const faceRangeList = [];
-    const featureIds = [];
-    const uniqueFeatureIds = [currentFeatureId];
-    faceRangeList[0] = 0;
-    featureIds[0] = currentFeatureId;
-    for (let index = VALUES_PER_VERTEX; index < featureIndices.length; index += VALUES_PER_VERTEX) {
-        const newFeatureId = getFrequentValue(featureIndices.slice(index, index + VALUES_PER_VERTEX));
-        if (currentFeatureId !== newFeatureId) {
-            faceRangeList[rangeIndex] = index / VALUES_PER_VERTEX - 1;
-            faceRangeList[rangeIndex + 1] = index / VALUES_PER_VERTEX;
-            featureIds[featureIndex] = newFeatureId;
-            if (!uniqueFeatureIds.includes(newFeatureId)) {
-                uniqueFeatureIds.push(newFeatureId);
-            }
-            rangeIndex += 2;
-            featureIndex += 1;
-        }
-        currentFeatureId = newFeatureId;
-    }
-    faceRangeList[rangeIndex] = featureIndices.length / VALUES_PER_VERTEX - 1;
-    const faceRange = new Uint32Array(faceRangeList);
-    const featureCount = uniqueFeatureIds.length;
-    return { faceRange, featureCount, featureIds };
-}
-/**
- * Find most frequent value to avoid situation where one vertex can be part of multiple features (objects).
- * @param values
- */
-function getFrequentValue(values) {
-    const map = {};
-    let mostFrequentValue = values[0];
-    let maxCount = 1;
-    for (const value of values) {
-        // Save item and it's frequency count to the map.
-        map[value] = (map[value] || 0) + 1;
-        // Find max count of frequency.
-        maxCount = maxCount > map[value] ? maxCount : map[value];
-        // Find the most frequent value.
-        mostFrequentValue = maxCount > map[value] ? mostFrequentValue : value;
-    }
-    return mostFrequentValue;
-}
-/**
- * Generate list of attribute object grouped by feature ids.
- * @param  attributes
- * @returns sorted list of attribute objects.
- */
-// eslint-disable-next-line max-statements
-function makeAttributeObjects(attributes) {
-    const { featureIds, positions, normals, colors, uvRegions, texCoords, faceRange = new Uint32Array(0) } = attributes;
-    const groupedData = [];
-    const positionsList = new Float32Array(positions);
-    const normalsList = new Float32Array(normals);
-    const colorsList = new Uint8Array(colors);
-    const texCoordsList = new Float32Array(texCoords);
-    const 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];
-        const positionsCount = getSliceAttributeCount('positions', startIndex, endIndex);
-        const normalsCount = getSliceAttributeCount('normals', startIndex, endIndex);
-        const colorsCount = getSliceAttributeCount('colors', startIndex, endIndex);
-        const uvRegionsCount = getSliceAttributeCount('uvRegions', startIndex, endIndex);
-        const texCoordsCount = getSliceAttributeCount('texCoords', startIndex, endIndex);
-        groupedData.push({
-            featureId: featureIds[index],
-            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)
-        });
-        positionsOffset += positionsCount;
-        normalsOffset += normalsCount;
-        colorsOffset += colorsCount;
-        uvRegionsOffset += uvRegionsCount;
-        texCoordsOffset += texCoordsCount;
-    }
-    return groupedData;
-}
-/**
- * Generate sliced count for generating attribute objects depends on attribute name and range.
- * @param attributeName
- * @param startIndex
- * @param endIndex
- * @returns sliced count
- */
-function getSliceAttributeCount(attributeName, startIndex, endIndex) {
-    const itemsPerVertex4 = 4;
-    const texCoordsPerVertex = 2;
-    const trianglesCount = endIndex - startIndex + 1;
-    const vertexCount = trianglesCount * 3;
-    switch (attributeName) {
-        case 'positions':
-        case 'normals':
-            return trianglesCount * POSITIONS_AND_NORMALS_PER_TRIANGLE;
-        case 'colors':
-        case 'uvRegions':
-            return vertexCount * itemsPerVertex4;
-        case 'texCoords':
-            return vertexCount * texCoordsPerVertex;
-        default:
-            return 0;
-    }
-}
-/**
- * Generates unique object list depends on feature ids and concantenate their attributes.
- * @param sortedData
- * @returns unique list of objects
- */
-function unifyObjectsByFeatureId(sortedData) {
-    const groupedMetadata = [];
-    for (const data of sortedData) {
-        const existingObject = groupedMetadata.find((obj) => obj.featureId === data.featureId);
-        if (existingObject) {
-            existingObject.attributes.push(data);
-        }
-        else {
-            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;
-}
-/**
- * Generates attribute objects with new faceRange and reordered attributes.
- * @param unifiedObjects
- * @returns generated attributes with new faceRange.
- */
-function groupAttributesAndRangesByFeatureId(unifiedObjects, featureCount) {
-    const firstAttributeObject = unifiedObjects[0];
-    const featureIds = [firstAttributeObject.featureId || 0];
-    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);
-        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;
-    }
-    const attributes = concatenateAttributes(unifiedObjects);
-    range.push(attributes.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
-    const faceRange = new Uint32Array(range);
-    return { faceRange, featureIds, featureCount, ...attributes };
-}
-/**
- * Concatenate attributes typed arrays
- * @param attributes - grouped by featureId typed arrays
- * @returns - concatenated typed array list
- */
-function concatenateAttributes(attributes) {
-    const positionGroups = attributes.map(({ positions }) => positions);
-    const positions = positionGroups.length > 1 ? concatenateTypedArrays(...positionGroups) : positionGroups[0];
-    const normalGroups = attributes.map(({ normals }) => normals);
-    const normals = normalGroups.length > 1 ? concatenateTypedArrays(...normalGroups) : normalGroups[0];
-    const colorGroups = attributes.map(({ colors }) => colors);
-    const colors = colorGroups.length > 1 ? concatenateTypedArrays(...colorGroups) : colorGroups[0];
-    const texCoordGroups = attributes.map(({ texCoords }) => texCoords);
-    const texCoords = texCoordGroups.length > 1 ? concatenateTypedArrays(...texCoordGroups) : texCoordGroups[0];
-    const uvRegionGroups = attributes.map(({ uvRegions }) => uvRegions);
-    const uvRegions = uvRegionGroups.length > 1 ? concatenateTypedArrays(...uvRegionGroups) : uvRegionGroups[0];
-    return {
-        positions,
-        normals,
-        colors,
-        texCoords,
-        uvRegions
-    };
-}

package/dist/i3s-converter/helpers/geometry-converter.d.ts

@@ -1,60 +0,0 @@
-import type { FeatureTableJson, Tiles3DTileContent } from '@loaders.gl/3d-tiles';
-import { Matrix4 } from '@math.gl/core';
-import { ConvertedAttributes, I3SConvertedResources, I3SMaterialWithTexture } from "../types.js";
-import { AttributeStorageInfo } from '@loaders.gl/i3s';
-import { Geoid } from '@math.gl/geoid';
-import type { GLTFAttributesData } from "../types.js";
-import { BoundingSphere, OrientedBoundingBox } from '@math.gl/culling';
-/**
- * Convert binary data from b3dm file to i3s resources
- *
- * @param tileContent - 3d tile content
- * @param tileTransform - transformation matrix of the tile, calculated recursively multiplying
- *                        transform of all parent tiles and transform of the current tile
- * @param tileBoundingVolume - initialized bounding volume of the source tile
- * @param addNodeToNodePage - function to add new node to node pages
- * @param propertyTable - batch table (corresponding to feature attributes data)
- * @param featuresHashArray - hash array of features that is needed to not to mix up same features in parent and child nodes
- * @param attributeStorageInfo - attributes metadata from 3DSceneLayer json
- * @param draco - is converter should create draco compressed geometry
- * @param generateBoundingVolumes - is converter should create accurate bounding voulmes from geometry attributes
- * @param shouldMergeMaterials - Try to merge similar materials to be able to merge meshes into one node
- * @param geoidHeightModel - model to convert elevation from elipsoidal to geoid
- * @param libraries - dynamicaly loaded 3rd-party libraries
- * @param metadataClass `- user selected feature metadata class name`
- * @returns Array of node resources to create one or more i3s nodes
- */
-export default function convertB3dmToI3sGeometry({ tileContent, tileTransform, tileBoundingVolume, addNodeToNodePage, propertyTable, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, shouldMergeMaterials, geoidHeightModel, libraries, metadataClass }: {
-    tileContent: Tiles3DTileContent;
-    tileTransform: Matrix4;
-    tileBoundingVolume: OrientedBoundingBox | BoundingSphere;
-    addNodeToNodePage: () => Promise<number>;
-    propertyTable: FeatureTableJson | null;
-    featuresHashArray: string[];
-    attributeStorageInfo: AttributeStorageInfo[] | undefined;
-    draco: boolean;
-    generateBoundingVolumes: boolean;
-    shouldMergeMaterials: boolean;
-    geoidHeightModel: Geoid | null;
-    libraries: Record<string, string>;
-    metadataClass?: string;
-}): Promise<I3SConvertedResources[] | null>;
-/**
- * Convert attributes from the gltf nodes tree to i3s plain geometry
- * @param attributesData - geometry attributes from gltf
- * @param materialAndTextureList - array of data about materials and textures of the content
- * @param useCartesianPositions - convert positions to absolute cartesian coordinates instead of cartographic offsets.
- * Cartesian coordinates will be required for creating bounding voulmest from geometry positions
- * @param featureTexture - feature texture key
- * @returns map of converted geometry attributes
- */
-export declare function convertAttributes(attributesData: GLTFAttributesData, materialAndTextureList: I3SMaterialWithTexture[], useCartesianPositions: boolean, featureTexture: string | null): Promise<Map<string, ConvertedAttributes>>;
-/**
- * Find property table in tile
- * For example it can be batchTable for b3dm files or property table in gLTF extension.
- * @param tileContent - 3DTiles tile content
- * @param metadataClass - user selected feature metadata class name
- * @return batch table from b3dm / feature properties from EXT_FEATURE_METADATA or EXT_STRUCTURAL_METADATA.
- */
-export declare function getPropertyTable(tileContent: Tiles3DTileContent | null, metadataClass?: string): FeatureTableJson | null;
-//# sourceMappingURL=geometry-converter.d.ts.map

package/dist/i3s-converter/helpers/geometry-converter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"geometry-converter.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/geometry-converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,gBAAgB,EAAE,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAgB/E,OAAO,EAAU,OAAO,EAAU,MAAM,eAAe,CAAC;AAexD,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,sBAAsB,EAGvB,oBAAiB;AAClB,OAAO,EACL,oBAAoB,EAIrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAC,KAAK,EAAC,MAAM,gBAAgB,CAAC;AAWrC,OAAO,KAAK,EAAC,kBAAkB,EAAgD,oBAAiB;AAEhG,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AAyBrE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAA8B,wBAAwB,CAAC,EACrD,WAAW,EACX,aAAa,EACb,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,oBAAoB,EACpB,KAAK,EACL,uBAAuB,EACvB,oBAAoB,EACpB,gBAAgB,EAChB,SAAS,EACT,aAAa,EACd,EAAE;IACD,WAAW,EAAE,kBAAkB,CAAC;IAChC,aAAa,EAAE,OAAO,CAAC;IACvB,kBAAkB,EAAE,mBAAmB,GAAG,cAAc,CAAC;IACzD,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,aAAa,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACvC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,oBAAoB,EAAE,oBAAoB,EAAE,GAAG,SAAS,CAAC;IACzD,KAAK,EAAE,OAAO,CAAC;IACf,uBAAuB,EAAE,OAAO,CAAC;IACjC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,gBAAgB,EAAE,KAAK,GAAG,IAAI,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,OAAO,CAAC,qBAAqB,EAAE,GAAG,IAAI,CAAC,CAgE1C;AAuJD;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,cAAc,EAAE,kBAAkB,EAClC,sBAAsB,EAAE,sBAAsB,EAAE,EAChD,qBAAqB,EAAE,OAAO,EAC9B,cAAc,EAAE,MAAM,GAAG,IAAI,GAC5B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAiD3C;AAuuCD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,kBAAkB,GAAG,IAAI,EACtC,aAAa,CAAC,EAAE,MAAM,GACrB,gBAAgB,GAAG,IAAI,CA+BzB"}