@loaders.gl/3d-tiles 3.1.0-alpha.5 → 3.1.0-beta.1

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 export { Tiles3DLoader } from './tiles-3d-loader';
 export { CesiumIonLoader } from './cesium-ion-loader';
+export { Tile3DSubtreeLoader } from './tile-3d-subtree-loader';
 export { Tile3DWriter } from './tile-3d-writer';
 export { default as Tile3DFeatureTable } from './lib/classes/tile-3d-feature-table';
 export { default as Tile3DBatchTable } from './lib/classes/tile-3d-batch-table';
 export { TILE3D_TYPE } from './lib/constants';
 export { getIonTilesetMetadata as _getIonTilesetMetadata } from './lib/ion/ion';
 export type { BatchTableJson, B3DMContent, Node3D } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAC,mBAAmB,EAAC,MAAM,0BAA0B,CAAC;AAG7D,OAAO,EAAC,YAAY,EAAC,MAAM,kBAAkB,CAAC;AAG9C,OAAO,EAAC,OAAO,IAAI,kBAAkB,EAAC,MAAM,qCAAqC,CAAC;AAClF,OAAO,EAAC,OAAO,IAAI,gBAAgB,EAAC,MAAM,mCAAmC,CAAC;AAG9E,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAC,qBAAqB,IAAI,sBAAsB,EAAC,MAAM,eAAe,CAAC;AAC9E,YAAY,EAAC,cAAc,EAAE,WAAW,EAAE,MAAM,EAAC,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getIonTilesetMetadata = exports.TILE3D_TYPE = exports.Tile3DBatchTable = exports.Tile3DFeatureTable = exports.Tile3DWriter = exports.Tile3DSubtreeLoader = exports.CesiumIonLoader = exports.Tiles3DLoader = void 0;
+// LOADERS
+var tiles_3d_loader_1 = require("./tiles-3d-loader");
+Object.defineProperty(exports, "Tiles3DLoader", { enumerable: true, get: function () { return tiles_3d_loader_1.Tiles3DLoader; } });
+var cesium_ion_loader_1 = require("./cesium-ion-loader");
+Object.defineProperty(exports, "CesiumIonLoader", { enumerable: true, get: function () { return cesium_ion_loader_1.CesiumIonLoader; } });
+var tile_3d_subtree_loader_1 = require("./tile-3d-subtree-loader");
+Object.defineProperty(exports, "Tile3DSubtreeLoader", { enumerable: true, get: function () { return tile_3d_subtree_loader_1.Tile3DSubtreeLoader; } });
+// WRITERS
+var tile_3d_writer_1 = require("./tile-3d-writer");
+Object.defineProperty(exports, "Tile3DWriter", { enumerable: true, get: function () { return tile_3d_writer_1.Tile3DWriter; } });
+// CLASSES
+var tile_3d_feature_table_1 = require("./lib/classes/tile-3d-feature-table");
+Object.defineProperty(exports, "Tile3DFeatureTable", { enumerable: true, get: function () { return __importDefault(tile_3d_feature_table_1).default; } });
+var tile_3d_batch_table_1 = require("./lib/classes/tile-3d-batch-table");
+Object.defineProperty(exports, "Tile3DBatchTable", { enumerable: true, get: function () { return __importDefault(tile_3d_batch_table_1).default; } });
+// EXPERIMENTAL
+var constants_1 = require("./lib/constants");
+Object.defineProperty(exports, "TILE3D_TYPE", { enumerable: true, get: function () { return constants_1.TILE3D_TYPE; } });
+var ion_1 = require("./lib/ion/ion");
+Object.defineProperty(exports, "_getIonTilesetMetadata", { enumerable: true, get: function () { return ion_1.getIonTilesetMetadata; } });

package/dist/lib/classes/helpers/tile-3d-accessor-utils.d.ts

@@ -1,7 +1,8 @@
-export function createTypedArrayFromAccessor(tile3DAccessor: any, buffer: any, byteOffset: any, length: any): {
-    values: import("modules/math/dist/geometry/types").TypedArray;
+export declare function createTypedArrayFromAccessor(tile3DAccessor: any, buffer: any, byteOffset: any, length: any): {
+    values: import("modules/math/src/geometry/types").TypedArray;
     type: any;
     size: any;
     unpacker: any;
     packer: any;
 };
+//# sourceMappingURL=tile-3d-accessor-utils.d.ts.map

package/dist/lib/classes/helpers/tile-3d-accessor-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-3d-accessor-utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/classes/helpers/tile-3d-accessor-utils.ts"],"names":[],"mappings":"AAgGA,wBAAgB,4BAA4B,CAAC,cAAc,KAAA,EAAE,MAAM,KAAA,EAAE,UAAU,KAAA,EAAE,MAAM,KAAA;;;;;;EAkBtF"}

package/dist/lib/classes/helpers/tile-3d-accessor-utils.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypedArrayFromAccessor = void 0;
+const math_1 = require("@loaders.gl/math"); // '@math.gl/geometry';
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const COMPONENTS_PER_ATTRIBUTE = {
+    SCALAR: 1,
+    VEC2: 2,
+    VEC3: 3,
+    VEC4: 4,
+    MAT2: 4,
+    MAT3: 9,
+    MAT4: 16
+};
+// TODO - could just return typed array views...
+// prettier-ignore
+const UNPACKER = {
+    SCALAR: (values, i) => values[i],
+    VEC2: (values, i) => [values[2 * i + 0], values[2 * i + 1]],
+    VEC3: (values, i) => [values[3 * i + 0], values[3 * i + 1], values[3 * i + 2]],
+    VEC4: (values, i) => [values[4 * i + 0], values[4 * i + 1], values[4 * i + 2], values[4 * i + 3]],
+    // TODO: check column major
+    MAT2: (values, i) => [
+        values[4 * i + 0], values[4 * i + 1],
+        values[4 * i + 2], values[4 * i + 3]
+    ],
+    MAT3: (values, i) => [
+        values[9 * i + 0], values[9 * i + 1], values[9 * i + 2],
+        values[9 * i + 3], values[9 * i + 4], values[9 * i + 5],
+        values[9 * i + 6], values[9 * i + 7], values[9 * i + 8]
+    ],
+    MAT4: (values, i) => [
+        values[16 * i + 0], values[16 * i + 1], values[16 * i + 2], values[16 * i + 3],
+        values[16 * i + 4], values[16 * i + 5], values[16 * i + 6], values[16 * i + 7],
+        values[16 * i + 8], values[16 * i + 9], values[16 * i + 10], values[16 * i + 11],
+        values[16 * i + 12], values[16 * i + 13], values[16 * i + 14], values[16 * i + 15]
+    ]
+};
+const PACKER = {
+    SCALAR: (x, values, i) => {
+        values[i] = x;
+    },
+    VEC2: (x, values, i) => {
+        values[2 * i + 0] = x[0];
+        values[2 * i + 1] = x[1];
+    },
+    VEC3: (x, values, i) => {
+        values[3 * i + 0] = x[0];
+        values[3 * i + 1] = x[1];
+        values[3 * i + 2] = x[2];
+    },
+    VEC4: (x, values, i) => {
+        values[4 * i + 0] = x[0];
+        values[4 * i + 1] = x[1];
+        values[4 * i + 2] = x[2];
+        values[4 * i + 3] = x[3];
+    },
+    // TODO: check column major correctness
+    MAT2: (x, values, i) => {
+        values[4 * i + 0] = x[0];
+        values[4 * i + 1] = x[1];
+        values[4 * i + 2] = x[2];
+        values[4 * i + 3] = x[3];
+    },
+    MAT3: (x, values, i) => {
+        values[9 * i + 0] = x[0];
+        values[9 * i + 1] = x[1];
+        values[9 * i + 2] = x[2];
+        values[9 * i + 3] = x[3];
+        values[9 * i + 4] = x[4];
+        values[9 * i + 5] = x[5];
+        values[9 * i + 6] = x[6];
+        values[9 * i + 7] = x[7];
+        values[9 * i + 8] = x[8];
+        values[9 * i + 9] = x[9];
+    },
+    MAT4: (x, values, i) => {
+        values[16 * i + 0] = x[0];
+        values[16 * i + 1] = x[1];
+        values[16 * i + 2] = x[2];
+        values[16 * i + 3] = x[3];
+        values[16 * i + 4] = x[4];
+        values[16 * i + 5] = x[5];
+        values[16 * i + 6] = x[6];
+        values[16 * i + 7] = x[7];
+        values[16 * i + 8] = x[8];
+        values[16 * i + 9] = x[9];
+        values[16 * i + 10] = x[10];
+        values[16 * i + 11] = x[11];
+        values[16 * i + 12] = x[12];
+        values[16 * i + 13] = x[13];
+        values[16 * i + 14] = x[14];
+        values[16 * i + 15] = x[15];
+    }
+};
+function createTypedArrayFromAccessor(tile3DAccessor, buffer, byteOffset, length) {
+    const { componentType } = tile3DAccessor;
+    (0, loader_utils_1.assert)(tile3DAccessor.componentType);
+    const type = typeof componentType === 'string' ? math_1.GLType.fromName(componentType) : componentType;
+    const size = COMPONENTS_PER_ATTRIBUTE[tile3DAccessor.type];
+    const unpacker = UNPACKER[tile3DAccessor.type];
+    const packer = PACKER[tile3DAccessor.type];
+    byteOffset += tile3DAccessor.byteOffset;
+    const values = math_1.GLType.createTypedArray(type, buffer, byteOffset, size * length);
+    return {
+        values,
+        type,
+        size,
+        unpacker,
+        packer
+    };
+}
+exports.createTypedArrayFromAccessor = createTypedArrayFromAccessor;

package/dist/lib/classes/tile-3d-batch-table-hierarchy.d.ts

@@ -1,9 +1,10 @@
-export function initializeHierarchy(batchTable: any, jsonHeader: any, binaryBody: any): {
+export declare function initializeHierarchy(batchTable: any, jsonHeader: any, binaryBody: any): {
     classes: any;
     classIds: any;
     classIndexes: Uint16Array;
     parentCounts: any;
-    parentIndexes: Uint16Array | undefined;
+    parentIndexes: any;
     parentIds: any;
 } | null;
-export function traverseHierarchy(hierarchy: any, instanceIndex: any, endConditionCallback: any): any;
+export declare function traverseHierarchy(hierarchy: any, instanceIndex: any, endConditionCallback: any): any;
+//# sourceMappingURL=tile-3d-batch-table-hierarchy.d.ts.map

package/dist/lib/classes/tile-3d-batch-table-hierarchy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-3d-batch-table-hierarchy.d.ts","sourceRoot":"","sources":["../../../src/lib/classes/tile-3d-batch-table-hierarchy.ts"],"names":[],"mappings":"AAQA,wBAAgB,mBAAmB,CAAC,UAAU,KAAA,EAAE,UAAU,KAAA,EAAE,UAAU,KAAA;;;;;;;SAqBrE;AA2FD,wBAAgB,iBAAiB,CAAC,SAAS,KAAA,EAAE,aAAa,KAAA,EAAE,oBAAoB,KAAA,OAc/E"}

package/dist/lib/classes/tile-3d-batch-table-hierarchy.js

@@ -0,0 +1,197 @@
+"use strict";
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseHierarchy = exports.initializeHierarchy = void 0;
+// TODO - Finish hierarchy suypport: this file is only half ported
+/* eslint-disable */
+// @ts-nocheck
+const defined = (x) => x !== undefined;
+function initializeHierarchy(batchTable, jsonHeader, binaryBody) {
+    if (!jsonHeader) {
+        return null;
+    }
+    let hierarchy = batchTable.getExtension('3DTILES_batch_table_hierarchy');
+    const legacyHierarchy = jsonHeader.HIERARCHY;
+    if (legacyHierarchy) {
+        // eslint-disable-next-line
+        console.warn('3D Tile Parser: HIERARCHY is deprecated. Use 3DTILES_batch_table_hierarchy.');
+        jsonHeader.extensions = jsonHeader.extensions || {};
+        jsonHeader.extensions['3DTILES_batch_table_hierarchy'] = legacyHierarchy;
+        hierarchy = legacyHierarchy;
+    }
+    if (!hierarchy) {
+        return null;
+    }
+    return initializeHierarchyValues(hierarchy, binaryBody);
+}
+exports.initializeHierarchy = initializeHierarchy;
+// eslint-disable-next-line max-statements
+function initializeHierarchyValues(hierarchyJson, binaryBody) {
+    let i;
+    let classId;
+    let binaryAccessor;
+    const instancesLength = hierarchyJson.instancesLength;
+    const classes = hierarchyJson.classes;
+    let classIds = hierarchyJson.classIds;
+    let parentCounts = hierarchyJson.parentCounts;
+    let parentIds = hierarchyJson.parentIds;
+    let parentIdsLength = instancesLength;
+    if (defined(classIds.byteOffset)) {
+        classIds.componentType = defaultValue(classIds.componentType, GL.UNSIGNED_SHORT);
+        classIds.type = AttributeType.SCALAR;
+        binaryAccessor = getBinaryAccessor(classIds);
+        classIds = binaryAccessor.createArrayBufferView(binaryBody.buffer, binaryBody.byteOffset + classIds.byteOffset, instancesLength);
+    }
+    let parentIndexes;
+    if (defined(parentCounts)) {
+        if (defined(parentCounts.byteOffset)) {
+            parentCounts.componentType = defaultValue(parentCounts.componentType, GL.UNSIGNED_SHORT);
+            parentCounts.type = AttributeType.SCALAR;
+            binaryAccessor = getBinaryAccessor(parentCounts);
+            parentCounts = binaryAccessor.createArrayBufferView(binaryBody.buffer, binaryBody.byteOffset + parentCounts.byteOffset, instancesLength);
+        }
+        parentIndexes = new Uint16Array(instancesLength);
+        parentIdsLength = 0;
+        for (i = 0; i < instancesLength; ++i) {
+            parentIndexes[i] = parentIdsLength;
+            parentIdsLength += parentCounts[i];
+        }
+    }
+    if (defined(parentIds) && defined(parentIds.byteOffset)) {
+        parentIds.componentType = defaultValue(parentIds.componentType, GL.UNSIGNED_SHORT);
+        parentIds.type = AttributeType.SCALAR;
+        binaryAccessor = getBinaryAccessor(parentIds);
+        parentIds = binaryAccessor.createArrayBufferView(binaryBody.buffer, binaryBody.byteOffset + parentIds.byteOffset, parentIdsLength);
+    }
+    const classesLength = classes.length;
+    for (i = 0; i < classesLength; ++i) {
+        const classInstancesLength = classes[i].length;
+        const properties = classes[i].instances;
+        const binaryProperties = getBinaryProperties(classInstancesLength, properties, binaryBody);
+        classes[i].instances = combine(binaryProperties, properties);
+    }
+    const classCounts = new Array(classesLength).fill(0);
+    const classIndexes = new Uint16Array(instancesLength);
+    for (i = 0; i < instancesLength; ++i) {
+        classId = classIds[i];
+        classIndexes[i] = classCounts[classId];
+        ++classCounts[classId];
+    }
+    const hierarchy = {
+        classes,
+        classIds,
+        classIndexes,
+        parentCounts,
+        parentIndexes,
+        parentIds
+    };
+    validateHierarchy(hierarchy);
+    return hierarchy;
+}
+// HELPER CODE
+// Traverse over the hierarchy and process each instance with the endConditionCallback.
+// When the endConditionCallback returns a value, the traversal stops and that value is returned.
+function traverseHierarchy(hierarchy, instanceIndex, endConditionCallback) {
+    if (!hierarchy) {
+        return;
+    }
+    const parentCounts = hierarchy.parentCounts;
+    const parentIds = hierarchy.parentIds;
+    if (parentIds) {
+        return endConditionCallback(hierarchy, instanceIndex);
+    }
+    if (parentCounts > 0) {
+        return traverseHierarchyMultipleParents(hierarchy, instanceIndex, endConditionCallback);
+    }
+    return traverseHierarchySingleParent(hierarchy, instanceIndex, endConditionCallback);
+}
+exports.traverseHierarchy = traverseHierarchy;
+// eslint-disable-next-line max-statements
+function traverseHierarchyMultipleParents(hierarchy, instanceIndex, endConditionCallback) {
+    const classIds = hierarchy.classIds;
+    const parentCounts = hierarchy.parentCounts;
+    const parentIds = hierarchy.parentIds;
+    const parentIndexes = hierarchy.parentIndexes;
+    const instancesLength = classIds.length;
+    // Ignore instances that have already been visited. This occurs in diamond inheritance situations.
+    // Use a marker value to indicate that an instance has been visited, which increments with each run.
+    // This is more efficient than clearing the visited array every time.
+    const visited = scratchVisited;
+    visited.length = Math.max(visited.length, instancesLength);
+    const visitedMarker = ++marker;
+    const stack = scratchStack;
+    stack.length = 0;
+    stack.push(instanceIndex);
+    while (stack.length > 0) {
+        instanceIndex = stack.pop();
+        if (visited[instanceIndex] === visitedMarker) {
+            // This instance has already been visited, stop traversal
+            continue;
+        }
+        visited[instanceIndex] = visitedMarker;
+        const result = endConditionCallback(hierarchy, instanceIndex);
+        if (defined(result)) {
+            // The end condition was met, stop the traversal and return the result
+            return result;
+        }
+        const parentCount = parentCounts[instanceIndex];
+        const parentIndex = parentIndexes[instanceIndex];
+        for (let i = 0; i < parentCount; ++i) {
+            const parentId = parentIds[parentIndex + i];
+            // Stop the traversal when the instance has no parent (its parentId equals itself)
+            // else add the parent to the stack to continue the traversal.
+            if (parentId !== instanceIndex) {
+                stack.push(parentId);
+            }
+        }
+    }
+    return null;
+}
+function traverseHierarchySingleParent(hierarchy, instanceIndex, endConditionCallback) {
+    let hasParent = true;
+    while (hasParent) {
+        const result = endConditionCallback(hierarchy, instanceIndex);
+        if (defined(result)) {
+            // The end condition was met, stop the traversal and return the result
+            return result;
+        }
+        const parentId = hierarchy.parentIds[instanceIndex];
+        hasParent = parentId !== instanceIndex;
+        instanceIndex = parentId;
+    }
+    throw new Error('traverseHierarchySingleParent');
+}
+// DEBUG CODE
+function validateHierarchy(hierarchy) {
+    const scratchValidateStack = [];
+    const classIds = hierarchy.classIds;
+    const instancesLength = classIds.length;
+    for (let i = 0; i < instancesLength; ++i) {
+        validateInstance(hierarchy, i, stack);
+    }
+}
+function validateInstance(hierarchy, instanceIndex, stack) {
+    const parentCounts = hierarchy.parentCounts;
+    const parentIds = hierarchy.parentIds;
+    const parentIndexes = hierarchy.parentIndexes;
+    const classIds = hierarchy.classIds;
+    const instancesLength = classIds.length;
+    if (!defined(parentIds)) {
+        // No need to validate if there are no parents
+        return;
+    }
+    assert(instanceIndex < instancesLength, `Parent index ${instanceIndex} exceeds the total number of instances: ${instancesLength}`);
+    assert(stack.indexOf(instanceIndex) === -1, 'Circular dependency detected in the batch table hierarchy.');
+    stack.push(instanceIndex);
+    const parentCount = defined(parentCounts) ? parentCounts[instanceIndex] : 1;
+    const parentIndex = defined(parentCounts) ? parentIndexes[instanceIndex] : instanceIndex;
+    for (let i = 0; i < parentCount; ++i) {
+        const parentId = parentIds[parentIndex + i];
+        // Stop the traversal when the instance has no parent (its parentId equals itself), else continue the traversal.
+        if (parentId !== instanceIndex) {
+            validateInstance(hierarchy, parentId, stack);
+        }
+    }
+    stack.pop(instanceIndex);
+}

package/dist/lib/classes/tile-3d-batch-table.d.ts

@@ -1,22 +1,15 @@
 export default class Tile3DBatchTableParser {
-    constructor(json: any, binary: any, featureCount: any, options?: {});
     json: any;
     binary: any;
     featureCount: any;
     _extensions: any;
-    _properties: {};
-    _binaryProperties: {} | null;
-    _hierarchy: {
-        classes: any;
-        classIds: any;
-        classIndexes: Uint16Array;
-        parentCounts: any;
-        parentIndexes: Uint16Array | undefined;
-        parentIds: any;
-    } | null | undefined;
+    _properties: any;
+    _binaryProperties: any;
+    _hierarchy: any;
+    constructor(json: any, binary: any, featureCount: any, options?: {});
     getExtension(extensionName: any): any;
     memorySizeInBytes(): number;
-    isClass(batchId: any, className: any): boolean;
+    isClass(batchId: any, className: string): boolean;
     isExactClass(batchId: any, className: any): boolean;
     getExactClassName(batchId: any): any;
     hasProperty(batchId: any, name: any): boolean;
@@ -26,9 +19,9 @@ export default class Tile3DBatchTableParser {
     _checkBatchId(batchId: any): void;
     _getBinaryProperty(binaryProperty: any, index: any): any;
     _setBinaryProperty(binaryProperty: any, index: any, value: any): void;
-    _initializeBinaryProperties(): {} | null;
+    _initializeBinaryProperties(): Record<string, any> | null;
     _initializeBinaryProperty(name: any, property: any): {
-        typedArray: import("modules/math/dist/geometry/types").TypedArray;
+        typedArray: import("modules/math/src/geometry/types").TypedArray;
         componentCount: any;
         unpack: any;
         pack: any;
@@ -38,3 +31,4 @@ export default class Tile3DBatchTableParser {
     _getHierarchyProperty(batchId: any, name: any): any;
     _setHierarchyProperty(batchTable: any, batchId: any, name: any, value: any): boolean;
 }
+//# sourceMappingURL=tile-3d-batch-table.d.ts.map

package/dist/lib/classes/tile-3d-batch-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-3d-batch-table.d.ts","sourceRoot":"","sources":["../../../src/lib/classes/tile-3d-batch-table.ts"],"names":[],"mappings":"AAsBA,MAAM,CAAC,OAAO,OAAO,sBAAsB;IACzC,IAAI,MAAC;IACL,MAAM,MAAC;IACP,YAAY,MAAC;IACb,WAAW,MAAC;IAEZ,WAAW,MAAC;IACZ,iBAAiB,MAAC;IAElB,UAAU,MAAC;gBAEC,IAAI,KAAA,EAAE,MAAM,KAAA,EAAE,YAAY,KAAA,EAAE,OAAO,KAAK;IAwBpD,YAAY,CAAC,aAAa,KAAA;IAI1B,iBAAiB,IAAI,MAAM;IAI3B,OAAO,CAAC,OAAO,KAAA,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAoB5C,YAAY,CAAC,OAAO,KAAA,EAAE,SAAS,KAAA;IAM/B,iBAAiB,CAAC,OAAO,KAAA;IAazB,WAAW,CAAC,OAAO,KAAA,EAAE,IAAI,KAAA;IAOzB,gBAAgB,CAAC,OAAO,KAAA,EAAE,OAAO,KAAA;IAgBjC,WAAW,CAAC,OAAO,KAAA,EAAE,IAAI,KAAA;IA2BzB,WAAW,CAAC,OAAO,KAAA,EAAE,IAAI,KAAA,EAAE,KAAK,KAAA;IAiChC,aAAa,CAAC,OAAO,KAAA;IAOrB,kBAAkB,CAAC,cAAc,KAAA,EAAE,KAAK,KAAA;IAIxC,kBAAkB,CAAC,cAAc,KAAA,EAAE,KAAK,KAAA,EAAE,KAAK,KAAA;IAI/C,2BAA2B;IAe3B,yBAAyB,CAAC,IAAI,KAAA,EAAE,QAAQ,KAAA;;;;;;IA8BxC,uBAAuB,CAAC,OAAO,KAAA,EAAE,IAAI,KAAA;IAcrC,4BAA4B,CAAC,OAAO,KAAA,EAAE,OAAO,KAAA;IAc7C,qBAAqB,CAAC,OAAO,KAAA,EAAE,IAAI,KAAA;IAgBnC,qBAAqB,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA,EAAE,IAAI,KAAA,EAAE,KAAK,KAAA;CAmBvD"}