@kepler.gl/components 3.3.0-alpha.5 → 3.3.0-alpha.7

package/dist/common/data-table/column-statistics-numeric.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { NumericColumnStats } from '@kepler.gl/utils';
+import HistogramPlotFactory, { HistogramPlotProps } from '../histogram-plot';
+export type ColumnStatisticsNumericProps = NumericColumnStats & {
+    width?: number;
+    margin?: {
+        top: number;
+        left: number;
+        right: number;
+        bottom: number;
+    };
+    type?: string;
+};
+declare function ColumnStatisticsNumericFactory(HistogramPlot: React.FC<HistogramPlotProps>): React.FC<ColumnStatisticsNumericProps>;
+declare namespace ColumnStatisticsNumericFactory {
+    var deps: (typeof HistogramPlotFactory)[];
+}
+export default ColumnStatisticsNumericFactory;

package/dist/common/data-table/column-statistics-time.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { TimeColumnStats } from '@kepler.gl/utils';
+import HistogramPlotFactory, { HistogramPlotProps } from '../histogram-plot';
+export type ColumnStatisticsTimeProps = TimeColumnStats & {
+    width?: number;
+    margin?: {
+        top: number;
+        left: number;
+        right: number;
+        bottom: number;
+    };
+    type?: string;
+    format?: string;
+};
+declare function ColumnStatisticsTimeFactory(HistogramPlot: React.FC<HistogramPlotProps>): React.FC<ColumnStatisticsTimeProps>;
+declare namespace ColumnStatisticsTimeFactory {
+    var deps: (typeof HistogramPlotFactory)[];
+}
+export default ColumnStatisticsTimeFactory;

package/dist/common/data-table/header-cell.d.ts

@@ -2,6 +2,8 @@ import React, { CSSProperties } from 'react';
 import { ColMeta } from '@kepler.gl/types';
 import FieldTokenFactory, { FieldTokenProps } from '../../common/field-token';
 import { DataTableProps } from './index';
+import ColumnStatisticsNumericFactory, { ColumnStatisticsNumericProps } from './column-statistics-numeric';
+import ColumnStatisticsTimeFactory, { ColumnStatisticsTimeProps } from './column-statistics-time';
 type CellInfo = {
     columnIndex: number;
     isScrolling: boolean;
@@ -11,7 +13,7 @@ type CellInfo = {
     rowIndex: number;
     style: CSSProperties;
 };
-type HeaderCellProps = {
+export type HeaderCellProps = {
     cellInfo: CellInfo;
     columns: DataTableProps['columns'];
     colMeta?: ColMeta;
@@ -22,8 +24,8 @@ type HeaderCellProps = {
     moreOptionsColumn: null | string;
     style: CSSProperties;
 };
-declare const HeaderCellFactory: {
-    (FieldToken: React.FC<FieldTokenProps>): ({ cellInfo, columns, isPinned, props, toggleMoreOptions, moreOptionsColumn }: HeaderCellProps) => React.JSX.Element;
-    deps: (typeof FieldTokenFactory)[];
-};
+declare function HeaderCellFactory(FieldToken: React.FC<FieldTokenProps>, ColumnStatisticsNumeric: React.FC<ColumnStatisticsNumericProps>, ColumnStatisticsTime: React.FC<ColumnStatisticsTimeProps>): ({ cellInfo, columns, isPinned, showStats, props, toggleMoreOptions, moreOptionsColumn }: HeaderCellProps) => React.JSX.Element;
+declare namespace HeaderCellFactory {
+    var deps: (typeof FieldTokenFactory | typeof ColumnStatisticsNumericFactory | typeof ColumnStatisticsTimeFactory)[];
+}
 export default HeaderCellFactory;

package/dist/common/data-table/index.d.ts

@@ -6,8 +6,9 @@ import { ColMeta } from '@kepler.gl/types';
 import { DataContainerInterface } from '@kepler.gl/utils';
 type ContainerProps = {
     $hasCustomScrollBarStyle?: boolean;
+    $hasStats?: boolean;
 };
-export declare const Container: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$hasCustomScrollBarStyle"> & ContainerProps, never> & Partial<Pick<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$hasCustomScrollBarStyle"> & ContainerProps, never>>> & string;
+export declare const Container: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof ContainerProps> & ContainerProps, never> & Partial<Pick<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof ContainerProps> & ContainerProps, never>>> & string;
 export type SortColumn = {
     column?: string;
     mode?: string;
@@ -45,8 +46,10 @@ interface TableSectionProps {
     headerCellRender?: any;
     dataCellRender?: any;
     scrollLeft?: number;
+    headerVisibleHeight?: number;
+    headerBodyOffset?: number;
 }
-export declare const TableSection: ({ classList, isPinned, columns, headerGridProps, fixedWidth, fixedHeight, onScroll, scrollTop, dataGridProps, columnWidth, setGridRef, headerCellRender, dataCellRender, scrollLeft }: TableSectionProps) => React.JSX.Element;
+export declare const TableSection: ({ classList, isPinned, columns, headerGridProps, fixedWidth, fixedHeight, onScroll, scrollTop, dataGridProps, columnWidth, setGridRef, headerCellRender, dataCellRender, scrollLeft, headerVisibleHeight, headerBodyOffset }: TableSectionProps) => React.JSX.Element;
 export interface DataTableProps {
     dataId?: string;
     hasStats?: boolean;
@@ -71,30 +74,10 @@ export interface DataTableProps {
     showStats?: boolean;
     hasCustomScrollBarStyle?: boolean;
     getRowCell?: (renderDataCellProps: GetRowCellProps, formatter: any) => string | number;
+    loadColumnStats?: (dataId: string, fieldName: string) => void;
 }
 declare function DataTableFactory(HeaderCell: ReturnType<typeof HeaderCellFactory>): React.ComponentType<DataTableProps>;
 declare namespace DataTableFactory {
-    var deps: {
-        (FieldToken: React.FC<import("../field-token").FieldTokenProps>): ({ cellInfo, columns, isPinned, props, toggleMoreOptions, moreOptionsColumn }: {
-            cellInfo: {
-                columnIndex: number;
-                isScrolling: boolean;
-                isVisible: boolean;
-                key: string;
-                parent: any;
-                rowIndex: number;
-                style: React.CSSProperties;
-            };
-            columns: DataTableProps["columns"];
-            colMeta?: ColMeta;
-            isPinned?: boolean;
-            showStats?: boolean;
-            props: DataTableProps;
-            toggleMoreOptions: (moreOptionsColumn: string) => void;
-            moreOptionsColumn: null | string;
-            style: React.CSSProperties;
-        }) => React.JSX.Element;
-        deps: typeof import("../field-token").default[];
-    }[];
+    var deps: (typeof HeaderCellFactory)[];
 }
 export default DataTableFactory;

package/dist/common/histogram-plot.d.ts

@@ -1,4 +1,5 @@
-import React from 'react';
+import React, { ReactElement } from 'react';
+import { Bins } from '@kepler.gl/types';
 export declare const HISTOGRAM_MASK_MODE: {
     NoMask: number;
     Mask: number;
@@ -9,5 +10,27 @@ export type HistogramMaskModeType = {
     Mask: number;
     MaskWithOverlay: number;
 };
+export interface HistogramPlotProps {
+    width: number;
+    height: number;
+    margin: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    isRanged?: boolean;
+    isEnlarged?: boolean;
+    value: number[];
+    isMasked?: number;
+    brushComponent?: ReactElement;
+    histogramsByGroup: Bins;
+    colorsByGroup?: null | {
+        [dataId: string]: string;
+    };
+    countProp?: string;
+    range?: number[];
+    breakLines?: number[];
+}
 declare function HistogramPlotFactory(): (props: any) => React.JSX.Element | null;
 export default HistogramPlotFactory;

package/dist/common/icons/draw-point.d.ts

@@ -0,0 +1,10 @@
+import React, { Component } from 'react';
+import { BaseProps } from './base';
+export default class DrawPoint extends Component<Partial<BaseProps>> {
+    static defaultProps: {
+        height: string;
+        predefinedClassName: string;
+        viewBox: string;
+    };
+    render(): React.JSX.Element;
+}

package/dist/common/icons/index.d.ts

@@ -77,6 +77,8 @@ export { default as CodeAlt } from './code-alt';
 export { default as Warning } from './warning';
 export { default as WarningSign } from './warning-sign';
 export { default as DrawPolygon } from './draw-polygon';
+export { default as DrawPoint } from './draw-point';
+export { default as LineString } from './line-string';
 export { default as Polygon } from './polygon';
 export { default as Rectangle } from './rectangle';
 export { default as TimelineMarker } from './timeline-marker';

package/dist/common/icons/line-string.d.ts

@@ -0,0 +1,10 @@
+import React, { Component } from 'react';
+import { BaseProps } from './base';
+export default class LineString extends Component<Partial<BaseProps>> {
+    static defaultProps: {
+        height: string;
+        predefinedClassName: string;
+        viewBox: string;
+    };
+    render(): React.JSX.Element;
+}

package/dist/common/toolbar-item.d.ts

@@ -4,8 +4,10 @@ export type ToolbarItemProps = {
     id?: string;
     key?: string;
     label: string;
+    tooltip?: string;
     className?: string;
     active?: boolean;
+    disabled?: boolean;
     onClose?: () => void;
     onClick: ((event: MouseEvent<HTMLDivElement>) => void) | null;
     icon?: ComponentType<any>;

package/dist/editor/editor.d.ts

@@ -18,6 +18,7 @@ interface EditorProps {
     onSelect: (f: Feature | null) => any;
     onSetEditorMode: (m: any) => void;
     onDeleteFeature: (f: Feature) => any;
+    onSetFeatureProperties: (f: Feature, properties: Record<string, unknown>) => any;
     onTogglePolygonFilter: (l: Layer, f: Feature) => any;
 }
 export type PortalEditorProps = FeatureActionPanelProps & {

package/dist/editor/feature-action-panel.d.ts

@@ -15,6 +15,7 @@ export interface FeatureActionPanelProps {
     currentFilter?: Filter;
     onToggleLayer: (layer: Layer) => void;
     onDeleteFeature: () => void;
+    onSetFeatureProperties?: (feature: Feature, properties: Record<string, unknown>) => void;
     onClose?: () => void;
     children?: React.ReactNode;
     actionIcons?: {

package/dist/editor/feature-properties-editor.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { Feature } from '@deck.gl-community/editable-layers';
+type FeaturePropertiesEditorProps = {
+    selectedFeature: Feature | null;
+    onSetFeatureProperties?: (feature: Feature, properties: Record<string, unknown>) => void;
+};
+export default function FeaturePropertiesEditor({ selectedFeature, onSetFeatureProperties }: FeaturePropertiesEditorProps): React.JSX.Element;
+export {};

package/dist/editor/filter-feature-badges.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Filter, Feature } from '@kepler.gl/types';
+import { MapViewport } from '../annotations/annotation-utils';
+export type FilterFeatureBadgesProps = {
+    filters: Filter[];
+    viewport?: MapViewport | null;
+    isGlobeEnabled?: boolean;
+    onSelect?: (feature: Feature) => void;
+};
+declare function FilterFeatureBadges({ filters, viewport, isGlobeEnabled, onSelect }: FilterFeatureBadgesProps): React.JSX.Element | null;
+declare const _default: React.MemoExoticComponent<typeof FilterFeatureBadges>;
+export default _default;

package/dist/esm/annotations/annotation-node.js

@@ -0,0 +1,138 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import { useDraggable } from '@dnd-kit/core';
+import { AnnotationKind } from '@kepler.gl/constants';
+import { makeMarker } from './annotation-utils';
+var HANDLE_RADIUS = 6;
+var MoveHandle = function MoveHandle(_ref) {
+  var id = _ref.id,
+    x = _ref.x,
+    y = _ref.y;
+  var _useDraggable = useDraggable({
+      id: id
+    }),
+    attributes = _useDraggable.attributes,
+    listeners = _useDraggable.listeners,
+    setNodeRef = _useDraggable.setNodeRef;
+  return /*#__PURE__*/React.createElement("circle", _extends({
+    ref: setNodeRef
+  }, listeners, attributes, {
+    cx: x,
+    cy: y,
+    r: HANDLE_RADIUS,
+    fill: "transparent",
+    stroke: "rgba(255,255,255,0.6)",
+    strokeWidth: 1,
+    cursor: "move",
+    style: {
+      pointerEvents: 'all'
+    }
+  }));
+};
+var ResizeHandle = function ResizeHandle(_ref2) {
+  var id = _ref2.id,
+    x = _ref2.x,
+    y = _ref2.y;
+  var _useDraggable2 = useDraggable({
+      id: id
+    }),
+    attributes = _useDraggable2.attributes,
+    listeners = _useDraggable2.listeners,
+    setNodeRef = _useDraggable2.setNodeRef;
+  return /*#__PURE__*/React.createElement("circle", _extends({
+    ref: setNodeRef
+  }, listeners, attributes, {
+    cx: x,
+    cy: y,
+    r: HANDLE_RADIUS,
+    fill: "transparent",
+    stroke: "rgba(255,255,255,0.6)",
+    strokeWidth: 1,
+    cursor: "ew-resize",
+    style: {
+      pointerEvents: 'all'
+    }
+  }));
+};
+var AnnotationNode = function AnnotationNode(_ref3) {
+  var annotation = _ref3.annotation,
+    viewport = _ref3.viewport,
+    isEditing = _ref3.isEditing,
+    isSelected = _ref3.isSelected;
+  var lineColor = annotation.lineColor,
+    lineWidth = annotation.lineWidth;
+  var marker = makeMarker(annotation, viewport);
+  var kind = marker.kind,
+    x = marker.x,
+    y = marker.y,
+    tx = marker.tx,
+    ty = marker.ty;
+  var arrW = 3 + lineWidth * 2;
+  var isArm = 'armLength' in annotation;
+  var moveHandle = isEditing ? /*#__PURE__*/React.createElement(MoveHandle, {
+    id: "".concat(annotation.id, ":MOVE_POINT"),
+    x: 0,
+    y: 0
+  }) : null;
+  var selectionHighlight = isEditing && isSelected ? /*#__PURE__*/React.createElement("circle", {
+    r: HANDLE_RADIUS + 2,
+    fill: "none",
+    stroke: "rgba(64,169,255,0.6)",
+    strokeWidth: 2
+  }) : null;
+  var body = null;
+  switch (kind) {
+    case AnnotationKind.CIRCLE:
+      {
+        var circleMarker = marker;
+        body = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("circle", _extends({
+          r: circleMarker.r,
+          fill: "none",
+          stroke: lineColor,
+          strokeWidth: lineWidth
+        }, isSelected && isEditing ? {
+          strokeDasharray: '6 3'
+        } : {})), /*#__PURE__*/React.createElement("path", {
+          d: "M".concat(circleMarker.ax, ",").concat(circleMarker.ay, " L").concat(tx, ",").concat(ty),
+          stroke: lineColor,
+          strokeWidth: lineWidth,
+          fill: "none",
+          strokeLinecap: "round"
+        }), isEditing ? /*#__PURE__*/React.createElement(React.Fragment, null, moveHandle, selectionHighlight, /*#__PURE__*/React.createElement(ResizeHandle, {
+          id: "".concat(annotation.id, ":RESIZE"),
+          x: circleMarker.r,
+          y: 0
+        })) : null);
+        break;
+      }
+    case AnnotationKind.POINT:
+    case AnnotationKind.ARROW:
+      body = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("path", {
+        d: "M0,0 L".concat(tx, ",").concat(ty),
+        stroke: lineColor,
+        fill: "none",
+        strokeWidth: lineWidth,
+        strokeLinecap: "round"
+      }), kind === AnnotationKind.ARROW ? /*#__PURE__*/React.createElement("path", {
+        transform: isArm ? "rotate(".concat(90 + annotation.angle, ")") : undefined,
+        d: "M0,".concat(lineWidth, " L").concat(-arrW, ",").concat(-arrW, " L").concat(arrW, ",").concat(-arrW, " Z"),
+        stroke: "none",
+        fill: lineColor
+      }) : null, kind === AnnotationKind.POINT ? /*#__PURE__*/React.createElement("circle", {
+        r: lineWidth * 1.5,
+        fill: lineColor,
+        stroke: "none"
+      }) : null, moveHandle, selectionHighlight);
+      break;
+    default:
+      body = /*#__PURE__*/React.createElement(React.Fragment, null, moveHandle, selectionHighlight);
+  }
+  return /*#__PURE__*/React.createElement("g", {
+    transform: "translate(".concat(x, ",").concat(y, ")")
+  }, body);
+};
+export default AnnotationNode;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useDraggable","AnnotationKind","makeMarker","HANDLE_RADIUS","MoveHandle","_ref","id","x","y","_useDraggable","attributes","listeners","setNodeRef","createElement","_extends","ref","cx","cy","r","fill","stroke","strokeWidth","cursor","style","pointerEvents","ResizeHandle","_ref2","_useDraggable2","AnnotationNode","_ref3","annotation","viewport","isEditing","isSelected","lineColor","lineWidth","marker","kind","tx","ty","arrW","isArm","moveHandle","concat","selectionHighlight","body","CIRCLE","circleMarker","Fragment","strokeDasharray","d","ax","ay","strokeLinecap","POINT","ARROW","transform","angle","undefined"],"sources":["../../../src/annotations/annotation-node.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {FC} from 'react';\nimport {useDraggable} from '@dnd-kit/core';\nimport {Annotation, AnnotationWithArm} from '@kepler.gl/types';\nimport {AnnotationKind} from '@kepler.gl/constants';\nimport {makeMarker, MapViewport, CircleAnnotationMarker} from './annotation-utils';\n\nconst HANDLE_RADIUS = 6;\n\nconst MoveHandle: FC<{id: string; x: number; y: number}> = ({id, x, y}) => {\n  const {attributes, listeners, setNodeRef} = useDraggable({id});\n  return (\n    <circle\n      ref={setNodeRef as any}\n      {...listeners}\n      {...attributes}\n      cx={x}\n      cy={y}\n      r={HANDLE_RADIUS}\n      fill=\"transparent\"\n      stroke=\"rgba(255,255,255,0.6)\"\n      strokeWidth={1}\n      cursor=\"move\"\n      style={{pointerEvents: 'all'}}\n    />\n  );\n};\n\nconst ResizeHandle: FC<{id: string; x: number; y: number}> = ({id, x, y}) => {\n  const {attributes, listeners, setNodeRef} = useDraggable({id});\n  return (\n    <circle\n      ref={setNodeRef as any}\n      {...listeners}\n      {...attributes}\n      cx={x}\n      cy={y}\n      r={HANDLE_RADIUS}\n      fill=\"transparent\"\n      stroke=\"rgba(255,255,255,0.6)\"\n      strokeWidth={1}\n      cursor=\"ew-resize\"\n      style={{pointerEvents: 'all'}}\n    />\n  );\n};\n\nexport type AnnotationNodeProps = {\n  annotation: Annotation;\n  viewport: MapViewport;\n  isEditing: boolean;\n  isSelected: boolean;\n};\n\nconst AnnotationNode: FC<AnnotationNodeProps> = ({annotation, viewport, isEditing, isSelected}) => {\n  const {lineColor, lineWidth} = annotation;\n  const marker = makeMarker(annotation, viewport);\n  const {kind, x, y, tx, ty} = marker;\n  const arrW = 3 + lineWidth * 2;\n  const isArm = 'armLength' in annotation;\n\n  const moveHandle = isEditing ? (\n    <MoveHandle id={`${annotation.id}:MOVE_POINT`} x={0} y={0} />\n  ) : null;\n\n  const selectionHighlight =\n    isEditing && isSelected ? (\n      <circle r={HANDLE_RADIUS + 2} fill=\"none\" stroke=\"rgba(64,169,255,0.6)\" strokeWidth={2} />\n    ) : null;\n\n  let body: React.ReactNode = null;\n\n  switch (kind) {\n    case AnnotationKind.CIRCLE: {\n      const circleMarker = marker as CircleAnnotationMarker;\n      body = (\n        <>\n          <circle\n            r={circleMarker.r}\n            fill=\"none\"\n            stroke={lineColor}\n            strokeWidth={lineWidth}\n            {...(isSelected && isEditing ? {strokeDasharray: '6 3'} : {})}\n          />\n          <path\n            d={`M${circleMarker.ax},${circleMarker.ay} L${tx},${ty}`}\n            stroke={lineColor}\n            strokeWidth={lineWidth}\n            fill=\"none\"\n            strokeLinecap=\"round\"\n          />\n          {isEditing ? (\n            <>\n              {moveHandle}\n              {selectionHighlight}\n              <ResizeHandle id={`${annotation.id}:RESIZE`} x={circleMarker.r} y={0} />\n            </>\n          ) : null}\n        </>\n      );\n      break;\n    }\n    case AnnotationKind.POINT:\n    case AnnotationKind.ARROW:\n      body = (\n        <>\n          <path\n            d={`M0,0 L${tx},${ty}`}\n            stroke={lineColor}\n            fill=\"none\"\n            strokeWidth={lineWidth}\n            strokeLinecap=\"round\"\n          />\n          {kind === AnnotationKind.ARROW ? (\n            <path\n              transform={\n                isArm ? `rotate(${90 + (annotation as AnnotationWithArm).angle})` : undefined\n              }\n              d={`M0,${lineWidth} L${-arrW},${-arrW} L${arrW},${-arrW} Z`}\n              stroke=\"none\"\n              fill={lineColor}\n            />\n          ) : null}\n          {kind === AnnotationKind.POINT ? (\n            <circle r={lineWidth * 1.5} fill={lineColor} stroke=\"none\" />\n          ) : null}\n          {moveHandle}\n          {selectionHighlight}\n        </>\n      );\n      break;\n    default:\n      body = (\n        <>\n          {moveHandle}\n          {selectionHighlight}\n        </>\n      );\n  }\n\n  return <g transform={`translate(${x},${y})`}>{body}</g>;\n};\n\nexport default AnnotationNode;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/annotations/annotation-overlay.js

@@ -0,0 +1,161 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useMemo } from 'react';
+import styled from 'styled-components';
+import { DndContext, PointerSensor, useSensor, useSensors } from '@dnd-kit/core';
+import AnnotationNode from './annotation-node';
+import AnnotationText from './annotation-text';
+import { isPointVisibleOnGlobe, movePoint, moveText, resizeCircle } from './annotation-utils';
+var AnnotationOverlayContainer = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n  pointer-events: none;\n  overflow: hidden;\n  z-index: 0;\n"])));
+var AnnotationSvgContainer = styled.svg(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  position: absolute;\n  top: 0;\n  left: 0;\n  pointer-events: none;\n"])));
+var AnnotationTextContainer = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  position: absolute;\n  top: 0;\n  left: 0;\n  pointer-events: none;\n"])));
+var AnnotationOverlay = function AnnotationOverlay(_ref) {
+  var annotations = _ref.annotations,
+    selectedAnnotationId = _ref.selectedAnnotationId,
+    isEditingAnnotationText = _ref.isEditingAnnotationText,
+    isAnnotationMode = _ref.isAnnotationMode,
+    mapIndex = _ref.mapIndex,
+    viewport = _ref.viewport,
+    isGlobeEnabled = _ref.isGlobeEnabled,
+    _onUpdateAnnotation = _ref.updateAnnotation,
+    onSetSelectedAnnotation = _ref.setSelectedAnnotation;
+  var annotationsToRender = useMemo(function () {
+    return annotations.filter(function (ann) {
+      var _ann$mapIndex;
+      return ((_ann$mapIndex = ann.mapIndex) !== null && _ann$mapIndex !== void 0 ? _ann$mapIndex : 0) === mapIndex && ann.isVisible && (
+      // Hide annotations on the far side of the globe (occluded by the planet)
+      !isGlobeEnabled || isPointVisibleOnGlobe(ann.anchorPoint, viewport));
+    }).reverse();
+  }, [annotations, mapIndex, isGlobeEnabled, viewport]);
+  var draggedAnnotationRef = React.useRef(null);
+  var sensors = useSensors(useSensor(PointerSensor, {
+    activationConstraint: {
+      distance: 3
+    }
+  }));
+  var accessibility = useMemo(function () {
+    return _objectSpread({
+      announcements: {
+        onDragStart: function onDragStart() {
+          return '';
+        },
+        onDragOver: function onDragOver() {
+          return '';
+        },
+        onDragEnd: function onDragEnd() {
+          return '';
+        },
+        onDragCancel: function onDragCancel() {
+          return '';
+        }
+      },
+      screenReaderInstructions: {
+        draggable: ''
+      }
+    }, typeof document !== 'undefined' ? {
+      container: document.body
+    } : {});
+  }, []);
+  var handleDragStart = useCallback(function (ev) {
+    var _annotations$find;
+    var annId = "".concat(ev.active.id).split(':')[0];
+    var ann = (_annotations$find = annotations.find(function (a) {
+      return a.id === annId;
+    })) !== null && _annotations$find !== void 0 ? _annotations$find : null;
+    draggedAnnotationRef.current = ann;
+    if (ann) {
+      onSetSelectedAnnotation(ann.id, false);
+    }
+  }, [annotations, onSetSelectedAnnotation]);
+  var handleDragMove = useCallback(function (ev) {
+    var _split = "".concat(ev.active.id).split(':'),
+      _split2 = _slicedToArray(_split, 2),
+      annId = _split2[0],
+      handleKind = _split2[1];
+    var draggedAnn = draggedAnnotationRef.current;
+    if (!draggedAnn || draggedAnn.id !== annId) return;
+    var changes = {};
+    switch (handleKind) {
+      case 'MOVE_POINT':
+        changes = movePoint(draggedAnn, ev.delta, viewport);
+        break;
+      case 'MOVE_TEXT':
+        changes = moveText(draggedAnn, ev.delta, viewport);
+        break;
+      case 'RESIZE':
+        changes = resizeCircle(draggedAnn, ev.delta, viewport);
+        break;
+    }
+    if (Object.keys(changes).length > 0) {
+      _onUpdateAnnotation(annId, changes);
+    }
+  }, [viewport, _onUpdateAnnotation]);
+  var handleDragEnd = useCallback(function (_ev) {
+    draggedAnnotationRef.current = null;
+  }, []);
+  var handleSelectAnnotation = useCallback(function (id, isEditingText) {
+    onSetSelectedAnnotation(id, isEditingText);
+  }, [onSetSelectedAnnotation]);
+  var handleChangeText = useCallback(function (id, text, editorState) {
+    _onUpdateAnnotation(id, _objectSpread({
+      label: text
+    }, editorState ? {
+      editorState: editorState
+    } : {}));
+  }, [_onUpdateAnnotation]);
+  if (!annotationsToRender.length) {
+    return null;
+  }
+  var width = viewport.width,
+    height = viewport.height;
+  return /*#__PURE__*/React.createElement(AnnotationOverlayContainer, null, /*#__PURE__*/React.createElement(DndContext, {
+    sensors: sensors,
+    accessibility: accessibility,
+    onDragStart: handleDragStart,
+    onDragMove: handleDragMove,
+    onDragEnd: handleDragEnd
+  }, /*#__PURE__*/React.createElement(AnnotationSvgContainer, {
+    width: width,
+    height: height
+  }, annotationsToRender.map(function (annotation) {
+    return /*#__PURE__*/React.createElement(AnnotationNode, {
+      key: annotation.id,
+      annotation: annotation,
+      viewport: viewport,
+      isEditing: isAnnotationMode,
+      isSelected: annotation.id === selectedAnnotationId
+    });
+  })), /*#__PURE__*/React.createElement(AnnotationTextContainer, {
+    style: {
+      width: width,
+      height: height
+    }
+  }, annotationsToRender.map(function (annotation) {
+    return /*#__PURE__*/React.createElement(AnnotationText, {
+      key: annotation.id,
+      annotation: annotation,
+      viewport: viewport,
+      isEditing: isAnnotationMode,
+      isSelected: annotation.id === selectedAnnotationId,
+      isEditingText: annotation.id === selectedAnnotationId && isEditingAnnotationText,
+      onSelect: function onSelect(isEditingText) {
+        return handleSelectAnnotation(annotation.id, isEditingText);
+      },
+      onChangeText: function onChangeText(text, editorState) {
+        return handleChangeText(annotation.id, text, editorState);
+      },
+      onUpdateAnnotation: function onUpdateAnnotation(config) {
+        return _onUpdateAnnotation(annotation.id, config);
+      }
+    });
+  }))));
+};
+export default AnnotationOverlay;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useMemo","styled","DndContext","PointerSensor","useSensor","useSensors","AnnotationNode","AnnotationText","isPointVisibleOnGlobe","movePoint","moveText","resizeCircle","AnnotationOverlayContainer","div","_templateObject","_taggedTemplateLiteral","AnnotationSvgContainer","svg","_templateObject2","AnnotationTextContainer","_templateObject3","AnnotationOverlay","_ref","annotations","selectedAnnotationId","isEditingAnnotationText","isAnnotationMode","mapIndex","viewport","isGlobeEnabled","onUpdateAnnotation","updateAnnotation","onSetSelectedAnnotation","setSelectedAnnotation","annotationsToRender","filter","ann","_ann$mapIndex","isVisible","anchorPoint","reverse","draggedAnnotationRef","useRef","sensors","activationConstraint","distance","accessibility","_objectSpread","announcements","onDragStart","onDragOver","onDragEnd","onDragCancel","screenReaderInstructions","draggable","document","container","body","handleDragStart","ev","_annotations$find","annId","concat","active","id","split","find","a","current","handleDragMove","_split","_split2","_slicedToArray","handleKind","draggedAnn","changes","delta","Object","keys","length","handleDragEnd","_ev","handleSelectAnnotation","isEditingText","handleChangeText","text","editorState","label","width","height","createElement","onDragMove","map","annotation","key","isEditing","isSelected","style","onSelect","onChangeText","config"],"sources":["../../../src/annotations/annotation-overlay.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {FC, useCallback, useMemo} from 'react';\nimport styled from 'styled-components';\nimport {\n  DndContext,\n  DragMoveEvent,\n  DragStartEvent,\n  DragEndEvent,\n  PointerSensor,\n  useSensor,\n  useSensors\n} from '@dnd-kit/core';\nimport {Annotation} from '@kepler.gl/types';\nimport {ActionHandler, updateAnnotation, setSelectedAnnotation} from '@kepler.gl/actions';\nimport AnnotationNode from './annotation-node';\nimport AnnotationText from './annotation-text';\nimport {\n  MapViewport,\n  isPointVisibleOnGlobe,\n  movePoint,\n  moveText,\n  resizeCircle\n} from './annotation-utils';\n\nconst AnnotationOverlayContainer = styled.div`\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n  pointer-events: none;\n  overflow: hidden;\n  z-index: 0;\n`;\n\nconst AnnotationSvgContainer = styled.svg`\n  position: absolute;\n  top: 0;\n  left: 0;\n  pointer-events: none;\n`;\n\nconst AnnotationTextContainer = styled.div`\n  position: absolute;\n  top: 0;\n  left: 0;\n  pointer-events: none;\n`;\n\nexport type AnnotationOverlayProps = {\n  annotations: Annotation[];\n  selectedAnnotationId: string | null;\n  isEditingAnnotationText: boolean;\n  isAnnotationMode: boolean;\n  mapIndex: number;\n  viewport: MapViewport;\n  isGlobeEnabled?: boolean;\n  updateAnnotation: ActionHandler<typeof updateAnnotation>;\n  setSelectedAnnotation: ActionHandler<typeof setSelectedAnnotation>;\n};\n\nconst AnnotationOverlay: FC<AnnotationOverlayProps> = ({\n  annotations,\n  selectedAnnotationId,\n  isEditingAnnotationText,\n  isAnnotationMode,\n  mapIndex,\n  viewport,\n  isGlobeEnabled,\n  updateAnnotation: onUpdateAnnotation,\n  setSelectedAnnotation: onSetSelectedAnnotation\n}) => {\n  const annotationsToRender = useMemo(\n    () =>\n      annotations\n        .filter(\n          ann =>\n            (ann.mapIndex ?? 0) === mapIndex &&\n            ann.isVisible &&\n            // Hide annotations on the far side of the globe (occluded by the planet)\n            (!isGlobeEnabled || isPointVisibleOnGlobe(ann.anchorPoint, viewport))\n        )\n        .reverse(),\n    [annotations, mapIndex, isGlobeEnabled, viewport]\n  );\n\n  const draggedAnnotationRef = React.useRef<Annotation | null>(null);\n\n  const sensors = useSensors(\n    useSensor(PointerSensor, {\n      activationConstraint: {distance: 3}\n    })\n  );\n\n  const accessibility = useMemo(\n    () => ({\n      announcements: {\n        onDragStart() {\n          return '';\n        },\n        onDragOver() {\n          return '';\n        },\n        onDragEnd() {\n          return '';\n        },\n        onDragCancel() {\n          return '';\n        }\n      },\n      screenReaderInstructions: {draggable: ''},\n      ...(typeof document !== 'undefined' ? {container: document.body} : {})\n    }),\n    []\n  );\n\n  const handleDragStart = useCallback(\n    (ev: DragStartEvent) => {\n      const annId = `${ev.active.id}`.split(':')[0];\n      const ann = annotations.find(a => a.id === annId) ?? null;\n      draggedAnnotationRef.current = ann;\n      if (ann) {\n        onSetSelectedAnnotation(ann.id, false);\n      }\n    },\n    [annotations, onSetSelectedAnnotation]\n  );\n\n  const handleDragMove = useCallback(\n    (ev: DragMoveEvent) => {\n      const [annId, handleKind] = `${ev.active.id}`.split(':');\n      const draggedAnn = draggedAnnotationRef.current;\n      if (!draggedAnn || draggedAnn.id !== annId) return;\n\n      let changes: Partial<Annotation> = {};\n      switch (handleKind) {\n        case 'MOVE_POINT':\n          changes = movePoint(draggedAnn, ev.delta, viewport);\n          break;\n        case 'MOVE_TEXT':\n          changes = moveText(draggedAnn, ev.delta, viewport);\n          break;\n        case 'RESIZE':\n          changes = resizeCircle(draggedAnn, ev.delta, viewport);\n          break;\n      }\n      if (Object.keys(changes).length > 0) {\n        onUpdateAnnotation(annId, changes);\n      }\n    },\n    [viewport, onUpdateAnnotation]\n  );\n\n  const handleDragEnd = useCallback((_ev: DragEndEvent) => {\n    draggedAnnotationRef.current = null;\n  }, []);\n\n  const handleSelectAnnotation = useCallback(\n    (id: string, isEditingText: boolean) => {\n      onSetSelectedAnnotation(id, isEditingText);\n    },\n    [onSetSelectedAnnotation]\n  );\n\n  const handleChangeText = useCallback(\n    (id: string, text: string, editorState?: Record<string, any>) => {\n      onUpdateAnnotation(id, {label: text, ...(editorState ? {editorState} : {})});\n    },\n    [onUpdateAnnotation]\n  );\n\n  if (!annotationsToRender.length) {\n    return null;\n  }\n\n  const {width, height} = viewport;\n\n  return (\n    <AnnotationOverlayContainer>\n      <DndContext\n        sensors={sensors}\n        accessibility={accessibility}\n        onDragStart={handleDragStart}\n        onDragMove={handleDragMove}\n        onDragEnd={handleDragEnd}\n      >\n        <AnnotationSvgContainer width={width} height={height}>\n          {annotationsToRender.map(annotation => (\n            <AnnotationNode\n              key={annotation.id}\n              annotation={annotation}\n              viewport={viewport}\n              isEditing={isAnnotationMode}\n              isSelected={annotation.id === selectedAnnotationId}\n            />\n          ))}\n        </AnnotationSvgContainer>\n        <AnnotationTextContainer style={{width, height}}>\n          {annotationsToRender.map(annotation => (\n            <AnnotationText\n              key={annotation.id}\n              annotation={annotation}\n              viewport={viewport}\n              isEditing={isAnnotationMode}\n              isSelected={annotation.id === selectedAnnotationId}\n              isEditingText={annotation.id === selectedAnnotationId && isEditingAnnotationText}\n              onSelect={isEditingText => handleSelectAnnotation(annotation.id, isEditingText)}\n              onChangeText={(text, editorState) =>\n                handleChangeText(annotation.id, text, editorState)\n              }\n              onUpdateAnnotation={config => onUpdateAnnotation(annotation.id, config)}\n            />\n          ))}\n        </AnnotationTextContainer>\n      </DndContext>\n    </AnnotationOverlayContainer>\n  );\n};\n\nexport default AnnotationOverlay;\n"],"mappings":";;;;;;AAAA;AACA;;AAEA,OAAOA,KAAK,IAAOC,WAAW,EAAEC,OAAO,QAAO,OAAO;AACrD,OAAOC,MAAM,MAAM,mBAAmB;AACtC,SACEC,UAAU,EAIVC,aAAa,EACbC,SAAS,EACTC,UAAU,QACL,eAAe;AAGtB,OAAOC,cAAc,MAAM,mBAAmB;AAC9C,OAAOC,cAAc,MAAM,mBAAmB;AAC9C,SAEEC,qBAAqB,EACrBC,SAAS,EACTC,QAAQ,EACRC,YAAY,QACP,oBAAoB;AAE3B,IAAMC,0BAA0B,GAAGX,MAAM,CAACY,GAAG,CAAAC,eAAA,KAAAA,eAAA,GAAAC,sBAAA,sJAS5C;AAED,IAAMC,sBAAsB,GAAGf,MAAM,CAACgB,GAAG,CAAAC,gBAAA,KAAAA,gBAAA,GAAAH,sBAAA,iFAKxC;AAED,IAAMI,uBAAuB,GAAGlB,MAAM,CAACY,GAAG,CAAAO,gBAAA,KAAAA,gBAAA,GAAAL,sBAAA,iFAKzC;AAcD,IAAMM,iBAA6C,GAAG,SAAhDA,iBAA6CA,CAAAC,IAAA,EAU7C;EAAA,IATJC,WAAW,GAAAD,IAAA,CAAXC,WAAW;IACXC,oBAAoB,GAAAF,IAAA,CAApBE,oBAAoB;IACpBC,uBAAuB,GAAAH,IAAA,CAAvBG,uBAAuB;IACvBC,gBAAgB,GAAAJ,IAAA,CAAhBI,gBAAgB;IAChBC,QAAQ,GAAAL,IAAA,CAARK,QAAQ;IACRC,QAAQ,GAAAN,IAAA,CAARM,QAAQ;IACRC,cAAc,GAAAP,IAAA,CAAdO,cAAc;IACIC,mBAAkB,GAAAR,IAAA,CAApCS,gBAAgB;IACOC,uBAAuB,GAAAV,IAAA,CAA9CW,qBAAqB;EAErB,IAAMC,mBAAmB,GAAGlC,OAAO,CACjC;IAAA,OACEuB,WAAW,CACRY,MAAM,CACL,UAAAC,GAAG;MAAA,IAAAC,aAAA;MAAA,OACD,EAAAA,aAAA,GAACD,GAAG,CAACT,QAAQ,cAAAU,aAAA,cAAAA,aAAA,GAAI,CAAC,MAAMV,QAAQ,IAChCS,GAAG,CAACE,SAAS;MACb;MACC,CAACT,cAAc,IAAIrB,qBAAqB,CAAC4B,GAAG,CAACG,WAAW,EAAEX,QAAQ,CAAC,CAAC;IAAA,CACzE,CAAC,CACAY,OAAO,CAAC,CAAC;EAAA,GACd,CAACjB,WAAW,EAAEI,QAAQ,EAAEE,cAAc,EAAED,QAAQ,CAClD,CAAC;EAED,IAAMa,oBAAoB,GAAG3C,KAAK,CAAC4C,MAAM,CAAoB,IAAI,CAAC;EAElE,IAAMC,OAAO,GAAGtC,UAAU,CACxBD,SAAS,CAACD,aAAa,EAAE;IACvByC,oBAAoB,EAAE;MAACC,QAAQ,EAAE;IAAC;EACpC,CAAC,CACH,CAAC;EAED,IAAMC,aAAa,GAAG9C,OAAO,CAC3B;IAAA,OAAA+C,aAAA;MACEC,aAAa,EAAE;QACbC,WAAW,WAAXA,WAAWA,CAAA,EAAG;UACZ,OAAO,EAAE;QACX,CAAC;QACDC,UAAU,WAAVA,UAAUA,CAAA,EAAG;UACX,OAAO,EAAE;QACX,CAAC;QACDC,SAAS,WAATA,SAASA,CAAA,EAAG;UACV,OAAO,EAAE;QACX,CAAC;QACDC,YAAY,WAAZA,YAAYA,CAAA,EAAG;UACb,OAAO,EAAE;QACX;MACF,CAAC;MACDC,wBAAwB,EAAE;QAACC,SAAS,EAAE;MAAE;IAAC,GACrC,OAAOC,QAAQ,KAAK,WAAW,GAAG;MAACC,SAAS,EAAED,QAAQ,CAACE;IAAI,CAAC,GAAG,CAAC,CAAC;EAAA,CACrE,EACF,EACF,CAAC;EAED,IAAMC,eAAe,GAAG3D,WAAW,CACjC,UAAC4D,EAAkB,EAAK;IAAA,IAAAC,iBAAA;IACtB,IAAMC,KAAK,GAAG,GAAAC,MAAA,CAAGH,EAAE,CAACI,MAAM,CAACC,EAAE,EAAGC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC7C,IAAM7B,GAAG,IAAAwB,iBAAA,GAAGrC,WAAW,CAAC2C,IAAI,CAAC,UAAAC,CAAC;MAAA,OAAIA,CAAC,CAACH,EAAE,KAAKH,KAAK;IAAA,EAAC,cAAAD,iBAAA,cAAAA,iBAAA,GAAI,IAAI;IACzDnB,oBAAoB,CAAC2B,OAAO,GAAGhC,GAAG;IAClC,IAAIA,GAAG,EAAE;MACPJ,uBAAuB,CAACI,GAAG,CAAC4B,EAAE,EAAE,KAAK,CAAC;IACxC;EACF,CAAC,EACD,CAACzC,WAAW,EAAES,uBAAuB,CACvC,CAAC;EAED,IAAMqC,cAAc,GAAGtE,WAAW,CAChC,UAAC4D,EAAiB,EAAK;IACrB,IAAAW,MAAA,GAA4B,GAAAR,MAAA,CAAGH,EAAE,CAACI,MAAM,CAACC,EAAE,EAAGC,KAAK,CAAC,GAAG,CAAC;MAAAM,OAAA,GAAAC,cAAA,CAAAF,MAAA;MAAjDT,KAAK,GAAAU,OAAA;MAAEE,UAAU,GAAAF,OAAA;IACxB,IAAMG,UAAU,GAAGjC,oBAAoB,CAAC2B,OAAO;IAC/C,IAAI,CAACM,UAAU,IAAIA,UAAU,CAACV,EAAE,KAAKH,KAAK,EAAE;IAE5C,IAAIc,OAA4B,GAAG,CAAC,CAAC;IACrC,QAAQF,UAAU;MAChB,KAAK,YAAY;QACfE,OAAO,GAAGlE,SAAS,CAACiE,UAAU,EAAEf,EAAE,CAACiB,KAAK,EAAEhD,QAAQ,CAAC;QACnD;MACF,KAAK,WAAW;QACd+C,OAAO,GAAGjE,QAAQ,CAACgE,UAAU,EAAEf,EAAE,CAACiB,KAAK,EAAEhD,QAAQ,CAAC;QAClD;MACF,KAAK,QAAQ;QACX+C,OAAO,GAAGhE,YAAY,CAAC+D,UAAU,EAAEf,EAAE,CAACiB,KAAK,EAAEhD,QAAQ,CAAC;QACtD;IACJ;IACA,IAAIiD,MAAM,CAACC,IAAI,CAACH,OAAO,CAAC,CAACI,MAAM,GAAG,CAAC,EAAE;MACnCjD,mBAAkB,CAAC+B,KAAK,EAAEc,OAAO,CAAC;IACpC;EACF,CAAC,EACD,CAAC/C,QAAQ,EAAEE,mBAAkB,CAC/B,CAAC;EAED,IAAMkD,aAAa,GAAGjF,WAAW,CAAC,UAACkF,GAAiB,EAAK;IACvDxC,oBAAoB,CAAC2B,OAAO,GAAG,IAAI;EACrC,CAAC,EAAE,EAAE,CAAC;EAEN,IAAMc,sBAAsB,GAAGnF,WAAW,CACxC,UAACiE,EAAU,EAAEmB,aAAsB,EAAK;IACtCnD,uBAAuB,CAACgC,EAAE,EAAEmB,aAAa,CAAC;EAC5C,CAAC,EACD,CAACnD,uBAAuB,CAC1B,CAAC;EAED,IAAMoD,gBAAgB,GAAGrF,WAAW,CAClC,UAACiE,EAAU,EAAEqB,IAAY,EAAEC,WAAiC,EAAK;IAC/DxD,mBAAkB,CAACkC,EAAE,EAAAjB,aAAA;MAAGwC,KAAK,EAAEF;IAAI,GAAMC,WAAW,GAAG;MAACA,WAAW,EAAXA;IAAW,CAAC,GAAG,CAAC,CAAC,CAAE,CAAC;EAC9E,CAAC,EACD,CAACxD,mBAAkB,CACrB,CAAC;EAED,IAAI,CAACI,mBAAmB,CAAC6C,MAAM,EAAE;IAC/B,OAAO,IAAI;EACb;EAEA,IAAOS,KAAK,GAAY5D,QAAQ,CAAzB4D,KAAK;IAAEC,MAAM,GAAI7D,QAAQ,CAAlB6D,MAAM;EAEpB,oBACE3F,KAAA,CAAA4F,aAAA,CAAC9E,0BAA0B,qBACzBd,KAAA,CAAA4F,aAAA,CAACxF,UAAU;IACTyC,OAAO,EAAEA,OAAQ;IACjBG,aAAa,EAAEA,aAAc;IAC7BG,WAAW,EAAES,eAAgB;IAC7BiC,UAAU,EAAEtB,cAAe;IAC3BlB,SAAS,EAAE6B;EAAc,gBAEzBlF,KAAA,CAAA4F,aAAA,CAAC1E,sBAAsB;IAACwE,KAAK,EAAEA,KAAM;IAACC,MAAM,EAAEA;EAAO,GAClDvD,mBAAmB,CAAC0D,GAAG,CAAC,UAAAC,UAAU;IAAA,oBACjC/F,KAAA,CAAA4F,aAAA,CAACpF,cAAc;MACbwF,GAAG,EAAED,UAAU,CAAC7B,EAAG;MACnB6B,UAAU,EAAEA,UAAW;MACvBjE,QAAQ,EAAEA,QAAS;MACnBmE,SAAS,EAAErE,gBAAiB;MAC5BsE,UAAU,EAAEH,UAAU,CAAC7B,EAAE,KAAKxC;IAAqB,CACpD,CAAC;EAAA,CACH,CACqB,CAAC,eACzB1B,KAAA,CAAA4F,aAAA,CAACvE,uBAAuB;IAAC8E,KAAK,EAAE;MAACT,KAAK,EAALA,KAAK;MAAEC,MAAM,EAANA;IAAM;EAAE,GAC7CvD,mBAAmB,CAAC0D,GAAG,CAAC,UAAAC,UAAU;IAAA,oBACjC/F,KAAA,CAAA4F,aAAA,CAACnF,cAAc;MACbuF,GAAG,EAAED,UAAU,CAAC7B,EAAG;MACnB6B,UAAU,EAAEA,UAAW;MACvBjE,QAAQ,EAAEA,QAAS;MACnBmE,SAAS,EAAErE,gBAAiB;MAC5BsE,UAAU,EAAEH,UAAU,CAAC7B,EAAE,KAAKxC,oBAAqB;MACnD2D,aAAa,EAAEU,UAAU,CAAC7B,EAAE,KAAKxC,oBAAoB,IAAIC,uBAAwB;MACjFyE,QAAQ,EAAE,SAAVA,QAAQA,CAAEf,aAAa;QAAA,OAAID,sBAAsB,CAACW,UAAU,CAAC7B,EAAE,EAAEmB,aAAa,CAAC;MAAA,CAAC;MAChFgB,YAAY,EAAE,SAAdA,YAAYA,CAAGd,IAAI,EAAEC,WAAW;QAAA,OAC9BF,gBAAgB,CAACS,UAAU,CAAC7B,EAAE,EAAEqB,IAAI,EAAEC,WAAW,CAAC;MAAA,CACnD;MACDxD,kBAAkB,EAAE,SAApBA,kBAAkBA,CAAEsE,MAAM;QAAA,OAAItE,mBAAkB,CAAC+D,UAAU,CAAC7B,EAAE,EAAEoC,MAAM,CAAC;MAAA;IAAC,CACzE,CAAC;EAAA,CACH,CACsB,CACf,CACc,CAAC;AAEjC,CAAC;AAED,eAAe/E,iBAAiB","ignoreList":[]}