@kepler.gl/components 3.3.0-alpha.0 → 3.3.0-alpha.10

package/dist/cjs/hooks/use-legend-position.js

@@ -0,0 +1,176 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useLegendPosition;
+exports.useCalcLegendPosition = useCalcLegendPosition;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = require("react");
+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) { (0, _defineProperty2["default"])(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
+var MARGIN = {
+  left: 10,
+  top: 10,
+  right: 10,
+  bottom: 30
+};
+var DEFAULT_POSITION = {
+  x: MARGIN.right,
+  y: MARGIN.bottom,
+  anchorX: 'right',
+  anchorY: 'bottom'
+};
+var MIN_CONTENT_HEIGHT = 100;
+var MAP_CONTROL_HEADER_FULL_HEIGHT = 34;
+function useCalcLegendPosition(_ref) {
+  var legendContentRef = _ref.legendContentRef,
+    isSidePanelShown = _ref.isSidePanelShown,
+    sidePanelWidth = _ref.sidePanelWidth;
+  return (0, _react.useCallback)(function () {
+    var _legendContentRef$cur;
+    var root = (_legendContentRef$cur = legendContentRef.current) === null || _legendContentRef$cur === void 0 ? void 0 : _legendContentRef$cur.closest('.kepler-gl');
+    var legendContent = legendContentRef.current;
+    if (!legendContent || !(root instanceof HTMLElement)) {
+      return DEFAULT_POSITION;
+    }
+    var legendRect = legendContent.getBoundingClientRect();
+    var mapRootBounds = root.getBoundingClientRect();
+    var leftSidebarOffset = isSidePanelShown ? sidePanelWidth : 0;
+    var leftOffset = Math.max(MARGIN.left, legendRect.left - mapRootBounds.left - leftSidebarOffset);
+    var rightOffset = Math.max(MARGIN.right, mapRootBounds.right - legendRect.right);
+    var topOffset = Math.max(MARGIN.top, legendRect.top - mapRootBounds.top);
+    var bottomOffset = Math.max(MARGIN.bottom, mapRootBounds.bottom - legendRect.bottom);
+    return _objectSpread(_objectSpread({}, leftOffset < rightOffset ? {
+      x: leftOffset + leftSidebarOffset,
+      anchorX: 'left'
+    } : {
+      x: rightOffset,
+      anchorX: 'right'
+    }), topOffset < bottomOffset ? {
+      y: topOffset,
+      anchorY: 'top'
+    } : {
+      y: bottomOffset,
+      anchorY: 'bottom'
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isSidePanelShown, sidePanelWidth]);
+}
+
+/**
+ * Returns a function that calculates the anchored position of the map legend
+ * that is being dragged.
+ */
+function useLegendPosition(_ref2) {
+  var _settings$position, _settings$contentHeig, _theme$sidePanel;
+  var legendContentRef = _ref2.legendContentRef,
+    isSidePanelShown = _ref2.isSidePanelShown,
+    settings = _ref2.settings,
+    onChangeSettings = _ref2.onChangeSettings,
+    theme = _ref2.theme,
+    mapHeight = _ref2.mapHeight,
+    mapWidth = _ref2.mapWidth;
+  var pos = (_settings$position = settings === null || settings === void 0 ? void 0 : settings.position) !== null && _settings$position !== void 0 ? _settings$position : DEFAULT_POSITION;
+  var contentHeight = (_settings$contentHeig = settings === null || settings === void 0 ? void 0 : settings.contentHeight) !== null && _settings$contentHeig !== void 0 ? _settings$contentHeig : -1;
+  var positionStyles = (0, _react.useMemo)(function () {
+    return (0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, pos.anchorX, pos.x), pos.anchorY, pos.y);
+  }, [pos]);
+  var startHeightRef = (0, _react.useRef)(0);
+  var sidePanelWidth = ((_theme$sidePanel = theme.sidePanel) === null || _theme$sidePanel === void 0 ? void 0 : _theme$sidePanel.width) || 0;
+
+  // Calculate dynamic max content height based on map root dimensions
+  var maxContentHeight = (0, _react.useMemo)(function () {
+    if (!mapHeight) return undefined;
+    // Available height minus margins and header
+    return mapHeight - MARGIN.top - MARGIN.bottom - MAP_CONTROL_HEADER_FULL_HEIGHT;
+  }, [mapHeight]);
+  var calcPosition = useCalcLegendPosition({
+    legendContentRef: legendContentRef,
+    isSidePanelShown: isSidePanelShown,
+    sidePanelWidth: sidePanelWidth
+  });
+  var updatePosition = (0, _react.useCallback)(function () {
+    return onChangeSettings({
+      position: calcPosition()
+    });
+  }, [calcPosition, onChangeSettings]);
+  var startResize = (0, _react.useCallback)(function () {
+    var _legendContentRef$cur2;
+    var content = (_legendContentRef$cur2 = legendContentRef.current) === null || _legendContentRef$cur2 === void 0 ? void 0 : _legendContentRef$cur2.querySelector('.map-control__panel-content');
+    if (content instanceof HTMLElement) {
+      startHeightRef.current = content.offsetHeight;
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  var resize = (0, _react.useCallback)(function (deltaY) {
+    var _legendContentRef$cur3;
+    var root = (_legendContentRef$cur3 = legendContentRef.current) === null || _legendContentRef$cur3 === void 0 ? void 0 : _legendContentRef$cur3.closest('.kepler-gl');
+    var legendContent = legendContentRef.current;
+    if (root instanceof HTMLElement && legendContent) {
+      var mapRootBounds = root.getBoundingClientRect();
+      var legendRect = legendContent.getBoundingClientRect();
+      var remainingHeight = mapRootBounds.bottom - (legendRect.top + MAP_CONTROL_HEADER_FULL_HEIGHT + MARGIN.bottom);
+      // Use maxContentHeight if available, otherwise fall back to viewport-based calculation
+      var maxHeight = maxContentHeight ? Math.min(maxContentHeight, remainingHeight) : remainingHeight;
+      var nextHeight = Math.min(maxHeight, Math.max(MIN_CONTENT_HEIGHT, startHeightRef.current + deltaY));
+      onChangeSettings({
+        contentHeight: nextHeight
+      });
+      if (contentHeight > 0 && pos.anchorY === 'bottom') {
+        onChangeSettings({
+          position: _objectSpread(_objectSpread({}, pos), {}, {
+            y: pos.y - (nextHeight - contentHeight)
+          })
+        });
+      }
+    }
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [contentHeight, pos, onChangeSettings, maxContentHeight]);
+
+  // Shift when side panel is shown/hidden
+  var posRef = (0, _react.useRef)(pos);
+  posRef.current = pos;
+  (0, _react.useEffect)(function () {
+    var currentPos = posRef.current;
+    if (currentPos.anchorX === 'left') {
+      if (isSidePanelShown) {
+        if (currentPos.x <= sidePanelWidth + MARGIN.left) {
+          onChangeSettings({
+            position: _objectSpread(_objectSpread({}, currentPos), {}, {
+              x: sidePanelWidth + MARGIN.left
+            })
+          });
+        }
+      } else {
+        onChangeSettings({
+          position: _objectSpread(_objectSpread({}, currentPos), {}, {
+            x: Math.max(MARGIN.left, currentPos.x - sidePanelWidth)
+          })
+        });
+      }
+    }
+  }, [isSidePanelShown, onChangeSettings, sidePanelWidth]);
+
+  // Clamp contentHeight when map resizes to ensure legend stays within available space
+  (0, _react.useEffect)(function () {
+    if (!mapWidth || !mapHeight || !legendContentRef.current) return;
+    if (maxContentHeight && contentHeight > 0 && contentHeight > maxContentHeight) {
+      onChangeSettings({
+        contentHeight: maxContentHeight
+      });
+    }
+  }, [mapWidth, mapHeight, contentHeight, onChangeSettings, maxContentHeight, legendContentRef]);
+  return {
+    positionStyles: positionStyles,
+    updatePosition: updatePosition,
+    contentHeight: contentHeight,
+    maxContentHeight: maxContentHeight,
+    startResize: startResize,
+    resize: resize
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","require","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","MARGIN","left","top","right","bottom","DEFAULT_POSITION","x","y","anchorX","anchorY","MIN_CONTENT_HEIGHT","MAP_CONTROL_HEADER_FULL_HEIGHT","useCalcLegendPosition","_ref","legendContentRef","isSidePanelShown","sidePanelWidth","useCallback","_legendContentRef$cur","root","current","closest","legendContent","HTMLElement","legendRect","getBoundingClientRect","mapRootBounds","leftSidebarOffset","leftOffset","Math","max","rightOffset","topOffset","bottomOffset","useLegendPosition","_ref2","_settings$position","_settings$contentHeig","_theme$sidePanel","settings","onChangeSettings","theme","mapHeight","mapWidth","pos","position","contentHeight","positionStyles","useMemo","startHeightRef","useRef","sidePanel","width","maxContentHeight","undefined","calcPosition","updatePosition","startResize","_legendContentRef$cur2","content","querySelector","offsetHeight","resize","deltaY","_legendContentRef$cur3","remainingHeight","maxHeight","min","nextHeight","posRef","useEffect","currentPos"],"sources":["../../../src/hooks/use-legend-position.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {useMemo, useRef, useCallback, useEffect} from 'react';\n\nimport {MapLegendControlSettings} from '@kepler.gl/types';\n\ntype Params = {\n  legendContentRef: React.MutableRefObject<HTMLElement | null>;\n  isSidePanelShown: boolean;\n  settings?: MapLegendControlSettings;\n  onChangeSettings: (settings: Partial<MapLegendControlSettings>) => void;\n  theme: Record<string, any>;\n  mapHeight?: number;\n  mapWidth?: number;\n};\n\ntype ReturnType = {\n  positionStyles: Record<string, unknown>;\n  updatePosition: () => void;\n  contentHeight: number;\n  maxContentHeight?: number;\n  startResize: () => void;\n  resize: (deltaY: number) => void;\n};\n\nconst MARGIN = {\n  left: 10,\n  top: 10,\n  right: 10,\n  bottom: 30\n};\nconst DEFAULT_POSITION: MapLegendControlSettings['position'] = {\n  x: MARGIN.right,\n  y: MARGIN.bottom,\n  anchorX: 'right',\n  anchorY: 'bottom'\n};\nconst MIN_CONTENT_HEIGHT = 100;\nconst MAP_CONTROL_HEADER_FULL_HEIGHT = 34;\n\nexport type UseCalcLegendPositionProps = {\n  legendContentRef: React.MutableRefObject<HTMLElement | null>;\n  isSidePanelShown: boolean;\n  sidePanelWidth: number;\n};\n\nexport function useCalcLegendPosition({\n  legendContentRef,\n  isSidePanelShown,\n  sidePanelWidth\n}: UseCalcLegendPositionProps) {\n  return useCallback((): MapLegendControlSettings['position'] => {\n    const root = legendContentRef.current?.closest('.kepler-gl');\n    const legendContent = legendContentRef.current;\n    if (!legendContent || !(root instanceof HTMLElement)) {\n      return DEFAULT_POSITION;\n    }\n    const legendRect = legendContent.getBoundingClientRect();\n    const mapRootBounds = root.getBoundingClientRect();\n    const leftSidebarOffset = isSidePanelShown ? sidePanelWidth : 0;\n\n    const leftOffset = Math.max(\n      MARGIN.left,\n      legendRect.left - mapRootBounds.left - leftSidebarOffset\n    );\n    const rightOffset = Math.max(MARGIN.right, mapRootBounds.right - legendRect.right);\n\n    const topOffset = Math.max(MARGIN.top, legendRect.top - mapRootBounds.top);\n    const bottomOffset = Math.max(MARGIN.bottom, mapRootBounds.bottom - legendRect.bottom);\n\n    return {\n      ...(leftOffset < rightOffset\n        ? {x: leftOffset + leftSidebarOffset, anchorX: 'left'}\n        : {x: rightOffset, anchorX: 'right'}),\n      ...(topOffset < bottomOffset\n        ? {y: topOffset, anchorY: 'top'}\n        : {y: bottomOffset, anchorY: 'bottom'})\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [isSidePanelShown, sidePanelWidth]);\n}\n\n/**\n * Returns a function that calculates the anchored position of the map legend\n * that is being dragged.\n */\nexport default function useLegendPosition({\n  legendContentRef,\n  isSidePanelShown,\n  settings,\n  onChangeSettings,\n  theme,\n  mapHeight,\n  mapWidth\n}: Params): ReturnType {\n  const pos = settings?.position ?? DEFAULT_POSITION;\n  const contentHeight = settings?.contentHeight ?? -1;\n  const positionStyles = useMemo(() => ({[pos.anchorX]: pos.x, [pos.anchorY]: pos.y}), [pos]);\n  const startHeightRef = useRef(0);\n  const sidePanelWidth = theme.sidePanel?.width || 0;\n\n  // Calculate dynamic max content height based on map root dimensions\n  const maxContentHeight = useMemo(() => {\n    if (!mapHeight) return undefined;\n    // Available height minus margins and header\n    return mapHeight - MARGIN.top - MARGIN.bottom - MAP_CONTROL_HEADER_FULL_HEIGHT;\n  }, [mapHeight]);\n\n  const calcPosition = useCalcLegendPosition({\n    legendContentRef,\n    isSidePanelShown,\n    sidePanelWidth\n  });\n  const updatePosition = useCallback(\n    () => onChangeSettings({position: calcPosition()}),\n    [calcPosition, onChangeSettings]\n  );\n\n  const startResize = useCallback(() => {\n    const content = legendContentRef.current?.querySelector('.map-control__panel-content');\n    if (content instanceof HTMLElement) {\n      startHeightRef.current = content.offsetHeight;\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  const resize = useCallback(\n    deltaY => {\n      const root = legendContentRef.current?.closest('.kepler-gl');\n      const legendContent = legendContentRef.current;\n      if (root instanceof HTMLElement && legendContent) {\n        const mapRootBounds = root.getBoundingClientRect();\n        const legendRect = legendContent.getBoundingClientRect();\n        const remainingHeight =\n          mapRootBounds.bottom - (legendRect.top + MAP_CONTROL_HEADER_FULL_HEIGHT + MARGIN.bottom);\n        // Use maxContentHeight if available, otherwise fall back to viewport-based calculation\n        const maxHeight = maxContentHeight\n          ? Math.min(maxContentHeight, remainingHeight)\n          : remainingHeight;\n        const nextHeight = Math.min(\n          maxHeight,\n          Math.max(MIN_CONTENT_HEIGHT, startHeightRef.current + deltaY)\n        );\n        onChangeSettings({contentHeight: nextHeight});\n        if (contentHeight > 0 && pos.anchorY === 'bottom') {\n          onChangeSettings({position: {...pos, y: pos.y - (nextHeight - contentHeight)}});\n        }\n      }\n    },\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [contentHeight, pos, onChangeSettings, maxContentHeight]\n  );\n\n  // Shift when side panel is shown/hidden\n  const posRef = useRef(pos);\n  posRef.current = pos;\n  useEffect(() => {\n    const currentPos = posRef.current;\n    if (currentPos.anchorX === 'left') {\n      if (isSidePanelShown) {\n        if (currentPos.x <= sidePanelWidth + MARGIN.left) {\n          onChangeSettings({position: {...currentPos, x: sidePanelWidth + MARGIN.left}});\n        }\n      } else {\n        onChangeSettings({\n          position: {...currentPos, x: Math.max(MARGIN.left, currentPos.x - sidePanelWidth)}\n        });\n      }\n    }\n  }, [isSidePanelShown, onChangeSettings, sidePanelWidth]);\n\n  // Clamp contentHeight when map resizes to ensure legend stays within available space\n  useEffect(() => {\n    if (!mapWidth || !mapHeight || !legendContentRef.current) return;\n    if (maxContentHeight && contentHeight > 0 && contentHeight > maxContentHeight) {\n      onChangeSettings({contentHeight: maxContentHeight});\n    }\n  }, [mapWidth, mapHeight, contentHeight, onChangeSettings, maxContentHeight, legendContentRef]);\n\n  return {positionStyles, updatePosition, contentHeight, maxContentHeight, startResize, resize};\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/hooks/use-on-click-outside.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useOnClickOutside;
+var _document = _interopRequireDefault(require("global/document"));
+var _react = require("react");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+function useOnClickOutside(onClose) {
+  var disabled = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  var containerRef = (0, _react.useRef)(null);
+  var handleClickOutside = (0, _react.useCallback)(function (e) {
+    if (containerRef.current && !containerRef.current.contains(e.target)) {
+      onClose(e);
+    }
+  }, [onClose]);
+  (0, _react.useEffect)(function () {
+    if (disabled) {
+      return;
+    }
+    _document["default"].addEventListener('click', handleClickOutside, {
+      capture: true
+    });
+    return function () {
+      _document["default"].removeEventListener('click', handleClickOutside, {
+        capture: true
+      });
+    };
+  }, [handleClickOutside, disabled]);
+  return containerRef;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfZG9jdW1lbnQiLCJfaW50ZXJvcFJlcXVpcmVEZWZhdWx0IiwicmVxdWlyZSIsIl9yZWFjdCIsInVzZU9uQ2xpY2tPdXRzaWRlIiwib25DbG9zZSIsImRpc2FibGVkIiwiYXJndW1lbnRzIiwibGVuZ3RoIiwidW5kZWZpbmVkIiwiY29udGFpbmVyUmVmIiwidXNlUmVmIiwiaGFuZGxlQ2xpY2tPdXRzaWRlIiwidXNlQ2FsbGJhY2siLCJlIiwiY3VycmVudCIsImNvbnRhaW5zIiwidGFyZ2V0IiwidXNlRWZmZWN0IiwiZG9jdW1lbnQiLCJhZGRFdmVudExpc3RlbmVyIiwiY2FwdHVyZSIsInJlbW92ZUV2ZW50TGlzdGVuZXIiXSwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaG9va3MvdXNlLW9uLWNsaWNrLW91dHNpZGUudHN4Il0sInNvdXJjZXNDb250ZW50IjpbIi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVRcbi8vIENvcHlyaWdodCBjb250cmlidXRvcnMgdG8gdGhlIGtlcGxlci5nbCBwcm9qZWN0XG5cbmltcG9ydCBkb2N1bWVudCBmcm9tICdnbG9iYWwvZG9jdW1lbnQnO1xuaW1wb3J0IHt1c2VDYWxsYmFjaywgdXNlRWZmZWN0LCB1c2VSZWYsIE11dGFibGVSZWZPYmplY3R9IGZyb20gJ3JlYWN0JztcbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIHVzZU9uQ2xpY2tPdXRzaWRlPFQgZXh0ZW5kcyBIVE1MRWxlbWVudD4oXG4gIG9uQ2xvc2U6IChlKSA9PiB2b2lkLFxuICBkaXNhYmxlZCA9IGZhbHNlXG4pOiBNdXRhYmxlUmVmT2JqZWN0PFQgfCBudWxsPiB7XG4gIGNvbnN0IGNvbnRhaW5lclJlZiA9IHVzZVJlZjxUPihudWxsKTtcbiAgY29uc3QgaGFuZGxlQ2xpY2tPdXRzaWRlID0gdXNlQ2FsbGJhY2soXG4gICAgZSA9PiB7XG4gICAgICBpZiAoY29udGFpbmVyUmVmLmN1cnJlbnQgJiYgIWNvbnRhaW5lclJlZi5jdXJyZW50LmNvbnRhaW5zKGUudGFyZ2V0KSkge1xuICAgICAgICBvbkNsb3NlKGUpO1xuICAgICAgfVxuICAgIH0sXG4gICAgW29uQ2xvc2VdXG4gICk7XG5cbiAgdXNlRWZmZWN0KCgpID0+IHtcbiAgICBpZiAoZGlzYWJsZWQpIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBkb2N1bWVudC5hZGRFdmVudExpc3RlbmVyKCdjbGljaycsIGhhbmRsZUNsaWNrT3V0c2lkZSwge2NhcHR1cmU6IHRydWV9KTtcblxuICAgIHJldHVybiAoKSA9PiB7XG4gICAgICBkb2N1bWVudC5yZW1vdmVFdmVudExpc3RlbmVyKCdjbGljaycsIGhhbmRsZUNsaWNrT3V0c2lkZSwge2NhcHR1cmU6IHRydWV9KTtcbiAgICB9O1xuICB9LCBbaGFuZGxlQ2xpY2tPdXRzaWRlLCBkaXNhYmxlZF0pO1xuXG4gIHJldHVybiBjb250YWluZXJSZWY7XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFHQSxJQUFBQSxTQUFBLEdBQUFDLHNCQUFBLENBQUFDLE9BQUE7QUFDQSxJQUFBQyxNQUFBLEdBQUFELE9BQUE7QUFKQTtBQUNBOztBQUllLFNBQVNFLGlCQUFpQkEsQ0FDdkNDLE9BQW9CLEVBRVE7RUFBQSxJQUQ1QkMsUUFBUSxHQUFBQyxTQUFBLENBQUFDLE1BQUEsUUFBQUQsU0FBQSxRQUFBRSxTQUFBLEdBQUFGLFNBQUEsTUFBRyxLQUFLO0VBRWhCLElBQU1HLFlBQVksR0FBRyxJQUFBQyxhQUFNLEVBQUksSUFBSSxDQUFDO0VBQ3BDLElBQU1DLGtCQUFrQixHQUFHLElBQUFDLGtCQUFXLEVBQ3BDLFVBQUFDLENBQUMsRUFBSTtJQUNILElBQUlKLFlBQVksQ0FBQ0ssT0FBTyxJQUFJLENBQUNMLFlBQVksQ0FBQ0ssT0FBTyxDQUFDQyxRQUFRLENBQUNGLENBQUMsQ0FBQ0csTUFBTSxDQUFDLEVBQUU7TUFDcEVaLE9BQU8sQ0FBQ1MsQ0FBQyxDQUFDO0lBQ1o7RUFDRixDQUFDLEVBQ0QsQ0FBQ1QsT0FBTyxDQUNWLENBQUM7RUFFRCxJQUFBYSxnQkFBUyxFQUFDLFlBQU07SUFDZCxJQUFJWixRQUFRLEVBQUU7TUFDWjtJQUNGO0lBRUFhLG9CQUFRLENBQUNDLGdCQUFnQixDQUFDLE9BQU8sRUFBRVIsa0JBQWtCLEVBQUU7TUFBQ1MsT0FBTyxFQUFFO0lBQUksQ0FBQyxDQUFDO0lBRXZFLE9BQU8sWUFBTTtNQUNYRixvQkFBUSxDQUFDRyxtQkFBbUIsQ0FBQyxPQUFPLEVBQUVWLGtCQUFrQixFQUFFO1FBQUNTLE9BQU8sRUFBRTtNQUFJLENBQUMsQ0FBQztJQUM1RSxDQUFDO0VBQ0gsQ0FBQyxFQUFFLENBQUNULGtCQUFrQixFQUFFTixRQUFRLENBQUMsQ0FBQztFQUVsQyxPQUFPSSxZQUFZO0FBQ3JCIiwiaWdub3JlTGlzdCI6W119