@deck.gl/geo-layers 8.8.0-alpha.4 → 8.8.0-beta.1

package/typed/tile-3d-layer/tile-3d-layer.d.ts

@@ -0,0 +1,70 @@
+declare class Tile3DLayer extends CompositeLayer<any> {
+    constructor(...propObjects: Partial<any>[]);
+    _loadTileset(tilesetUrl: any): Promise<void>;
+    _onTileLoad(tileHeader: any): void;
+    _onTileUnload(tileHeader: any): void;
+    _updateTileset(viewports: any): void;
+    _getSubLayer(tileHeader: any, oldLayer: any): PointCloudLayer<any, {}> | ScenegraphLayer<any, {}> | _MeshLayer | null;
+    _makePointCloudLayer(tileHeader: any, oldLayer: any): PointCloudLayer<any, {}> | null;
+    _make3DModelLayer(tileHeader: any): ScenegraphLayer<any, {}>;
+    _makeSimpleMeshLayer(tileHeader: any, oldLayer: any): _MeshLayer;
+}
+declare namespace Tile3DLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+export default Tile3DLayer;
+import { CompositeLayer } from '@deck.gl/core/typed';
+import { PointCloudLayer } from '@deck.gl/layers/typed';
+import { ScenegraphLayer } from '@deck.gl/mesh-layers/typed';
+import { default as _MeshLayer } from "../mesh-layer/mesh-layer";
+declare namespace defaultProps {
+    export namespace getPointColor {
+        const type: string;
+        const value: number[];
+    }
+    export const pointSize: number;
+    export const data: null;
+    export { Tiles3DLoader as loader };
+    export namespace onTilesetLoad {
+        const type_1: string;
+        export { type_1 as type };
+        export function value_1(tileset3d: any): void;
+        export { value_1 as value };
+        export const compare: boolean;
+    }
+    export namespace onTileLoad {
+        const type_2: string;
+        export { type_2 as type };
+        export function value_2(tileHeader: any): void;
+        export { value_2 as value };
+        const compare_1: boolean;
+        export { compare_1 as compare };
+    }
+    export namespace onTileUnload {
+        const type_3: string;
+        export { type_3 as type };
+        export function value_3(tileHeader: any): void;
+        export { value_3 as value };
+        const compare_2: boolean;
+        export { compare_2 as compare };
+    }
+    export namespace onTileError {
+        const type_4: string;
+        export { type_4 as type };
+        export function value_4(tile: any, message: any, url: any): void;
+        export { value_4 as value };
+        const compare_3: boolean;
+        export { compare_3 as compare };
+    }
+    export namespace _getMeshColor {
+        const type_5: string;
+        export { type_5 as type };
+        export function value_5(tileHeader: any): number[];
+        export { value_5 as value };
+        const compare_4: boolean;
+        export { compare_4 as compare };
+    }
+}
+import { Tiles3DLoader } from "@loaders.gl/3d-tiles";
+//# sourceMappingURL=tile-3d-layer.d.ts.map

package/typed/tile-3d-layer/tile-3d-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-3d-layer.d.ts","sourceRoot":"","sources":["../../src/tile-3d-layer/tile-3d-layer.js"],"names":[],"mappings":"AA4BA;IAboC,4CAG5B;IA4FN,6CAqCC;IAED,mCAKC;IAED,qCAIC;IAED,qCAaC;IAED,sHAeC;IAED,sFAuCC;IAED,6DA0BC;IAED,iEAyCC;CA4BF;;;;;;;;;;;;;;;;;;;;;QAvT0C,8CAAe;;;;;;;QAClB,+CAAgB;;;;;;;;QACd,+CAAgB;;;;;;;;QACjB,iEAA0B;;;;;;;;QACxB,mDAA6B"}

package/typed/tile-3d-layer/tile-3d-layer.js

@@ -0,0 +1,294 @@
+import GL from '@luma.gl/constants';
+import { Geometry } from '@luma.gl/core';
+import { COORDINATE_SYSTEM, CompositeLayer } from '@deck.gl/core';
+import { PointCloudLayer } from '@deck.gl/layers';
+import { ScenegraphLayer } from '@deck.gl/mesh-layers';
+import { default as _MeshLayer } from '../mesh-layer/mesh-layer';
+import { log } from '@deck.gl/core';
+import { load } from '@loaders.gl/core';
+import { Tileset3D, TILE_TYPE } from '@loaders.gl/tiles';
+import { Tiles3DLoader } from '@loaders.gl/3d-tiles';
+const SINGLE_DATA = [0];
+const defaultProps = {
+    getPointColor: { type: 'accessor', value: [0, 0, 0, 255] },
+    pointSize: 1.0,
+    data: null,
+    loader: Tiles3DLoader,
+    onTilesetLoad: { type: 'function', value: tileset3d => { }, compare: false },
+    onTileLoad: { type: 'function', value: tileHeader => { }, compare: false },
+    onTileUnload: { type: 'function', value: tileHeader => { }, compare: false },
+    onTileError: { type: 'function', value: (tile, message, url) => { }, compare: false },
+    _getMeshColor: { type: 'function', value: tileHeader => [255, 255, 255], compare: false }
+};
+export default class Tile3DLayer extends CompositeLayer {
+    initializeState() {
+        if ('onTileLoadFail' in this.props) {
+            log.removed('onTileLoadFail', 'onTileError')();
+        }
+        // prop verification
+        this.state = {
+            layerMap: {},
+            tileset3d: null,
+            activeViewports: {},
+            lastUpdatedViewports: null
+        };
+    }
+    get isLoaded() {
+        const { tileset3d } = this.state;
+        return tileset3d && tileset3d.isLoaded();
+    }
+    shouldUpdateState({ changeFlags }) {
+        return changeFlags.somethingChanged;
+    }
+    updateState({ props, oldProps, changeFlags }) {
+        if (props.data && props.data !== oldProps.data) {
+            this._loadTileset(props.data);
+        }
+        if (changeFlags.viewportChanged) {
+            const { activeViewports } = this.state;
+            const viewportsNumber = Object.keys(activeViewports).length;
+            if (viewportsNumber) {
+                this._updateTileset(activeViewports);
+                this.state.lastUpdatedViewports = activeViewports;
+                this.state.activeViewports = {};
+            }
+        }
+        if (changeFlags.propsChanged) {
+            const { layerMap } = this.state;
+            for (const key in layerMap) {
+                layerMap[key].needsUpdate = true;
+            }
+        }
+    }
+    activateViewport(viewport) {
+        const { activeViewports, lastUpdatedViewports } = this.state;
+        this.internalState.viewport = viewport;
+        activeViewports[viewport.id] = viewport;
+        const lastViewport = lastUpdatedViewports?.[viewport.id];
+        if (!lastViewport || !viewport.equals(lastViewport)) {
+            this.setChangeFlags({ viewportChanged: true });
+            this.setNeedsUpdate();
+        }
+    }
+    getPickingInfo({ info, sourceLayer }) {
+        const { layerMap } = this.state;
+        const layerId = sourceLayer && sourceLayer.id;
+        if (layerId) {
+            // layerId: this.id-[scenegraph|pointcloud]-tileId
+            const substr = layerId.substring(this.id.length + 1);
+            const tileId = substr.substring(substr.indexOf('-') + 1);
+            info.object = layerMap[tileId] && layerMap[tileId].tile;
+        }
+        return info;
+    }
+    filterSubLayer({ layer, viewport }) {
+        const { tile } = layer.props;
+        const { id: viewportId } = viewport;
+        return tile.selected && tile.viewportIds.includes(viewportId);
+    }
+    _updateAutoHighlight(info) {
+        if (info.sourceLayer) {
+            info.sourceLayer.updateAutoHighlight(info);
+        }
+    }
+    async _loadTileset(tilesetUrl) {
+        const { loadOptions = {} } = this.props;
+        // TODO: deprecate `loader` in v9.0
+        let loader = this.props.loader || this.props.loaders;
+        if (Array.isArray(loader)) {
+            loader = loader[0];
+        }
+        const options = { loadOptions: { ...loadOptions } };
+        if (loader.preload) {
+            const preloadOptions = await loader.preload(tilesetUrl, loadOptions);
+            if (preloadOptions.headers) {
+                options.loadOptions.fetch = {
+                    ...options.loadOptions.fetch,
+                    headers: preloadOptions.headers
+                };
+            }
+            Object.assign(options, preloadOptions);
+        }
+        const tilesetJson = await load(tilesetUrl, loader, options.loadOptions);
+        const tileset3d = new Tileset3D(tilesetJson, {
+            onTileLoad: this._onTileLoad.bind(this),
+            onTileUnload: this._onTileUnload.bind(this),
+            onTileLoadFail: this.props.onTileError,
+            ...options
+        });
+        this.setState({
+            tileset3d,
+            layerMap: {}
+        });
+        this._updateTileset(this.state.activeViewports);
+        this.props.onTilesetLoad(tileset3d);
+    }
+    _onTileLoad(tileHeader) {
+        const { lastUpdatedViewports } = this.state;
+        this.props.onTileLoad(tileHeader);
+        this._updateTileset(lastUpdatedViewports);
+        this.setNeedsUpdate();
+    }
+    _onTileUnload(tileHeader) {
+        // Was cleaned up from tileset cache. We no longer need to track it.
+        delete this.state.layerMap[tileHeader.id];
+        this.props.onTileUnload(tileHeader);
+    }
+    _updateTileset(viewports) {
+        const { tileset3d } = this.state;
+        const { timeline } = this.context;
+        const viewportsNumber = Object.keys(viewports).length;
+        if (!timeline || !viewportsNumber || !tileset3d) {
+            return;
+        }
+        tileset3d.selectTiles(Object.values(viewports)).then(frameNumber => {
+            const tilesetChanged = this.state.frameNumber !== frameNumber;
+            if (tilesetChanged) {
+                this.setState({ frameNumber });
+            }
+        });
+    }
+    _getSubLayer(tileHeader, oldLayer) {
+        if (!tileHeader.content) {
+            return null;
+        }
+        switch (tileHeader.type) {
+            case TILE_TYPE.POINTCLOUD:
+                return this._makePointCloudLayer(tileHeader, oldLayer);
+            case TILE_TYPE.SCENEGRAPH:
+                return this._make3DModelLayer(tileHeader, oldLayer);
+            case TILE_TYPE.MESH:
+                return this._makeSimpleMeshLayer(tileHeader, oldLayer);
+            default:
+                throw new Error(`Tile3DLayer: Failed to render layer of type ${tileHeader.content.type}`);
+        }
+    }
+    _makePointCloudLayer(tileHeader, oldLayer) {
+        const { attributes, pointCount, constantRGBA, cartographicOrigin, modelMatrix } = tileHeader.content;
+        const { positions, normals, colors } = attributes;
+        if (!positions) {
+            return null;
+        }
+        const data = (oldLayer && oldLayer.props.data) || {
+            header: {
+                vertexCount: pointCount
+            },
+            attributes: {
+                POSITION: positions,
+                NORMAL: normals,
+                COLOR_0: colors
+            }
+        };
+        const { pointSize, getPointColor } = this.props;
+        const SubLayerClass = this.getSubLayerClass('pointcloud', PointCloudLayer);
+        return new SubLayerClass({
+            pointSize
+        }, this.getSubLayerProps({
+            id: 'pointcloud'
+        }), {
+            id: `${this.id}-pointcloud-${tileHeader.id}`,
+            tile: tileHeader,
+            data,
+            coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS,
+            coordinateOrigin: cartographicOrigin,
+            modelMatrix,
+            getColor: constantRGBA || getPointColor,
+            _offset: 0
+        });
+    }
+    _make3DModelLayer(tileHeader) {
+        const { gltf, instances, cartographicOrigin, modelMatrix } = tileHeader.content;
+        const SubLayerClass = this.getSubLayerClass('scenegraph', ScenegraphLayer);
+        return new SubLayerClass({
+            _lighting: 'pbr'
+        }, this.getSubLayerProps({
+            id: 'scenegraph'
+        }), {
+            id: `${this.id}-scenegraph-${tileHeader.id}`,
+            tile: tileHeader,
+            data: instances || SINGLE_DATA,
+            scenegraph: gltf,
+            coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS,
+            coordinateOrigin: cartographicOrigin,
+            modelMatrix,
+            getTransformMatrix: instance => instance.modelMatrix,
+            getPosition: [0, 0, 0],
+            _offset: 0
+        });
+    }
+    _makeSimpleMeshLayer(tileHeader, oldLayer) {
+        const content = tileHeader.content;
+        const { attributes, indices, modelMatrix, cartographicOrigin, coordinateSystem = COORDINATE_SYSTEM.METER_OFFSETS, material, featureIds } = content;
+        const { _getMeshColor } = this.props;
+        const geometry = (oldLayer && oldLayer.props.mesh) ||
+            new Geometry({
+                drawMode: GL.TRIANGLES,
+                attributes: getMeshGeometry(attributes),
+                indices
+            });
+        const SubLayerClass = this.getSubLayerClass('mesh', _MeshLayer);
+        return new SubLayerClass(this.getSubLayerProps({
+            id: 'mesh'
+        }), {
+            id: `${this.id}-mesh-${tileHeader.id}`,
+            tile: tileHeader,
+            mesh: geometry,
+            data: SINGLE_DATA,
+            getColor: _getMeshColor(tileHeader),
+            pbrMaterial: material,
+            modelMatrix,
+            coordinateOrigin: cartographicOrigin,
+            coordinateSystem,
+            featureIds,
+            _offset: 0
+        });
+    }
+    renderLayers() {
+        const { tileset3d, layerMap } = this.state;
+        if (!tileset3d) {
+            return null;
+        }
+        return tileset3d.tiles
+            .map(tile => {
+            const layerCache = (layerMap[tile.id] = layerMap[tile.id] || { tile });
+            let { layer } = layerCache;
+            if (tile.selected) {
+                // render selected tiles
+                if (!layer) {
+                    // create layer
+                    layer = this._getSubLayer(tile);
+                }
+                else if (layerCache.needsUpdate) {
+                    // props have changed, rerender layer
+                    layer = this._getSubLayer(tile, layer);
+                    layerCache.needsUpdate = false;
+                }
+            }
+            layerCache.layer = layer;
+            return layer;
+        })
+            .filter(Boolean);
+    }
+}
+function getMeshGeometry(contentAttributes) {
+    const attributes = {};
+    attributes.positions = {
+        ...contentAttributes.positions,
+        value: new Float32Array(contentAttributes.positions.value)
+    };
+    if (contentAttributes.normals) {
+        attributes.normals = contentAttributes.normals;
+    }
+    if (contentAttributes.texCoords) {
+        attributes.texCoords = contentAttributes.texCoords;
+    }
+    if (contentAttributes.colors) {
+        attributes.colors = contentAttributes.colors;
+    }
+    if (contentAttributes.uvRegions) {
+        attributes.uvRegions = contentAttributes.uvRegions;
+    }
+    return attributes;
+}
+Tile3DLayer.layerName = 'Tile3DLayer';
+Tile3DLayer.defaultProps = defaultProps;

package/typed/tile-layer/tile-2d-header.d.ts

@@ -0,0 +1,40 @@
+import { Layer } from '@deck.gl/core/typed';
+import { RequestScheduler } from '@loaders.gl/loader-utils';
+import { TileBoundingBox, TileIndex, TileLoadProps } from './types';
+export declare type TileLoadDataProps<DataT = any> = {
+    requestScheduler: RequestScheduler;
+    getData: (props: TileLoadProps) => Promise<DataT>;
+    onLoad: (tile: Tile2DHeader<DataT>) => void;
+    onError: (error: any, tile: Tile2DHeader<DataT>) => void;
+};
+export default class Tile2DHeader<DataT = any> {
+    index: TileIndex;
+    isVisible: boolean;
+    isSelected: boolean;
+    parent: Tile2DHeader | null;
+    children: Tile2DHeader[] | null;
+    content: DataT | null;
+    state?: number;
+    layers?: Layer[] | null;
+    id: string;
+    bbox: TileBoundingBox;
+    zoom: number;
+    userData?: Record<string, any>;
+    private _abortController;
+    private _loader;
+    private _loaderId;
+    private _isLoaded;
+    private _isCancelled;
+    private _needsReload;
+    constructor(index: TileIndex);
+    get data(): Promise<DataT | null> | DataT | null;
+    get isLoaded(): boolean;
+    get isLoading(): boolean;
+    get needsReload(): boolean;
+    get byteLength(): number;
+    private _loadData;
+    loadData(opts: TileLoadDataProps): Promise<void>;
+    setNeedsReload(): void;
+    abort(): void;
+}
+//# sourceMappingURL=tile-2d-header.d.ts.map

package/typed/tile-layer/tile-2d-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-2d-header.d.ts","sourceRoot":"","sources":["../../src/tile-layer/tile-2d-header.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,KAAK,EAAM,MAAM,eAAe,CAAC;AACzC,OAAO,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAC,eAAe,EAAE,SAAS,EAAE,aAAa,EAAC,MAAM,SAAS,CAAC;AAElE,oBAAY,iBAAiB,CAAC,KAAK,GAAG,GAAG,IAAI;IAC3C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;IAClD,MAAM,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IAC5C,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,YAAY,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;CAC1D,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,YAAY,CAAC,KAAK,GAAG,GAAG;IAC3C,KAAK,EAAE,SAAS,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;IAChC,OAAO,EAAE,KAAK,GAAG,IAAI,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;IAExB,EAAE,EAAG,MAAM,CAAC;IACZ,IAAI,EAAG,eAAe,CAAC;IACvB,IAAI,EAAG,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE/B,OAAO,CAAC,gBAAgB,CAAyB;IACjD,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,YAAY,CAAU;IAC9B,OAAO,CAAC,YAAY,CAAU;gBAElB,KAAK,EAAE,SAAS;IAiB5B,IAAI,IAAI,IAAI,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,KAAK,GAAG,IAAI,CAE/C;IAED,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,IAAI,UAAU,IAAI,MAAM,CAMvB;YAGa,SAAS;IA8DvB,QAAQ,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAShD,cAAc,IAAI,IAAI;IAQtB,KAAK,IAAI,IAAI;CAQd"}

package/typed/tile-layer/tile-2d-header.js

@@ -0,0 +1,113 @@
+/* eslint-env browser */
+import { log } from '@deck.gl/core';
+export default class Tile2DHeader {
+    constructor(index) {
+        this.index = index;
+        this.isVisible = false;
+        this.isSelected = false;
+        this.parent = null;
+        this.children = [];
+        this.content = null;
+        this._loader = undefined;
+        this._abortController = null;
+        this._loaderId = 0;
+        this._isLoaded = false;
+        this._isCancelled = false;
+        this._needsReload = false;
+    }
+    get data() {
+        return this.isLoading && this._loader ? this._loader.then(() => this.data) : this.content;
+    }
+    get isLoaded() {
+        return this._isLoaded && !this._needsReload;
+    }
+    get isLoading() {
+        return Boolean(this._loader) && !this._isCancelled;
+    }
+    get needsReload() {
+        return this._needsReload || this._isCancelled;
+    }
+    get byteLength() {
+        const result = this.content ? this.content.byteLength : 0;
+        if (!Number.isFinite(result)) {
+            log.error('byteLength not defined in tile data')();
+        }
+        return result;
+    }
+    /* eslint-disable max-statements */
+    async _loadData({ getData, requestScheduler, onLoad, onError }) {
+        const { index, id, bbox, userData, zoom } = this;
+        const loaderId = this._loaderId;
+        this._abortController = new AbortController();
+        const { signal } = this._abortController;
+        // @ts-expect-error (2345) Argument of type '(tile: any) => 1 | -1' is not assignable ...
+        const requestToken = await requestScheduler.scheduleRequest(this, tile => {
+            return tile.isSelected ? 1 : -1;
+        });
+        if (!requestToken) {
+            this._isCancelled = true;
+            return;
+        }
+        // A tile can be cancelled while being scheduled
+        if (this._isCancelled) {
+            requestToken.done();
+            return;
+        }
+        let tileData = null;
+        let error;
+        try {
+            tileData = await getData({ index, id, bbox, userData, zoom, signal });
+        }
+        catch (err) {
+            error = err || true;
+        }
+        finally {
+            requestToken.done();
+        }
+        // If loadData has been called with a newer version, discard the result from this operation
+        if (loaderId !== this._loaderId) {
+            return;
+        }
+        // Clear the `isLoading` flag
+        this._loader = undefined;
+        // Rewrite tile content with the result of getTileData if successful, or `null` in case of
+        // error or cancellation
+        this.content = tileData;
+        // If cancelled, do not invoke the callbacks
+        // Consider it loaded if we tried to cancel but `getTileData` still returned data
+        if (this._isCancelled && !tileData) {
+            this._isLoaded = false;
+            return;
+        }
+        this._isLoaded = true;
+        this._isCancelled = false;
+        if (error) {
+            onError(error, this);
+        }
+        else {
+            onLoad(this);
+        }
+    }
+    loadData(opts) {
+        this._isLoaded = false;
+        this._isCancelled = false;
+        this._needsReload = false;
+        this._loaderId++;
+        this._loader = this._loadData(opts);
+        return this._loader;
+    }
+    setNeedsReload() {
+        if (this.isLoading) {
+            this.abort();
+            this._loader = undefined;
+        }
+        this._needsReload = true;
+    }
+    abort() {
+        if (this.isLoaded) {
+            return;
+        }
+        this._isCancelled = true;
+        this._abortController?.abort();
+    }
+}

package/typed/tile-layer/tile-2d-traversal.d.ts

@@ -0,0 +1,4 @@
+import { Viewport } from '@deck.gl/core/typed';
+import { Bounds, TileIndex, ZRange } from './types';
+export declare function getOSMTileIndices(viewport: Viewport, maxZ: number, zRange: ZRange | undefined, bounds?: Bounds): TileIndex[];
+//# sourceMappingURL=tile-2d-traversal.d.ts.map

package/typed/tile-layer/tile-2d-traversal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-2d-traversal.d.ts","sourceRoot":"","sources":["../../src/tile-layer/tile-2d-traversal.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,QAAQ,EAAsC,MAAM,eAAe,CAAC;AAQ5E,OAAO,EAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAC,MAAM,SAAS,CAAC;AA2KlD,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,MAAM,CAAC,EAAE,MAAM,GACd,SAAS,EAAE,CAiEb"}