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

package/typed/gpu-grid-layer/gpu-grid-cell-layer-vertex.glsl.js

@@ -0,0 +1,141 @@
+// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+// Inspired by screen-grid-layer vertex shader in deck.gl
+export default `\
+#version 300 es
+#define SHADER_NAME gpu-grid-cell-layer-vertex-shader
+#define RANGE_COUNT 6
+
+in vec3 positions;
+in vec3 normals;
+
+in vec4 colors;
+in vec4 elevations;
+in vec3 instancePickingColors;
+
+// Custom uniforms
+uniform vec2 offset;
+uniform bool extruded;
+uniform float cellSize;
+uniform float coverage;
+uniform float opacity;
+uniform float elevationScale;
+
+uniform ivec2 gridSize;
+uniform vec2 gridOrigin;
+uniform vec2 gridOriginLow;
+uniform vec2 gridOffset;
+uniform vec2 gridOffsetLow;
+uniform vec4 colorRange[RANGE_COUNT];
+uniform vec2 elevationRange;
+
+// Domain uniforms
+uniform vec2 colorDomain;
+uniform bool colorDomainValid;
+uniform vec2 elevationDomain;
+uniform bool elevationDomainValid;
+
+layout(std140) uniform;
+uniform ColorData
+{
+  vec4 maxMinCount;
+} colorData;
+uniform ElevationData
+{
+  vec4 maxMinCount;
+} elevationData;
+
+#define EPSILON 0.00001
+
+// Result
+out vec4 vColor;
+
+vec4 quantizeScale(vec2 domain, vec4 range[RANGE_COUNT], float value) {
+  vec4 outColor = vec4(0., 0., 0., 0.);
+  if (value >= (domain.x - EPSILON) && value <= (domain.y + EPSILON)) {
+    float domainRange = domain.y - domain.x;
+    if (domainRange <= 0.) {
+      outColor = colorRange[0];
+    } else {
+      float rangeCount = float(RANGE_COUNT);
+      float rangeStep = domainRange / rangeCount;
+      float idx = floor((value - domain.x) / rangeStep);
+      idx = clamp(idx, 0., rangeCount - 1.);
+      int intIdx = int(idx);
+      outColor = colorRange[intIdx];
+    }
+  }
+  return outColor;
+}
+
+float linearScale(vec2 domain, vec2 range, float value) {
+  if (value >= (domain.x - EPSILON) && value <= (domain.y + EPSILON)) {
+    return ((value - domain.x) / (domain.y - domain.x)) * (range.y - range.x) + range.x;
+  }
+  return -1.;
+}
+
+void main(void) {
+  vec2 clrDomain = colorDomainValid ? colorDomain : vec2(colorData.maxMinCount.a, colorData.maxMinCount.r);
+  vec4 color = quantizeScale(clrDomain, colorRange, colors.r);
+
+  float elevation = 0.0;
+
+  if (extruded) {
+    vec2 elvDomain = elevationDomainValid ? elevationDomain : vec2(elevationData.maxMinCount.a, elevationData.maxMinCount.r);
+    elevation = linearScale(elvDomain, elevationRange, elevations.r);
+    elevation = elevation  * (positions.z + 1.0) / 2.0 * elevationScale;
+  }
+
+  // if aggregated color or elevation is 0 do not render
+  float shouldRender = float(color.r > 0.0 && elevations.r >= 0.0);
+  float dotRadius = cellSize / 2. * coverage * shouldRender;
+
+  int yIndex = (gl_InstanceID / gridSize[0]);
+  int xIndex = gl_InstanceID - (yIndex * gridSize[0]);
+
+  vec2 instancePositionXFP64 = mul_fp64(vec2(gridOffset[0], gridOffsetLow[0]), vec2(float(xIndex), 0.));
+  instancePositionXFP64 = sum_fp64(instancePositionXFP64, vec2(gridOrigin[0], gridOriginLow[0]));
+  vec2 instancePositionYFP64 = mul_fp64(vec2(gridOffset[1], gridOffsetLow[1]), vec2(float(yIndex), 0.));
+  instancePositionYFP64 = sum_fp64(instancePositionYFP64, vec2(gridOrigin[1], gridOriginLow[1]));
+
+  vec3 centroidPosition = vec3(instancePositionXFP64[0], instancePositionYFP64[0], elevation);
+  vec3 centroidPosition64Low = vec3(instancePositionXFP64[1], instancePositionYFP64[1], 0.0);
+  geometry.worldPosition = centroidPosition;
+  vec3 pos = vec3(project_size(positions.xy + offset) * dotRadius, 0.);
+
+  // Set color to be rendered to picking fbo (also used to check for selection highlight).
+  picking_setPickingColor(instancePickingColors);
+
+  gl_Position = project_position_to_clipspace(centroidPosition, centroidPosition64Low, pos, geometry.position);
+
+  // Light calculations
+  // Worldspace is the linear space after Mercator projection
+
+  vec3 normals_commonspace = project_normal(normals);
+
+   if (extruded) {
+    vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, normals_commonspace);
+    vColor = vec4(lightColor, color.a * opacity) / 255.;
+  } else {
+    vColor = vec4(color.rgb, color.a * opacity) / 255.;
+  }
+}
+`;

package/typed/gpu-grid-layer/gpu-grid-cell-layer.d.ts

@@ -0,0 +1,71 @@
+import { Layer, LayerContext } from '@deck.gl/core/typed';
+import { Model, Buffer } from '@luma.gl/core';
+import type { _GPUGridLayerProps } from './gpu-grid-layer';
+declare type _GPUGridCellLayerProps = _GPUGridLayerProps<any> & {
+    offset: number[];
+    gridSize: number[];
+    gridOrigin: number[];
+    gridOffset: number[];
+    colorMaxMinBuffer: Buffer;
+    elevationMaxMinBuffer: Buffer;
+};
+export default class GPUGridCellLayer extends Layer<_GPUGridCellLayerProps> {
+    static layerName: string;
+    static defaultProps: {
+        colorDomain: null;
+        colorRange: number[][];
+        elevationDomain: null;
+        elevationRange: number[];
+        elevationScale: {
+            type: string;
+            min: number;
+            value: number;
+        };
+        gridSize: {
+            type: string;
+            min: number;
+            value: number[];
+        };
+        gridOrigin: {
+            type: string;
+            min: number;
+            value: number[];
+        };
+        gridOffset: {
+            type: string;
+            min: number;
+            value: number[];
+        };
+        cellSize: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        offset: {
+            type: string;
+            min: number;
+            value: number[];
+        };
+        coverage: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        extruded: boolean;
+        material: boolean;
+    };
+    getShaders(): any;
+    initializeState({ gl }: LayerContext): void;
+    _getModel(gl: WebGLRenderingContext): Model;
+    draw({ uniforms }: {
+        uniforms: any;
+    }): void;
+    bindUniformBuffers(colorMaxMinBuffer: any, elevationMaxMinBuffer: any): void;
+    unbindUniformBuffers(colorMaxMinBuffer: any, elevationMaxMinBuffer: any): void;
+    getDomainUniforms(): Record<string, any>;
+    private _setupUniformBuffer;
+}
+export {};
+//# sourceMappingURL=gpu-grid-cell-layer.d.ts.map

package/typed/gpu-grid-layer/gpu-grid-cell-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-grid-cell-layer.d.ts","sourceRoot":"","sources":["../../src/gpu-grid-layer/gpu-grid-cell-layer.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAC,KAAK,EAAoD,YAAY,EAAC,MAAM,eAAe,CAAC;AAEpG,OAAO,EAAC,KAAK,EAAgB,MAAM,EAAC,MAAM,eAAe,CAAC;AAG1D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,kBAAkB,CAAC;AA8BzD,aAAK,sBAAsB,GAAG,kBAAkB,CAAC,GAAG,CAAC,GAAG;IACtD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,KAAK,CAAC,sBAAsB,CAAC;IACzE,MAAM,CAAC,SAAS,SAAsB;IACtC,MAAM,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAgB;IAEnC,UAAU;IAQV,eAAe,CAAC,EAAC,EAAE,EAAC,EAAE,YAAY;IAiBlC,SAAS,CAAC,EAAE,EAAE,qBAAqB,GAAG,KAAK;IAS3C,IAAI,CAAC,EAAC,QAAQ,EAAC;;KAAA;IAyCf,kBAAkB,CAAC,iBAAiB,KAAA,EAAE,qBAAqB,KAAA;IAK3D,oBAAoB,CAAC,iBAAiB,KAAA,EAAE,qBAAqB,KAAA;IAK7D,iBAAiB;IAkBjB,OAAO,CAAC,mBAAmB;CAS5B"}

package/typed/gpu-grid-layer/gpu-grid-cell-layer.js

@@ -0,0 +1,143 @@
+// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+import { Layer, fp64LowPart, project32, gouraudLighting, picking } from '@deck.gl/core';
+import GL from '@luma.gl/constants';
+import { Model, CubeGeometry } from '@luma.gl/core';
+import { fp64arithmetic } from '@luma.gl/shadertools';
+import { defaultColorRange, colorRangeToFlatArray } from '../utils/color-utils';
+import vs from './gpu-grid-cell-layer-vertex.glsl';
+import fs from './gpu-grid-cell-layer-fragment.glsl';
+const COLOR_DATA_UBO_INDEX = 0;
+const ELEVATION_DATA_UBO_INDEX = 1;
+const defaultProps = {
+    // color
+    colorDomain: null,
+    colorRange: defaultColorRange,
+    // elevation
+    elevationDomain: null,
+    elevationRange: [0, 1000],
+    elevationScale: { type: 'number', min: 0, value: 1 },
+    // grid
+    gridSize: { type: 'array', min: 0, value: [1, 1] },
+    gridOrigin: { type: 'array', min: 0, value: [0, 0] },
+    gridOffset: { type: 'array', min: 0, value: [0, 0] },
+    cellSize: { type: 'number', min: 0, max: 1000, value: 1000 },
+    offset: { type: 'array', min: 0, value: [1, 1] },
+    coverage: { type: 'number', min: 0, max: 1, value: 1 },
+    extruded: true,
+    material: true // Use lighting module defaults
+};
+export default class GPUGridCellLayer extends Layer {
+    getShaders() {
+        return super.getShaders({
+            vs,
+            fs,
+            modules: [project32, gouraudLighting, picking, fp64arithmetic]
+        });
+    }
+    initializeState({ gl }) {
+        const attributeManager = this.getAttributeManager();
+        attributeManager.addInstanced({
+            colors: {
+                size: 4,
+                noAlloc: true
+            },
+            elevations: {
+                size: 4,
+                noAlloc: true
+            }
+        });
+        const model = this._getModel(gl);
+        this._setupUniformBuffer(model);
+        this.setState({ model });
+    }
+    _getModel(gl) {
+        return new Model(gl, {
+            ...this.getShaders(),
+            id: this.props.id,
+            geometry: new CubeGeometry(),
+            isInstanced: true
+        });
+    }
+    draw({ uniforms }) {
+        const { cellSize, offset, extruded, elevationScale, coverage, gridSize, gridOrigin, gridOffset, elevationRange, colorMaxMinBuffer, elevationMaxMinBuffer } = this.props;
+        const gridOriginLow = [fp64LowPart(gridOrigin[0]), fp64LowPart(gridOrigin[1])];
+        const gridOffsetLow = [fp64LowPart(gridOffset[0]), fp64LowPart(gridOffset[1])];
+        const domainUniforms = this.getDomainUniforms();
+        const colorRange = colorRangeToFlatArray(this.props.colorRange);
+        this.bindUniformBuffers(colorMaxMinBuffer, elevationMaxMinBuffer);
+        this.state.model
+            .setUniforms(uniforms)
+            .setUniforms(domainUniforms)
+            .setUniforms({
+            cellSize,
+            offset,
+            extruded,
+            elevationScale,
+            coverage,
+            gridSize,
+            gridOrigin,
+            gridOriginLow,
+            gridOffset,
+            gridOffsetLow,
+            colorRange,
+            elevationRange
+        })
+            .draw();
+        this.unbindUniformBuffers(colorMaxMinBuffer, elevationMaxMinBuffer);
+    }
+    bindUniformBuffers(colorMaxMinBuffer, elevationMaxMinBuffer) {
+        colorMaxMinBuffer.bind({ target: GL.UNIFORM_BUFFER, index: COLOR_DATA_UBO_INDEX });
+        elevationMaxMinBuffer.bind({ target: GL.UNIFORM_BUFFER, index: ELEVATION_DATA_UBO_INDEX });
+    }
+    unbindUniformBuffers(colorMaxMinBuffer, elevationMaxMinBuffer) {
+        colorMaxMinBuffer.unbind({ target: GL.UNIFORM_BUFFER, index: COLOR_DATA_UBO_INDEX });
+        elevationMaxMinBuffer.unbind({ target: GL.UNIFORM_BUFFER, index: ELEVATION_DATA_UBO_INDEX });
+    }
+    getDomainUniforms() {
+        const { colorDomain, elevationDomain } = this.props;
+        const domainUniforms = {};
+        if (colorDomain !== null) {
+            domainUniforms.colorDomainValid = true;
+            domainUniforms.colorDomain = colorDomain;
+        }
+        else {
+            domainUniforms.colorDomainValid = false;
+        }
+        if (elevationDomain !== null) {
+            domainUniforms.elevationDomainValid = true;
+            domainUniforms.elevationDomain = elevationDomain;
+        }
+        else {
+            domainUniforms.elevationDomainValid = false;
+        }
+        return domainUniforms;
+    }
+    _setupUniformBuffer(model) {
+        const gl = this.context.gl;
+        const programHandle = model.program.handle;
+        const colorIndex = gl.getUniformBlockIndex(programHandle, 'ColorData');
+        const elevationIndex = gl.getUniformBlockIndex(programHandle, 'ElevationData');
+        gl.uniformBlockBinding(programHandle, colorIndex, COLOR_DATA_UBO_INDEX);
+        gl.uniformBlockBinding(programHandle, elevationIndex, ELEVATION_DATA_UBO_INDEX);
+    }
+}
+GPUGridCellLayer.layerName = 'GPUGridCellLayer';
+GPUGridCellLayer.defaultProps = defaultProps;

package/typed/gpu-grid-layer/gpu-grid-layer.d.ts

@@ -0,0 +1,134 @@
+import { Accessor, AccessorFunction, Color, GetPickingInfoParams, LayerContext, PickingInfo, Position } from '@deck.gl/core/typed';
+import { _MaterialProps as MaterialProps } from '@deck.gl/layers/typed';
+import GPUGridCellLayer from './gpu-grid-cell-layer';
+import GridAggregationLayer, { GridAggregationLayerProps } from '../grid-aggregation-layer';
+/** All properties supported by GPUGridLayer. */
+export declare type GPUGridLayerProps<DataT = any> = _GPUGridLayerProps<DataT> & GridAggregationLayerProps<DataT>;
+/** Properties added by GPUGridLayer. */
+export declare type _GPUGridLayerProps<DataT> = {
+    /**
+     * Size of each cell in meters.
+     * @default 1000
+     */
+    cellSize?: number;
+    /**
+     * Color scale domain, default is set to the extent of aggregated weights in each cell.
+     * @default [min(colorWeight), max(colorWeight)]
+     */
+    colorDomain?: [number, number] | null;
+    /**
+     * Default: [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6) `6-class YlOrRd`
+     */
+    colorRange?: Color[];
+    /**
+     * Cell size multiplier, clamped between 0 - 1.
+     * @default 1
+     */
+    coverage?: number;
+    /**
+     * Elevation scale input domain, default is set to between 0 and the max of aggregated weights in each cell.
+     * @default [0, max(elevationWeight)]
+     */
+    elevationDomain?: [number, number] | null;
+    /**
+     * Elevation scale output range.
+     * @default [0, 1000]
+     */
+    elevationRange?: [number, number];
+    /**
+     * Cell elevation multiplier.
+     * @default 1
+     */
+    elevationScale?: number;
+    /**
+     * Whether to enable cell elevation. If set to false, all cell will be flat.
+     * @default true
+     */
+    extruded?: boolean;
+    /**
+     * This is an object that contains material props
+     * for [lighting effect](/docs/api-reference/core/lighting-effect.md) applied on extruded polygons.
+     * @default true
+     */
+    material?: MaterialProps | null;
+    /**
+     * Defines the operation used to aggregate all data object weights to calculate a cell's color value.
+     * @default 'SUM'
+     */
+    colorAggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
+    /**
+     * Defines the operation used to aggregate all data object weights to calculate a cell's elevation value.
+     * @default 'SUM'
+     */
+    elevationAggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
+    /**
+     * Method called to retrieve the position of each object.
+     * @default object => object.position
+     */
+    getPosition?: AccessorFunction<DataT, Position>;
+    /**
+     * The weight of a data object used to calculate the color value for a cell.
+     * @default 1
+     */
+    getColorWeight?: Accessor<DataT, number>;
+    /**
+     * The weight of a data object used to calculate the elevation value for a cell.
+     * @default 1
+     */
+    getElevationWeight?: Accessor<DataT, number>;
+};
+/**
+ * The `GPUGridLayer` renders a grid heatmap based on an array of inputs.
+ */
+export default class GPUGridLayer<DataT = any, ExtraPropsT = {}> extends GridAggregationLayer<ExtraPropsT & Required<_GPUGridLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: {
+        colorDomain: null;
+        colorRange: number[][];
+        getColorWeight: {
+            type: string;
+            value: number;
+        };
+        colorAggregation: string;
+        elevationDomain: null;
+        elevationRange: number[];
+        getElevationWeight: {
+            type: string;
+            value: number;
+        };
+        elevationAggregation: string;
+        elevationScale: {
+            type: string;
+            min: number;
+            value: number;
+        };
+        cellSize: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        coverage: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        getPosition: {
+            type: string;
+            value: (x: any) => any;
+        };
+        extruded: boolean;
+        material: boolean;
+    };
+    initializeState({ gl }: LayerContext): void;
+    updateState(opts: any): void;
+    getHashKeyForIndex(index: number): string;
+    getPositionForIndex(index: number): Position;
+    getPickingInfo({ info, mode }: GetPickingInfoParams): PickingInfo;
+    renderLayers(): GPUGridCellLayer | null;
+    finalizeState(context: LayerContext): void;
+    updateAggregationState(opts: any): void;
+    _updateAccessors(opts: any): void;
+}
+//# sourceMappingURL=gpu-grid-layer.d.ts.map

package/typed/gpu-grid-layer/gpu-grid-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-grid-layer.d.ts","sourceRoot":"","sources":["../../src/gpu-grid-layer/gpu-grid-layer.ts"],"names":[],"mappings":"AAsBA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EACL,oBAAoB,EACpB,YAAY,EAEZ,WAAW,EACX,QAAQ,EACT,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,cAAc,IAAI,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAKhE,OAAO,gBAAgB,MAAM,uBAAuB,CAAC;AAErD,OAAO,oBAAoB,EAAE,EAAC,yBAAyB,EAAC,MAAM,2BAA2B,CAAC;AAsC1F,gDAAgD;AAChD,oBAAY,iBAAiB,CAAC,KAAK,GAAG,GAAG,IAAI,kBAAkB,CAAC,KAAK,CAAC,GACpE,yBAAyB,CAAC,KAAK,CAAC,CAAC;AAEnC,wCAAwC;AACxC,oBAAY,kBAAkB,CAAC,KAAK,IAAI;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAEtC;;OAEG;IACH,UAAU,CAAC,EAAE,KAAK,EAAE,CAAC;IAErB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAE1C;;;OAGG;IACH,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAElC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAEhC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;IAElD;;;OAGG;IACH,oBAAoB,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;IAEtD;;;OAGG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAEhD;;;OAGG;IACH,cAAc,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAEzC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CAC9C,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,YAAY,CAAC,KAAK,GAAG,GAAG,EAAE,WAAW,GAAG,EAAE,CAAE,SAAQ,oBAAoB,CAC3F,WAAW,GAAG,QAAQ,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAClD;IACC,MAAM,CAAC,SAAS,SAAkB;IAClC,MAAM,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAgB;IAEnC,eAAe,CAAC,EAAC,EAAE,EAAC,EAAE,YAAY,GAAG,IAAI;IA+CzC,WAAW,CAAC,IAAI,KAAA;IAehB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAkBzC,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ;IAa5C,cAAc,CAAC,EAAC,IAAI,EAAE,IAAI,EAAC,EAAE,oBAAoB,GAAG,WAAW;IAqD/D,YAAY;IAsDZ,aAAa,CAAC,OAAO,EAAE,YAAY;IAYnC,sBAAsB,CAAC,IAAI,KAAA;IAoD3B,gBAAgB,CAAC,IAAI,KAAA;CAMtB"}