@spaziodati/atoka-design-system 2.0.72-beta

package/Map/index.js

@@ -0,0 +1,4810 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("@fortawesome/pro-light-svg-icons/faEmptySet"), require("@fortawesome/react-fontawesome"), require("classnames"), require("leaflet"), require("leaflet-image"), require("react"), require("react-bootstrap/Form"), require("react-bootstrap/FormControl"), require("react-bootstrap/FormText"), require("react-bootstrap/OverlayTrigger"), require("react-bootstrap/Tooltip"), require("react-dom"));
+	else if(typeof define === 'function' && define.amd)
+		define("atoka-design-system", ["@fortawesome/pro-light-svg-icons/faEmptySet", "@fortawesome/react-fontawesome", "classnames", "leaflet", "leaflet-image", "react", "react-bootstrap/Form", "react-bootstrap/FormControl", "react-bootstrap/FormText", "react-bootstrap/OverlayTrigger", "react-bootstrap/Tooltip", "react-dom"], factory);
+	else if(typeof exports === 'object')
+		exports["atoka-design-system"] = factory(require("@fortawesome/pro-light-svg-icons/faEmptySet"), require("@fortawesome/react-fontawesome"), require("classnames"), require("leaflet"), require("leaflet-image"), require("react"), require("react-bootstrap/Form"), require("react-bootstrap/FormControl"), require("react-bootstrap/FormText"), require("react-bootstrap/OverlayTrigger"), require("react-bootstrap/Tooltip"), require("react-dom"));
+	else
+		root["atoka-design-system"] = factory(root["@fortawesome/pro-light-svg-icons/faEmptySet"], root["@fortawesome/react-fontawesome"], root["classnames"], root["leaflet"], root["leaflet-image"], root["react"], root["react-bootstrap/Form"], root["react-bootstrap/FormControl"], root["react-bootstrap/FormText"], root["react-bootstrap/OverlayTrigger"], root["react-bootstrap/Tooltip"], root["react-dom"]);
+})(self, function(__WEBPACK_EXTERNAL_MODULE__3402__, __WEBPACK_EXTERNAL_MODULE__5692__, __WEBPACK_EXTERNAL_MODULE__8310__, __WEBPACK_EXTERNAL_MODULE__4159__, __WEBPACK_EXTERNAL_MODULE__855__, __WEBPACK_EXTERNAL_MODULE__8156__, __WEBPACK_EXTERNAL_MODULE__8721__, __WEBPACK_EXTERNAL_MODULE__1082__, __WEBPACK_EXTERNAL_MODULE__8763__, __WEBPACK_EXTERNAL_MODULE__6043__, __WEBPACK_EXTERNAL_MODULE__8053__, __WEBPACK_EXTERNAL_MODULE__7111__) {
+return /******/ (() => { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 5385:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "EmptyState": () => (/* reexport */ EmptyState)
+});
+
+// EXTERNAL MODULE: external "react"
+var external_react_ = __webpack_require__(8156);
+var external_react_default = /*#__PURE__*/__webpack_require__.n(external_react_);
+// EXTERNAL MODULE: external "@fortawesome/react-fontawesome"
+var react_fontawesome_ = __webpack_require__(5692);
+// EXTERNAL MODULE: external "@fortawesome/pro-light-svg-icons/faEmptySet"
+var faEmptySet_ = __webpack_require__(3402);
+// EXTERNAL MODULE: external "classnames"
+var external_classnames_ = __webpack_require__(8310);
+var external_classnames_default = /*#__PURE__*/__webpack_require__.n(external_classnames_);
+;// CONCATENATED MODULE: ./src/components/EmptyState/EmptyState.tsx
+var __extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+
+
+
+
+
+/**
+ * ### Overview
+ *
+ * An empty state is a predominant element the user sees on a page where there is nothing to display.
+ */
+var EmptyState = /** @class */ (function (_super) {
+    __extends(EmptyState, _super);
+    function EmptyState() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    EmptyState.prototype.render = function () {
+        return (external_react_default().createElement("div", { className: external_classnames_default()('atoka-empty-state', this.props.className) },
+            external_react_default().createElement("div", { className: 'mb-2' },
+                external_react_default().createElement(react_fontawesome_.FontAwesomeIcon, { icon: faEmptySet_.faEmptySet })),
+            this.props.children));
+    };
+    EmptyState.displayName = 'EmptyState';
+    return EmptyState;
+}((external_react_default()).PureComponent));
+
+
+;// CONCATENATED MODULE: ./src/components/EmptyState/index.ts
+
+
+
+/***/ }),
+
+/***/ 9316:
+/***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
+
+"use strict";
+
+// UNUSED EXPORTS: Form
+
+// EXTERNAL MODULE: external "react"
+var external_react_ = __webpack_require__(8156);
+var external_react_default = /*#__PURE__*/__webpack_require__.n(external_react_);
+// EXTERNAL MODULE: external "classnames"
+var external_classnames_ = __webpack_require__(8310);
+var external_classnames_default = /*#__PURE__*/__webpack_require__.n(external_classnames_);
+// EXTERNAL MODULE: external "react-bootstrap/Form"
+var Form_ = __webpack_require__(8721);
+var Form_default = /*#__PURE__*/__webpack_require__.n(Form_);
+;// CONCATENATED MODULE: ./src/components/Form/FormLabel.tsx
+
+
+
+
+var FormLabel = external_react_default().memo(function (props) {
+    var className = external_classnames_default()(props === null || props === void 0 ? void 0 : props.className, 'atoka-form-label');
+    return external_react_default().createElement((Form_default()).Label, { className: className }, props.children);
+});
+FormLabel.displayName = 'FormLabel';
+
+// EXTERNAL MODULE: ./src/components/Form/FormControl.tsx + 1 modules
+var FormControl = __webpack_require__(3422);
+;// CONCATENATED MODULE: ./src/components/Form/FormCheckbox.tsx
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+
+
+
+var FormCheckbox = function (props) {
+    var _a;
+    var className = external_classnames_default()('atoka-form-checkbox', props === null || props === void 0 ? void 0 : props.className);
+    return external_react_default().createElement((Form_default()).Check, __assign({ type: 'checkbox' }, props, { custom: true, className: className, label: (_a = props.label) !== null && _a !== void 0 ? _a : '' }));
+};
+FormCheckbox.displayName = 'FormCheckbox';
+
+;// CONCATENATED MODULE: ./src/components/Form/FormRadio.tsx
+var FormRadio_assign = (undefined && undefined.__assign) || function () {
+    FormRadio_assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return FormRadio_assign.apply(this, arguments);
+};
+
+
+
+
+var FormRadio = function (props) {
+    var _a;
+    var className = external_classnames_default()(props === null || props === void 0 ? void 0 : props.className, 'atoka-form-radio');
+    return external_react_default().createElement((Form_default()).Check, FormRadio_assign({ type: 'radio' }, props, { custom: true, className: className, label: (_a = props.label) !== null && _a !== void 0 ? _a : '' }));
+};
+FormRadio.displayName = 'FormRadio';
+
+// EXTERNAL MODULE: external "react-bootstrap/FormText"
+var FormText_ = __webpack_require__(8763);
+var FormText_default = /*#__PURE__*/__webpack_require__.n(FormText_);
+;// CONCATENATED MODULE: ./src/components/Form/FormHelp.tsx
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+
+
+
+
+var FormHelp = external_react_default().memo(function (_a) {
+    var children = _a.children, props = __rest(_a, ["children"]);
+    var className = external_classnames_default()('d-block', props === null || props === void 0 ? void 0 : props.className);
+    return (external_react_default().createElement((FormText_default()), { bsPrefix: 'atoka-form-help', className: className }, children));
+});
+FormHelp.displayName = 'FormHelp';
+
+;// CONCATENATED MODULE: ./src/components/Form/Form.tsx
+var Form_assign = (undefined && undefined.__assign) || function () {
+    Form_assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return Form_assign.apply(this, arguments);
+};
+
+
+
+
+
+
+
+
+
+var Form = function (props) {
+    var className = external_classnames_default()(props === null || props === void 0 ? void 0 : props.className, 'atoka-form');
+    return (external_react_default().createElement((Form_default()), Form_assign({}, props, { className: className }), props.children));
+};
+Form.displayName = 'Form';
+Form.Control = FormControl/* FormControl */.N;
+Form.Label = FormLabel;
+Form.Checkbox = FormCheckbox;
+Form.Radio = FormRadio;
+Form.File = (Form_default()).File;
+Form.Switch = (Form_default()).Switch;
+Form.Help = FormHelp;
+Form.Group = (Form_default()).Group;
+
+
+
+/***/ }),
+
+/***/ 3422:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "N": () => (/* binding */ FormControl)
+});
+
+// EXTERNAL MODULE: external "react"
+var external_react_ = __webpack_require__(8156);
+var external_react_default = /*#__PURE__*/__webpack_require__.n(external_react_);
+// EXTERNAL MODULE: external "classnames"
+var external_classnames_ = __webpack_require__(8310);
+var external_classnames_default = /*#__PURE__*/__webpack_require__.n(external_classnames_);
+// EXTERNAL MODULE: external "react-bootstrap/FormControl"
+var FormControl_ = __webpack_require__(1082);
+var FormControl_default = /*#__PURE__*/__webpack_require__.n(FormControl_);
+;// CONCATENATED MODULE: ./src/components/Form/FormControlFeedBack.tsx
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+
+
+
+var FormControlFeedBack = external_react_default().memo(function (_a) {
+    var _b = _a.show, show = _b === void 0 ? true : _b, props = __rest(_a, ["show"]);
+    var className = external_classnames_default()(props === null || props === void 0 ? void 0 : props.className, 'atoka-form-control-feedback', {
+        'd-block': show,
+    });
+    return (external_react_default().createElement((FormControl_default()).Feedback, { type: props.type, className: className }, props.children));
+});
+FormControlFeedBack.displayName = ' FormControlFeedBack';
+
+;// CONCATENATED MODULE: ./src/components/Form/FormControl.tsx
+var FormControl_rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+
+
+
+
+
+var FormControlComponent = external_react_default().forwardRef(function (_a, ref) {
+    var _b = _a.size, size = _b === void 0 ? 'md' : _b, props = FormControl_rest(_a, ["size"]);
+    var className = external_classnames_default()('atoka-form-control', props === null || props === void 0 ? void 0 : props.className, {
+        'atoka-shadow': props.withShadow,
+        'disabled': props.disabled,
+    });
+    return (external_react_default().createElement((FormControl_default()), { as: props.as, rows: props.rows, cols: props.cols, placeholder: props.placeholder, className: className, disabled: props.disabled, readOnly: props.readOnly, value: props.value, onChange: props.onChange, onKeyPress: props.onKeyPress, onKeyDown: props.onKeyDown, defaultValue: props.defaultValue, size: size === 'md' ? undefined : size, type: props.type, id: props.id, isValid: props.isValid, isInvalid: props.isInvalid, ref: ref, autoComplete: 'off' }, props.children));
+});
+FormControlComponent.displayName = 'FormControlComponent';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+var FormControl = FormControlComponent;
+FormControl.FeedBack = FormControlFeedBack;
+FormControl.displayName = 'FormControl';
+
+
+
+/***/ }),
+
+/***/ 604:
+/***/ (() => {
+
+
+
+/***/ }),
+
+/***/ 69:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "Map": () => (/* reexport */ Map_Map),
+  "MapChoroplethProps": () => (/* reexport */ Types.MapChoroplethProps),
+  "MapData": () => (/* reexport */ Types.MapData),
+  "MapDataKind": () => (/* reexport */ Types.MapDataKind),
+  "MapEventDispatcher": () => (/* reexport */ Types.MapEventDispatcher),
+  "MapProps": () => (/* reexport */ Types.MapProps)
+});
+
+// EXTERNAL MODULE: external "react"
+var external_react_ = __webpack_require__(8156);
+var external_react_default = /*#__PURE__*/__webpack_require__.n(external_react_);
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js
+var objectWithoutPropertiesLoose = __webpack_require__(7038);
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
+
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = (0,objectWithoutPropertiesLoose/* default */.Z)(source, excluded);
+  var key, i;
+
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
+function _iterableToArrayLimit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+  if (_i == null) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+
+  var _s, _e;
+
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+
+  return arr2;
+}
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js
+
+
+
+
+function slicedToArray_slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+;// CONCATENATED MODULE: ./node_modules/@react-leaflet/core/esm/context.js
+
+var CONTEXT_VERSION = 1;
+var LeafletContext = /*#__PURE__*/(0,external_react_.createContext)(null);
+var LeafletProvider = LeafletContext.Provider;
+function useLeafletContext() {
+  var context = (0,external_react_.useContext)(LeafletContext);
+
+  if (context == null) {
+    throw new Error('No context provided: useLeafletContext() can only be used in a descendant of <MapContainer>');
+  }
+
+  return context;
+}
+// EXTERNAL MODULE: external "leaflet"
+var external_leaflet_ = __webpack_require__(4159);
+var external_leaflet_default = /*#__PURE__*/__webpack_require__.n(external_leaflet_);
+;// CONCATENATED MODULE: ./node_modules/react-leaflet-v3/esm/MapContainer.js
+
+
+var _excluded = ["children", "className", "id", "placeholder", "style", "whenCreated"];
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+
+
+
+function useMapElement(mapRef, props) {
+  var _useState = (0,external_react_.useState)(null),
+      _useState2 = slicedToArray_slicedToArray(_useState, 2),
+      map = _useState2[0],
+      setMap = _useState2[1];
+
+  (0,external_react_.useEffect)(function () {
+    if (mapRef.current !== null && map === null) {
+      var instance = new external_leaflet_.Map(mapRef.current, props);
+
+      if (props.center != null && props.zoom != null) {
+        instance.setView(props.center, props.zoom);
+      } else if (props.bounds != null) {
+        instance.fitBounds(props.bounds, props.boundsOptions);
+      }
+
+      if (props.whenReady != null) {
+        instance.whenReady(props.whenReady);
+      }
+
+      setMap(instance);
+    }
+  }, [mapRef, map, props]);
+  return map;
+}
+function MapContainer(_ref) {
+  var children = _ref.children,
+      className = _ref.className,
+      id = _ref.id,
+      placeholder = _ref.placeholder,
+      style = _ref.style,
+      whenCreated = _ref.whenCreated,
+      options = _objectWithoutProperties(_ref, _excluded);
+
+  var mapRef = (0,external_react_.useRef)(null);
+  var map = useMapElement(mapRef, options);
+  var createdRef = (0,external_react_.useRef)(false);
+  (0,external_react_.useEffect)(function () {
+    if (map != null && createdRef.current === false && whenCreated != null) {
+      createdRef.current = true;
+      whenCreated(map);
+    }
+  }, [map, whenCreated]);
+
+  var _useState3 = (0,external_react_.useState)({
+    className: className,
+    id: id,
+    style: style
+  }),
+      _useState4 = slicedToArray_slicedToArray(_useState3, 1),
+      props = _useState4[0];
+
+  var context = (0,external_react_.useMemo)(function () {
+    return map ? {
+      __version: CONTEXT_VERSION,
+      map: map
+    } : null;
+  }, [map]);
+  var contents = context ? /*#__PURE__*/external_react_default().createElement(LeafletProvider, {
+    value: context
+  }, children) : placeholder != null ? placeholder : null;
+  return /*#__PURE__*/external_react_default().createElement("div", _extends({}, props, {
+    ref: mapRef
+  }), contents);
+}
+// EXTERNAL MODULE: external "react-dom"
+var external_react_dom_ = __webpack_require__(7111);
+;// CONCATENATED MODULE: ./node_modules/@react-leaflet/core/esm/component.js
+
+
+
+
+function component_createContainerComponent(useElement) {
+  function ContainerComponent(props, ref) {
+    var _useElement$current = useElement(props).current,
+        instance = _useElement$current.instance,
+        context = _useElement$current.context;
+    (0,external_react_.useImperativeHandle)(ref, function () {
+      return instance;
+    });
+    return props.children == null ? null : /*#__PURE__*/external_react_default().createElement(LeafletProvider, {
+      value: context
+    }, props.children);
+  }
+
+  return /*#__PURE__*/(0,external_react_.forwardRef)(ContainerComponent);
+}
+function component_createDivOverlayComponent(useElement) {
+  function OverlayComponent(props, ref) {
+    var _useState = useState(false),
+        _useState2 = _slicedToArray(_useState, 2),
+        isOpen = _useState2[0],
+        setOpen = _useState2[1];
+
+    var instance = useElement(props, setOpen).current.instance;
+    useImperativeHandle(ref, function () {
+      return instance;
+    });
+    useEffect(function updateOverlay() {
+      if (isOpen) {
+        instance.update();
+      }
+    }, [instance, isOpen, props.children]); // @ts-ignore _contentNode missing in type definition
+
+    var contentNode = instance._contentNode;
+    return contentNode ? /*#__PURE__*/createPortal(props.children, contentNode) : null;
+  }
+
+  return /*#__PURE__*/forwardRef(OverlayComponent);
+}
+function component_createLeafComponent(useElement) {
+  function LeafComponent(props, ref) {
+    var instance = useElement(props).current.instance;
+    (0,external_react_.useImperativeHandle)(ref, function () {
+      return instance;
+    });
+    return null;
+  }
+
+  return /*#__PURE__*/(0,external_react_.forwardRef)(LeafComponent);
+}
+;// CONCATENATED MODULE: ./node_modules/@react-leaflet/core/esm/element.js
+
+function element_createElementHook(createElement, updateElement) {
+  if (updateElement == null) {
+    return function useImmutableLeafletElement(props, context) {
+      return (0,external_react_.useRef)(createElement(props, context));
+    };
+  }
+
+  return function useMutableLeafletElement(props, context) {
+    var elementRef = (0,external_react_.useRef)(createElement(props, context));
+    var propsRef = (0,external_react_.useRef)(props);
+    var instance = elementRef.current.instance;
+    (0,external_react_.useEffect)(function updateElementProps() {
+      if (propsRef.current !== props) {
+        updateElement(instance, props, propsRef.current);
+        propsRef.current = props;
+      }
+    }, [instance, props, context]);
+    return elementRef;
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/@react-leaflet/core/esm/attribution.js
+
+function useAttribution(map, attribution) {
+  var attributionRef = (0,external_react_.useRef)(attribution);
+  (0,external_react_.useEffect)(function updateAttribution() {
+    if (attribution !== attributionRef.current && map.attributionControl != null) {
+      if (attributionRef.current != null) {
+        map.attributionControl.removeAttribution(attributionRef.current);
+      }
+
+      if (attribution != null) {
+        map.attributionControl.addAttribution(attribution);
+      }
+    }
+
+    attributionRef.current = attribution;
+  }, [map, attribution]);
+}
+;// CONCATENATED MODULE: ./node_modules/@react-leaflet/core/esm/events.js
+
+function useEventHandlers(element, eventHandlers) {
+  var eventHandlersRef = (0,external_react_.useRef)();
+  (0,external_react_.useEffect)(function addEventHandlers() {
+    if (eventHandlers != null) {
+      element.instance.on(eventHandlers);
+    }
+
+    eventHandlersRef.current = eventHandlers;
+    return function removeEventHandlers() {
+      if (eventHandlersRef.current != null) {
+        element.instance.off(eventHandlersRef.current);
+      }
+
+      eventHandlersRef.current = null;
+    };
+  }, [element, eventHandlers]);
+}
+;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+;// CONCATENATED MODULE: ./node_modules/@react-leaflet/core/esm/pane.js
+
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function withPane(props, context) {
+  var _props$pane;
+
+  var pane = (_props$pane = props.pane) != null ? _props$pane : context.pane;
+  return pane ? _objectSpread(_objectSpread({}, props), {}, {
+    pane: pane
+  }) : props;
+}
+;// CONCATENATED MODULE: ./node_modules/@react-leaflet/core/esm/layer.js
+
+
+
+
+
+function useLayerLifecycle(element, context) {
+  (0,external_react_.useEffect)(function addLayer() {
+    var _context$layerContain;
+
+    var container = (_context$layerContain = context.layerContainer) != null ? _context$layerContain : context.map;
+    container.addLayer(element.instance);
+    return function removeLayer() {
+      container.removeLayer(element.instance);
+    };
+  }, [context, element]);
+}
+function layer_createLayerHook(useElement) {
+  return function useLayer(props) {
+    var context = useLeafletContext();
+    var elementRef = useElement(withPane(props, context), context);
+    useAttribution(context.map, props.attribution);
+    useEventHandlers(elementRef.current, props.eventHandlers);
+    useLayerLifecycle(elementRef.current, context);
+    return elementRef;
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/@react-leaflet/core/esm/path.js
+
+
+
+
+
+function usePathOptions(element, props) {
+  var optionsRef = (0,external_react_.useRef)();
+  (0,external_react_.useEffect)(function updatePathOptions() {
+    if (props.pathOptions !== optionsRef.current) {
+      var _props$pathOptions;
+
+      var options = (_props$pathOptions = props.pathOptions) != null ? _props$pathOptions : {};
+      element.instance.setStyle(options);
+      optionsRef.current = options;
+    }
+  }, [element, props]);
+}
+function createPathHook(useElement) {
+  return function usePath(props) {
+    var context = useLeafletContext();
+    var elementRef = useElement(withPane(props, context), context);
+    useEventHandlers(elementRef.current, props.eventHandlers);
+    useLayerLifecycle(elementRef.current, context);
+    usePathOptions(elementRef.current, props);
+    return elementRef;
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/@react-leaflet/core/esm/generic.js
+
+
+
+
+
+
+function createControlComponent(createInstance) {
+  function createElement(props, context) {
+    return {
+      instance: createInstance(props),
+      context: context
+    };
+  }
+
+  var useElement = createElementHook(createElement);
+  var useControl = createControlHook(useElement);
+  return createLeafComponent(useControl);
+}
+function createLayerComponent(createElement, updateElement) {
+  var useElement = createElementHook(createElement, updateElement);
+  var useLayer = createLayerHook(useElement);
+  return createContainerComponent(useLayer);
+}
+function createOverlayComponent(createElement, useLifecycle) {
+  var useElement = createElementHook(createElement);
+  var useOverlay = createDivOverlayHook(useElement, useLifecycle);
+  return createDivOverlayComponent(useOverlay);
+}
+function createPathComponent(createElement, updateElement) {
+  var useElement = element_createElementHook(createElement, updateElement);
+  var usePath = createPathHook(useElement);
+  return component_createContainerComponent(usePath);
+}
+function createTileLayerComponent(createElement, updateElement) {
+  var useElement = element_createElementHook(createElement, updateElement);
+  var useLayer = layer_createLayerHook(useElement);
+  return component_createLeafComponent(useLayer);
+}
+;// CONCATENATED MODULE: ./node_modules/@react-leaflet/core/esm/grid-layer.js
+function updateGridLayer(layer, props, prevProps) {
+  var opacity = props.opacity,
+      zIndex = props.zIndex;
+
+  if (opacity != null && opacity !== prevProps.opacity) {
+    layer.setOpacity(opacity);
+  }
+
+  if (zIndex != null && zIndex !== prevProps.zIndex) {
+    layer.setZIndex(zIndex);
+  }
+}
+;// CONCATENATED MODULE: ./node_modules/react-leaflet-v3/esm/TileLayer.js
+
+var TileLayer_excluded = ["url"];
+
+
+var TileLayer = createTileLayerComponent(function createTileLayer(_ref, context) {
+  var url = _ref.url,
+      options = _objectWithoutProperties(_ref, TileLayer_excluded);
+
+  return {
+    instance: new external_leaflet_.TileLayer(url, withPane(options, context)),
+    context: context
+  };
+}, updateGridLayer);
+// EXTERNAL MODULE: external "classnames"
+var external_classnames_ = __webpack_require__(8310);
+var external_classnames_default = /*#__PURE__*/__webpack_require__.n(external_classnames_);
+// EXTERNAL MODULE: ./node_modules/autobind-decorator/lib/esm/index.js
+var esm = __webpack_require__(6627);
+// EXTERNAL MODULE: external "leaflet-image"
+var external_leaflet_image_ = __webpack_require__(855);
+var external_leaflet_image_default = /*#__PURE__*/__webpack_require__.n(external_leaflet_image_);
+// EXTERNAL MODULE: ./src/components/Utils/Utils.tsx
+var Utils = __webpack_require__(5654);
+// EXTERNAL MODULE: ./src/components/Spinner/index.ts + 1 modules
+var Spinner = __webpack_require__(4482);
+// EXTERNAL MODULE: ./src/components/EmptyState/index.ts + 1 modules
+var EmptyState = __webpack_require__(5385);
+// EXTERNAL MODULE: external "react-bootstrap/Tooltip"
+var Tooltip_ = __webpack_require__(8053);
+var Tooltip_default = /*#__PURE__*/__webpack_require__.n(Tooltip_);
+// EXTERNAL MODULE: external "react-bootstrap/OverlayTrigger"
+var OverlayTrigger_ = __webpack_require__(6043);
+var OverlayTrigger_default = /*#__PURE__*/__webpack_require__.n(OverlayTrigger_);
+// EXTERNAL MODULE: external "@fortawesome/react-fontawesome"
+var react_fontawesome_ = __webpack_require__(5692);
+;// CONCATENATED MODULE: ./src/components/Map/MapControl.tsx
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+
+
+
+
+
+
+var MapControl = external_react_default().memo(function (_a) {
+    var _b;
+    var _c = _a.size, size = _c === void 0 ? 'sm' : _c, props = __rest(_a, ["size"]);
+    var icon = null;
+    if (props.icon != null) {
+        icon = external_react_default().createElement(react_fontawesome_.FontAwesomeIcon, { size: 'xs', icon: props.icon });
+    }
+    var className = external_classnames_default()('map-control-button', props.className, size, {
+        selected: props.isSelected,
+    });
+    if (props.children == null || size === 'lg') {
+        return (external_react_default().createElement("button", { className: className, onClick: props.onClick },
+            icon,
+            props.children));
+    }
+    var tooltip = (external_react_default().createElement((Tooltip_default()), { id: (_b = props === null || props === void 0 ? void 0 : props.tooltipId) !== null && _b !== void 0 ? _b : '', className: 'big-tooltip' }, props.children));
+    return (external_react_default().createElement((OverlayTrigger_default()), { rootClose: true, trigger: ['hover', 'focus'], placement: 'bottom', overlay: tooltip },
+        external_react_default().createElement("button", { className: className, onClick: props.onClick }, icon)));
+});
+MapControl.displayName = 'MapControl';
+
+
+// EXTERNAL MODULE: ./node_modules/d3-scale/src/linear.js + 38 modules
+var linear = __webpack_require__(1820);
+;// CONCATENATED MODULE: ./node_modules/react-leaflet-v3/esm/GeoJSON.js
+
+
+var GeoJSON_excluded = ["data"];
+
+function GeoJSON_ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function GeoJSON_objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? GeoJSON_ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : GeoJSON_ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+
+
+var GeoJSON = createPathComponent(function createGeoJSON(_ref, ctx) {
+  var data = _ref.data,
+      options = _objectWithoutProperties(_ref, GeoJSON_excluded);
+
+  var instance = new external_leaflet_.GeoJSON(data, options);
+  return {
+    instance: instance,
+    context: GeoJSON_objectSpread(GeoJSON_objectSpread({}, ctx), {}, {
+      overlayContainer: instance
+    })
+  };
+});
+// EXTERNAL MODULE: ./src/components/Utils/Style.ts
+var Style = __webpack_require__(2755);
+// EXTERNAL MODULE: ./src/components/Utils/Text.ts
+var Text = __webpack_require__(6347);
+;// CONCATENATED MODULE: ./src/components/Map/MapPopup.tsx
+var MapPopup_rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+
+
+
+var MapPopup = external_react_default().memo(function (_a) {
+    var props = MapPopup_rest(_a, []);
+    var className = external_classnames_default()('map-popup-container', 'w-100', props.className);
+    return external_react_default().createElement("div", { className: className }, props.children);
+});
+MapPopup.displayName = 'MapPopup';
+
+
+;// CONCATENATED MODULE: ./src/components/Map/MapLegendContent.tsx
+var __extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (undefined && undefined.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __read = (undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+
+
+
+var MapLegendContent = /** @class */ (function (_super) {
+    __extends(MapLegendContent, _super);
+    function MapLegendContent() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.popupRef = external_react_default().createRef();
+        return _this;
+    }
+    MapLegendContent.prototype.componentDidMount = function () {
+        if (this.props.forceUpdateOnMount) {
+            this.forceUpdate();
+        }
+    };
+    MapLegendContent.estimatedWordSize = function (wordLength, letterPixels, constant) {
+        if (letterPixels === void 0) { letterPixels = this.ESTIMATED_LETTER_PIXELS; }
+        if (constant === void 0) { constant = this.ESTIMATED_ADDABLE_SPACE; }
+        return wordLength * letterPixels + constant;
+    };
+    MapLegendContent.prototype.getItemsPositions = function (wordLength, minMargin) {
+        var _a, _b, _c, _d, _e;
+        if (minMargin === void 0) { minMargin = 30; }
+        var _f = ((_d = (_c = (_b = (_a = this.popupRef) === null || _a === void 0 ? void 0 : _a.current) === null || _b === void 0 ? void 0 : _b.getBoundingClientRect) === null || _c === void 0 ? void 0 : _c.call(_b)) !== null && _d !== void 0 ? _d : {}).width, width = _f === void 0 ? 0 : _f, _g = ((_e = this.props.hoveredItem) !== null && _e !== void 0 ? _e : {}).value, value = _g === void 0 ? 0 : _g, hoveredItemPosition = Math.round((value * width) / this.props.valueMax), middle = width / 2, isOnLeftSide = hoveredItemPosition < Math.round(middle), vector = 0, estimatedWordSize = MapLegendContent.estimatedWordSize(wordLength);
+        if (width === 0) {
+            return [0, 0];
+        }
+        if (isOnLeftSide) {
+            vector = ((middle - hoveredItemPosition) * minMargin) / middle;
+        }
+        else {
+            vector = -((hoveredItemPosition - middle) * minMargin) / middle;
+        }
+        var cursorPosition = hoveredItemPosition + vector, textLeftPosition = -Infinity;
+        if (cursorPosition < width / 3) {
+            textLeftPosition = cursorPosition - 10;
+        }
+        else if (cursorPosition < 2 * (width / 3)) {
+            textLeftPosition = cursorPosition - estimatedWordSize / 2;
+        }
+        else {
+            textLeftPosition = cursorPosition - estimatedWordSize;
+        }
+        return [cursorPosition, textLeftPosition];
+    };
+    MapLegendContent.prototype.renderCursor = function (position) {
+        var className = external_classnames_default()({
+            triangle: true,
+            invisible: this.props.hoveredItem == null,
+        });
+        return external_react_default().createElement("div", { className: className, style: { left: position } });
+    };
+    MapLegendContent.prototype.renderMapBitInfo = function (leftPosition) {
+        var _a, _b;
+        var _c = (_b = (_a = this.props) === null || _a === void 0 ? void 0 : _a.hoveredItem) !== null && _b !== void 0 ? _b : {}, _d = _c.value, value = _d === void 0 ? 0 : _d, _e = _c.label, label = _e === void 0 ? '' : _e, mapBitClassName = external_classnames_default()({
+            'invisible w-0': this.props.hoveredItem == null,
+            'w-100': this.props.hoveredItem != null,
+            'map-bit-info': true,
+        });
+        return (external_react_default().createElement("div", { className: mapBitClassName },
+            external_react_default().createElement("div", { className: 'pusher-container', style: { flex: "0 1 " + leftPosition + "px" } }),
+            external_react_default().createElement("div", { className: 'content' },
+                external_react_default().createElement("span", { className: 'first-letter-capitalize' }, label), ": " + this.getFormattedNumber(value))));
+    };
+    MapLegendContent.prototype.getFormattedNumber = function (value) {
+        var numberToStringFormatter = this.props.numberToStringFormatter;
+        return numberToStringFormatter != null ? numberToStringFormatter(value) : "" + value;
+    };
+    MapLegendContent.prototype.renderPopupChildren = function () {
+        var mapDataclassName = external_classnames_default()({
+            invisible: this.props.hoveredItem != null,
+        }), className = external_classnames_default()({
+            'd-flex w-100': this.props.hoveredItem == null,
+            'd-none': this.props.hoveredItem != null,
+            'text-white justify-content-between': true,
+        }), min = Math.round(this.props.valueMin), middle = (this.props.valueMax - this.props.valueMin) / 2;
+        return (external_react_default().createElement("span", { className: className },
+            external_react_default().createElement("span", { className: mapDataclassName }, this.getFormattedNumber(min)),
+            external_react_default().createElement("span", { className: mapDataclassName }, this.getFormattedNumber(middle)),
+            external_react_default().createElement("span", { className: mapDataclassName }, this.getFormattedNumber(this.props.valueMax))));
+    };
+    MapLegendContent.prototype.render = function () {
+        var _a, _b, _c;
+        var linearG = 'linear-gradient(to right, ' + this.props.minColor + ',' + this.props.maxColor + ')', className = external_classnames_default()({
+            'popup-children': true,
+        }), _d = (_a = this.props.hoveredItem) !== null && _a !== void 0 ? _a : {}, _e = _d.value, value = _e === void 0 ? 0 : _e, _f = _d.label, label = _f === void 0 ? '' : _f, estimationLabel = ((_c = (_b = this.props) === null || _b === void 0 ? void 0 : _b.hoveredItem) === null || _c === void 0 ? void 0 : _c.value) == null ? '' : label + ": " + this.getFormattedNumber(value), _g = __read(this.getItemsPositions(estimationLabel.length), 2), cursorPosition = _g[0], textLeftPosition = _g[1];
+        return (external_react_default().createElement("div", { className: className, ref: this.popupRef, style: { backgroundImage: linearG } },
+            this.renderPopupChildren(),
+            this.renderMapBitInfo(textLeftPosition),
+            this.renderCursor(cursorPosition)));
+    };
+    MapLegendContent.ESTIMATED_LETTER_PIXELS = 5.4;
+    MapLegendContent.ESTIMATED_ADDABLE_SPACE = 1.1;
+    MapLegendContent.displayName = 'MapLegendContent';
+    MapLegendContent.defaultProps = {
+        forceUpdateOnMount: false,
+    };
+    __decorate([
+        esm/* default */.ZP,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Number]),
+        __metadata("design:returntype", String)
+    ], MapLegendContent.prototype, "getFormattedNumber", null);
+    return MapLegendContent;
+}((external_react_default()).PureComponent));
+
+
+// EXTERNAL MODULE: ./src/components/Map/Types.ts
+var Types = __webpack_require__(604);
+;// CONCATENATED MODULE: ./src/components/Map/MapUtils.ts
+var MAP_ATTRIBUTION = '<a href="https://www.mapbox.com/feedback/">&copy; Mapbox</a> | ' +
+    '<a href="https://www.mapbox.com/feedback/" target="_blank"><strong>Improve this map</strong></a>', mapboxStyle = 'mapbox/light-v10', mapboxAccessToken = 'pk.eyJ1Ijoic2RhdG9rYSIsImEiOiI5MjlmNDMxYzJiYWQ5YjhjMjU4ZGE2YmVkZjQ1YzhiOCJ9.FYB402MPxkR2bIME35d0zg', MAP_TILE_URL = 'https://api.mapbox.com/styles/v1/' + mapboxStyle + '/tiles/{z}/{x}/{y}?access_token=' + mapboxAccessToken;
+
+
+;// CONCATENATED MODULE: ./src/components/Map/MapChoropleth.tsx
+var MapChoropleth_extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var MapChoropleth_decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var MapChoropleth_metadata = (undefined && undefined.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var MapChoropleth_read = (undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (undefined && undefined.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+
+
+
+
+
+
+
+
+
+
+
+
+var MapChoropleth = /** @class */ (function (_super) {
+    MapChoropleth_extends(MapChoropleth, _super);
+    function MapChoropleth() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.state = {
+            mapDataShowKind: null,
+            currentMapData: null,
+            hoveredItem: null,
+            nameToDataPoint: new Map(),
+            valueMax: -Infinity,
+            valueMin: Infinity,
+            itemValueToColor: (0,linear/* default */.Z)(),
+        };
+        return _this;
+    }
+    MapChoropleth.getDerivedStateFromProps = function (props, state) {
+        var _a, _b, _c;
+        var mapDataShowKind = (_a = state === null || state === void 0 ? void 0 : state.mapDataShowKind) !== null && _a !== void 0 ? _a : (_c = (_b = props.mapData) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.kind, _d = MapChoropleth_read(MapChoropleth.getSetupData(props, mapDataShowKind), 5), currentMapData = _d[0], nameToDataPoint = _d[1], valueMax = _d[2], valueMin = _d[3], itemValueToColor = _d[4];
+        return __assign(__assign({}, state), { mapDataShowKind: mapDataShowKind,
+            currentMapData: currentMapData,
+            nameToDataPoint: nameToDataPoint,
+            valueMax: valueMax,
+            valueMin: valueMin,
+            itemValueToColor: itemValueToColor });
+    };
+    MapChoropleth.getSetupData = function (props, currentType) {
+        var _a;
+        var mapDataFromType = props.mapData.filter(function (m) {
+            return m.kind === currentType;
+        });
+        if (mapDataFromType.length === 0) {
+            return [null, new Map(), -Infinity, Infinity, (0,linear/* default */.Z)()];
+        }
+        var currentMapData = mapDataFromType[0], dataPoint = currentMapData.dataPoint, nameToDataPoint = new Map(), valueMax = -Infinity, valueMin = (_a = props.valueMin) !== null && _a !== void 0 ? _a : Infinity, itemValueToColor = (0,linear/* default */.Z)();
+        dataPoint.forEach(function (item) {
+            nameToDataPoint.set(item.label, item);
+            valueMax = Math.max(valueMax, item.value);
+            valueMin = Math.min(valueMin, item.value);
+        });
+        itemValueToColor.domain([valueMin, valueMax]).range([props.minColor, props.maxColor]);
+        return [currentMapData, nameToDataPoint, valueMax, valueMin, itemValueToColor];
+    };
+    MapChoropleth.prototype.getFeatureStyle = function (feature) {
+        var _a, _b, _c, _d, _e;
+        var featureName = (_b = (_a = feature.properties) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : '', item = (_c = this.state.nameToDataPoint) === null || _c === void 0 ? void 0 : _c.get(featureName);
+        if (item == null) {
+            return {
+                className: "interactive-base " + (0,Text/* slugify */.lV)(featureName),
+                weight: 1,
+                opacity: 0.5,
+                fillOpacity: 0.1,
+                fill: true,
+                stroke: true,
+                color: 'white',
+            };
+        }
+        if (((_e = (_d = this.state) === null || _d === void 0 ? void 0 : _d.hoveredItem) === null || _e === void 0 ? void 0 : _e.label) === featureName) {
+            return {
+                weight: 1,
+                opacity: 0.9,
+                fillOpacity: 0.9,
+                className: "interactive-hovered " + (0,Text/* slugify */.lV)(featureName),
+                fillColor: this.props.hoverColor,
+                fill: true,
+                stroke: true,
+                color: 'white',
+            };
+        }
+        return {
+            weight: 1,
+            opacity: 0.9,
+            fillOpacity: 0.9,
+            className: "interactive-selected " + (0,Text/* slugify */.lV)(featureName),
+            fillColor: this.state.itemValueToColor(item.value),
+            fill: true,
+            stroke: true,
+            color: 'white',
+        };
+    };
+    MapChoropleth.prototype.handleFeatureOver = function (feature) {
+        var _a, _b;
+        var hoveredItem = (_a = this.state.nameToDataPoint) === null || _a === void 0 ? void 0 : _a.get(feature.name);
+        if (hoveredItem != null && ((_b = this.state.hoveredItem) === null || _b === void 0 ? void 0 : _b.label) !== hoveredItem.label) {
+            this.setState({ hoveredItem: hoveredItem });
+        }
+    };
+    MapChoropleth.prototype.handleFeatureOut = function () {
+        this.setState({ hoveredItem: null });
+    };
+    MapChoropleth.prototype.handleChangeMapDataType = function (kind) {
+        if (this.state.mapDataShowKind === kind) {
+            return;
+        }
+        var _a = MapChoropleth_read(MapChoropleth.getSetupData(this.props, kind), 5), currentMapData = _a[0], nameToDataPoint = _a[1], valueMax = _a[2], valueMin = _a[3], itemValueToColor = _a[4];
+        this.setState({
+            mapDataShowKind: kind,
+            currentMapData: currentMapData,
+            nameToDataPoint: nameToDataPoint,
+            valueMax: valueMax,
+            valueMin: valueMin,
+            itemValueToColor: itemValueToColor,
+            hoveredItem: null,
+        });
+    };
+    MapChoropleth.prototype.renderSingleControl = function (mapData) {
+        var _this = this;
+        return (external_react_default().createElement(Map_Map.Control, { isSelected: mapData.kind === this.state.mapDataShowKind, key: mapData.kind, size: 'lg', className: 'ml-2', onClick: function () { return _this.handleChangeMapDataType(mapData.kind); } }, mapData.label));
+    };
+    MapChoropleth.prototype.renderMapDataToggleButtons = function () {
+        if (this.props.mapData.length < 2) {
+            return null;
+        }
+        return (external_react_default().createElement(Map_Map.ControlsContainer, { className: 'd-flex' }, this.props.mapData.map(this.renderSingleControl)));
+    };
+    MapChoropleth.prototype.renderBottomPopup = function () {
+        if (!this.props.withLegend) {
+            return null;
+        }
+        return (external_react_default().createElement(MapPopup, null,
+            external_react_default().createElement(MapLegendContent, { hoveredItem: this.state.hoveredItem, valueMax: this.state.valueMax, valueMin: this.state.valueMin, numberToStringFormatter: this.props.numberToStringFormatter, minColor: this.props.minColor, maxColor: this.props.maxColor })));
+    };
+    MapChoropleth.prototype.renderHoveredItem = function () {
+        var e_1, _a;
+        var _b, _c, _d, _e, _f, _g;
+        var features = [], geometries = (_c = (_b = this.state.currentMapData) === null || _b === void 0 ? void 0 : _b.geometries) !== null && _c !== void 0 ? _c : [];
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            for (var _h = __values((_e = (_d = geometries) === null || _d === void 0 ? void 0 : _d.features) !== null && _e !== void 0 ? _e : []), _j = _h.next(); !_j.done; _j = _h.next()) {
+                var feature = _j.value;
+                if (feature.properties.name === ((_f = this.state.hoveredItem) === null || _f === void 0 ? void 0 : _f.label)) {
+                    features.push(feature);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_j && !_j.done && (_a = _h.return)) _a.call(_h);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (features.length === 0) {
+            return null;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        var data = {
+            features: features,
+        };
+        return (external_react_default().createElement(GeoJSON, { key: (_g = this.state.hoveredItem) === null || _g === void 0 ? void 0 : _g.label, style: this.getFeatureStyle, data: data, onEachFeature: this.onHoverEachFeature }));
+    };
+    MapChoropleth.prototype.onHoverEachFeature = function (feature, layer) {
+        var _this = this;
+        layer.on('mouseout', function () { return _this.handleFeatureOut(); });
+    };
+    MapChoropleth.prototype.onEachFeature = function (feature, layer) {
+        var _this = this;
+        layer.on('mouseover', function () { return _this.handleFeatureOver(feature.properties); });
+    };
+    MapChoropleth.prototype.render = function () {
+        var _a;
+        if (!this.state.mapDataShowKind == null) {
+            return null;
+        }
+        var geometries = (_a = this.state.currentMapData) === null || _a === void 0 ? void 0 : _a.geometries, key = "ita-" + this.state.mapDataShowKind;
+        if (geometries == null) {
+            return null;
+        }
+        return (external_react_default().createElement((external_react_default()).Fragment, null,
+            this.renderHoveredItem(),
+            external_react_default().createElement(GeoJSON, { key: key, style: this.getFeatureStyle, data: geometries, onEachFeature: this.onEachFeature }),
+            this.renderBottomPopup(),
+            this.renderMapDataToggleButtons(),
+            external_react_default().createElement(Map_Map.TileLayer, { url: MAP_TILE_URL, attribution: MAP_ATTRIBUTION, minZoom: 4 })));
+    };
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    MapChoropleth.displayName = 'MapChoropleth';
+    MapChoropleth.defaultProps = {
+        minColor: Style/* blue30 */.KH,
+        maxColor: Style/* blue300 */.p5,
+        hoverColor: Style/* orange */.$y,
+        withLegend: true,
+    };
+    MapChoropleth_decorate([
+        esm/* default */.ZP,
+        MapChoropleth_metadata("design:type", Function),
+        MapChoropleth_metadata("design:paramtypes", [typeof (_a = typeof MapBaseChoroplethFeature !== "undefined" && MapBaseChoroplethFeature) === "function" ? _a : Object]),
+        MapChoropleth_metadata("design:returntype", typeof (_b = typeof external_leaflet_.PathOptions !== "undefined" && external_leaflet_.PathOptions) === "function" ? _b : Object)
+    ], MapChoropleth.prototype, "getFeatureStyle", null);
+    MapChoropleth_decorate([
+        esm/* default */.ZP,
+        MapChoropleth_metadata("design:type", Function),
+        MapChoropleth_metadata("design:paramtypes", [typeof (_c = typeof Types.MapBaseChoroplethFeatureProperties !== "undefined" && Types.MapBaseChoroplethFeatureProperties) === "function" ? _c : Object]),
+        MapChoropleth_metadata("design:returntype", void 0)
+    ], MapChoropleth.prototype, "handleFeatureOver", null);
+    MapChoropleth_decorate([
+        esm/* default */.ZP,
+        MapChoropleth_metadata("design:type", Function),
+        MapChoropleth_metadata("design:paramtypes", []),
+        MapChoropleth_metadata("design:returntype", void 0)
+    ], MapChoropleth.prototype, "handleFeatureOut", null);
+    MapChoropleth_decorate([
+        esm/* default */.ZP,
+        MapChoropleth_metadata("design:type", Function),
+        MapChoropleth_metadata("design:paramtypes", [typeof (_d = typeof Types.MapDataKind !== "undefined" && Types.MapDataKind) === "function" ? _d : Object]),
+        MapChoropleth_metadata("design:returntype", void 0)
+    ], MapChoropleth.prototype, "handleChangeMapDataType", null);
+    MapChoropleth_decorate([
+        esm/* default */.ZP,
+        MapChoropleth_metadata("design:type", Function),
+        MapChoropleth_metadata("design:paramtypes", [typeof (_e = typeof Types.MapData !== "undefined" && Types.MapData) === "function" ? _e : Object]),
+        MapChoropleth_metadata("design:returntype", typeof (_f = typeof (external_react_default()) !== "undefined" && (external_react_default()).ReactNode) === "function" ? _f : Object)
+    ], MapChoropleth.prototype, "renderSingleControl", null);
+    MapChoropleth_decorate([
+        esm/* default */.ZP,
+        MapChoropleth_metadata("design:type", Function),
+        MapChoropleth_metadata("design:paramtypes", [typeof (_g = typeof MapBaseChoroplethFeature !== "undefined" && MapBaseChoroplethFeature) === "function" ? _g : Object, typeof (_h = typeof external_leaflet_.Layer !== "undefined" && external_leaflet_.Layer) === "function" ? _h : Object]),
+        MapChoropleth_metadata("design:returntype", void 0)
+    ], MapChoropleth.prototype, "onHoverEachFeature", null);
+    MapChoropleth_decorate([
+        esm/* default */.ZP,
+        MapChoropleth_metadata("design:type", Function),
+        MapChoropleth_metadata("design:paramtypes", [typeof (_j = typeof MapBaseChoroplethFeature !== "undefined" && MapBaseChoroplethFeature) === "function" ? _j : Object, typeof (_k = typeof external_leaflet_.Layer !== "undefined" && external_leaflet_.Layer) === "function" ? _k : Object]),
+        MapChoropleth_metadata("design:returntype", void 0)
+    ], MapChoropleth.prototype, "onEachFeature", null);
+    return MapChoropleth;
+}((external_react_default()).Component));
+
+
+;// CONCATENATED MODULE: ./src/components/Map/Map.tsx
+var Map_extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var Map_assign = (undefined && undefined.__assign) || function () {
+    Map_assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return Map_assign.apply(this, arguments);
+};
+var Map_decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Map_metadata = (undefined && undefined.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+
+
+
+
+
+// eslint-disable-next-line
+// @ts-expect-error: no types for leaflet-image yet :/
+
+
+
+
+
+
+
+var ControlsContainer = external_react_default().memo(function (props) {
+    var className = external_classnames_default()('map-controls-container', props.className);
+    return external_react_default().createElement("div", { className: className }, props.children);
+});
+ControlsContainer.displayName = 'ControlsContainer';
+/** Container component to display the map component.<br />
+ *  You should use its special children Choropleth to define its content<br />
+ *  and a Spinner as well as EmptyState to define its empty states */
+var Map_Map = /** @class */ (function (_super) {
+    Map_extends(Map, _super);
+    function Map() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.map = null;
+        _this.italyBounds = [
+            [47.53203824675999, 6.3394115537],
+            [36.12012758978146, 18.8501168459],
+        ];
+        return _this;
+    }
+    Map.prototype.renderOtherChildren = function () {
+        var ret = [];
+        external_react_default().Children.forEach(this.props.children, function (element) {
+            if ((element === null || element === void 0 ? void 0 : element.type) !== Map.Choropleth && (element === null || element === void 0 ? void 0 : element.type) !== Spinner.Spinner && (element === null || element === void 0 ? void 0 : element.type) !== EmptyState.EmptyState) {
+                ret.push(element);
+            }
+        });
+        return ret;
+    };
+    Map.prototype.renderChoropleth = function () {
+        if (this.props.isLoading || this.props.isEmpty) {
+            return null;
+        }
+        return (0,Utils/* findChildByComponent */.z8)(this.props.children, Map.Choropleth);
+    };
+    Map.prototype.renderIsLoading = function () {
+        if (!this.props.isLoading) {
+            return null;
+        }
+        return (external_react_default().createElement("div", { className: 'w-100 h-100 d-flex justify-content-center align-items-center' }, (0,Utils/* findChildByComponent */.z8)(this.props.children, Spinner.Spinner)));
+    };
+    Map.prototype.renderIsEmpty = function () {
+        if (!this.props.isEmpty) {
+            return null;
+        }
+        return (external_react_default().createElement("div", { className: 'w-100 h-100 d-flex justify-content-center align-items-center' }, (0,Utils/* findChildByComponent */.z8)(this.props.children, EmptyState.EmptyState)));
+    };
+    Map.prototype.handleMapCreated = function (map) {
+        var _a, _b;
+        this.map = map;
+        (_b = (_a = this.props).onInit) === null || _b === void 0 ? void 0 : _b.call(_a, {
+            getCanvas: function () {
+                return __awaiter(this, void 0, Promise, function () {
+                    return __generator(this, function (_a) {
+                        return [2 /*return*/, new Promise(function (resolve, reject) {
+                                external_leaflet_image_default()(map, function (err, canvas) {
+                                    if (err) {
+                                        reject(err);
+                                        return;
+                                    }
+                                    resolve(canvas);
+                                });
+                            })];
+                    });
+                });
+            },
+        });
+    };
+    Map.prototype.render = function () {
+        var _a;
+        var bounds = (_a = this.props.bounds) !== null && _a !== void 0 ? _a : this.italyBounds, isDisabled = this.props.isLoading || this.props.isEmpty || this.props.zoomControl === false, className = external_classnames_default()('atoka-map-container', {
+            disabled: isDisabled,
+        });
+        // The map does not rerender when props that are not children re-renders. We force it to do so giving it a key
+        return (external_react_default().createElement(MapContainer, Map_assign({}, this.props, { bounds: bounds, className: className, key: className, renderer: external_leaflet_default().canvas(), whenCreated: this.handleMapCreated, id: this.props.id }),
+            this.renderChoropleth(),
+            this.renderIsLoading(),
+            this.renderIsEmpty(),
+            this.renderOtherChildren()));
+    };
+    var _a;
+    Map.displayName = 'Map';
+    Map.defaultProps = {
+        isLoading: false,
+        isEmpty: false,
+        id: '',
+    };
+    Map.Choropleth = MapChoropleth;
+    Map.TileLayer = TileLayer;
+    Map.ControlsContainer = ControlsContainer;
+    Map.Control = MapControl;
+    Map_decorate([
+        esm/* boundMethod */.MR,
+        Map_metadata("design:type", Function),
+        Map_metadata("design:paramtypes", [typeof (_a = typeof (external_leaflet_default()) !== "undefined" && (external_leaflet_default()).Map) === "function" ? _a : Object]),
+        Map_metadata("design:returntype", void 0)
+    ], Map.prototype, "handleMapCreated", null);
+    return Map;
+}((external_react_default()).Component));
+
+
+;// CONCATENATED MODULE: ./src/components/Map/index.ts
+
+
+
+
+/***/ }),
+
+/***/ 4482:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "Spinner": () => (/* reexport */ Spinner)
+});
+
+// UNUSED EXPORTS: SpinnerSize
+
+// EXTERNAL MODULE: external "classnames"
+var external_classnames_ = __webpack_require__(8310);
+var external_classnames_default = /*#__PURE__*/__webpack_require__.n(external_classnames_);
+// EXTERNAL MODULE: external "react"
+var external_react_ = __webpack_require__(8156);
+var external_react_default = /*#__PURE__*/__webpack_require__.n(external_react_);
+;// CONCATENATED MODULE: ./src/components/Spinner/Spinner.tsx
+var __extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+
+
+
+var SpinnerSize;
+(function (SpinnerSize) {
+    SpinnerSize[SpinnerSize["mini"] = 0] = "mini";
+    SpinnerSize[SpinnerSize["small"] = 1] = "small";
+    SpinnerSize[SpinnerSize["big"] = 2] = "big";
+    SpinnerSize[SpinnerSize["modal"] = 3] = "modal";
+})(SpinnerSize || (SpinnerSize = {}));
+/**
+ * ### Overview
+ *
+ * We can find two different spinners in the Atoka interface, small and big. The **small** one is used to show that a specific section inside the page is loading. The **big** spinner on the other hand shows when the whole page is loading.
+ *
+ * ### Best practice
+ *
+ * Use the spinner if the waiting time is between 0.1 and 1 second. After one second, the user gets the impression that the app is slow: in that case, use a progress indicator instead.
+ **/
+var Spinner = /** @class */ (function (_super) {
+    __extends(Spinner, _super);
+    function Spinner() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Spinner.prototype.renderOnlyDotsSpinner = function (size) {
+        var className = 'atoka-spinner spinner-' + size + ' ' + this.props.className;
+        return (external_react_default().createElement("div", { className: className },
+            external_react_default().createElement("div", { className: 'spinner-dot1' },
+                external_react_default().createElement("div", { className: 'spinner-leaf' })),
+            external_react_default().createElement("div", { className: 'spinner-dot2' },
+                external_react_default().createElement("div", { className: 'spinner-leaf' })),
+            external_react_default().createElement("div", { className: 'spinner-dot3' },
+                external_react_default().createElement("div", { className: 'spinner-leaf' }))));
+    };
+    Spinner.prototype.renderSmall = function () {
+        return this.renderOnlyDotsSpinner('small');
+    };
+    Spinner.prototype.renderMini = function () {
+        return this.renderOnlyDotsSpinner('mini');
+    };
+    Spinner.prototype.renderLeaf = function () {
+        return (external_react_default().createElement("svg", { viewBox: '0 0 204.01 190.64', version: '1.1', xmlns: 'http://www.w3.org/2000/svg' },
+            external_react_default().createElement("g", { id: 'leaf' },
+                external_react_default().createElement("path", { d: 'M80.88,7.62a26,26,0,0,0-36.79,36.8,25.85,25.85,0,0,0,13.4,7.14V83.39c1.19,0,2.4-.08,3.62-.08,2.16,0,4.28.08,6.38.23v-32A26,26,0,0,0,80.88,7.62ZM73.81,37.35a16,16,0,1,1,0-22.66,15.92,15.92,0,0,1,0,22.66Z' }))));
+    };
+    Spinner.prototype.renderLetter = function () {
+        return (external_react_default().createElement("svg", { viewBox: '0 0 204.01 190.64', version: '1.1', xmlns: 'http://www.w3.org/2000/svg' },
+            external_react_default().createElement("g", { id: 'logo-vector' },
+                external_react_default().createElement("path", { d: 'M110.77,180.67V140.16a50.47,50.47,0,1,0-22,41.71L93.12,187a10,10,0,0,0,17.65-6.34Zm-81-40.51a30.5,30.5,0,1,1,30.5,30.5,30.49,30.49,0,0,1-30.5-30.5Z' }))));
+    };
+    Spinner.prototype.renderBig = function () {
+        var spinnerClassName = external_classnames_default()(this.props.className, {
+            'atoka-spinner': true,
+            'spinner-big': this.props.size === SpinnerSize.big,
+            'spinner-medium': this.props.size === SpinnerSize.modal,
+        }), containerClassName = external_classnames_default()({
+            'container-fluid spinner-modal': this.props.size === SpinnerSize.modal,
+        });
+        return (external_react_default().createElement("div", { className: containerClassName },
+            external_react_default().createElement("div", { className: spinnerClassName },
+                external_react_default().createElement("div", { className: 'spinner-dot1' },
+                    external_react_default().createElement("div", { className: 'spinner-leaf' }, this.renderLeaf())),
+                external_react_default().createElement("div", { className: 'spinner-dot2' },
+                    external_react_default().createElement("div", { className: 'spinner-leaf' }, this.renderLeaf())),
+                external_react_default().createElement("div", { className: 'spinner-dot3' },
+                    external_react_default().createElement("div", { className: 'spinner-leaf' }, this.renderLeaf())),
+                external_react_default().createElement("span", { className: 'spinner-letter' }, this.renderLetter()))));
+    };
+    Spinner.prototype.render = function () {
+        switch (this.props.size) {
+            case SpinnerSize.mini:
+                return this.renderMini();
+            case SpinnerSize.small:
+                return this.renderSmall();
+            case SpinnerSize.big:
+            case SpinnerSize.modal:
+                return this.renderBig();
+            default:
+                return null;
+        }
+    };
+    Spinner.displayName = 'Spinner';
+    Spinner.defaultProps = {
+        size: SpinnerSize.small,
+        className: '',
+    };
+    return Spinner;
+}((external_react_default()).Component));
+
+
+;// CONCATENATED MODULE: ./src/components/Spinner/index.ts
+
+
+
+/***/ }),
+
+/***/ 2755:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "KH": () => (/* binding */ blue30),
+/* harmony export */   "p5": () => (/* binding */ blue300),
+/* harmony export */   "$y": () => (/* binding */ orange)
+/* harmony export */ });
+/* unused harmony exports calculateDomain, generateRangeColor, white, blue25, blue50, blue80, blue90, blue95, blue100, gray200, blue400, yellow, red, green, gray100, gray300, gray400, purple, viola, pink100, pink200, salmon, black */
+
+function generateRangeColor(len, rangeColors) {
+    if (rangeColors === void 0) { rangeColors = ['#82CA9D', '#f6ea25', '#F7977A']; }
+    var generatedColors = [];
+    if (len === 0) {
+        return undefined;
+    }
+    var colors = scaleLinear(), domain = calculateDomain(rangeColors.length, rangeColors.length), targetDomain = calculateDomain(len, rangeColors.length);
+    colors = colors.domain(domain).range(rangeColors);
+    for (var i = 0; i < len; i++) {
+        generatedColors.push(colors(targetDomain[i]));
+    }
+    return generatedColors;
+}
+function calculateDomain(len, rangeColorsLength) {
+    var domain = [];
+    domain.push(0);
+    for (var i = 0; i < len - 2; i++) {
+        var num = Number((rangeColorsLength / len) * (i + 1));
+        domain.push(parseFloat(num.toFixed(2)));
+    }
+    domain.push(rangeColorsLength);
+    return domain;
+}
+// Keep these in sync with variables.less
+var white = '#FFFFFF', blue25 = '#eef2f5', blue30 = '#CBD8E0', blue50 = '#AFD1E0', blue80 = '#8FB7CB', blue90 = '#94C2DA', blue95 = '#6E9DB5', blue100 = '#578EA8', blue300 = 'rgb(32, 88, 113)', // #205871
+blue400 = '#11455C', gray100 = '#FAFAFA', gray200 = '#EBEBEB', gray300 = '#B0B0B0', gray400 = '#717171', yellow = '#FFBB00', orange = '#F38522', red = '#F72200', green = '#309B0A', purple = '#63619F', viola = '#965DA3', pink200 = '#C55795', pink100 = '#E85778', salmon = '#F86752', black = '#222222';
+
+
+
+/***/ }),
+
+/***/ 6347:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "lV": () => (/* binding */ slugify)
+/* harmony export */ });
+/* unused harmony exports isStringEmpty, estimateWordSize, ellipse, matchAndFormatRangeLabel, formatRange, ellipseAndFormat, escapeRegExp, isMatching, splitTextInParts */
+var __values = (undefined && undefined.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (undefined && undefined.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+function isStringEmpty(s) {
+    if (s == null) {
+        return true;
+    }
+    return s.match(/^\s*$/) !== null;
+}
+function slugify(text) {
+    var a = 'àáâäæãåāăąçćčđďèéêëēėęěğǵḧîïíīįìłḿñńǹňôöòóœøōõőṕŕřßśšşșťțûüùúūǘůűųẃẍÿýžźż·/_,:;', b = 'aaaaaaaaaacccddeeeeeeeegghiiiiiilmnnnnoooooooooprrsssssttuuuuuuuuuwxyyzzz------', p = new RegExp(a.split('').join('|'), 'g');
+    return text
+        .toString()
+        .toLowerCase()
+        .replace(/\s+/g, '-') // Replace spaces with -
+        .replace(p, function (c) { return b.charAt(a.indexOf(c)); }) // Replace special characters
+        .replace(/&/g, '-and-') // Replace & with 'and'
+        .replace(/[^\w-]+/g, '') // Remove all non-word characters
+        .replace(/--+/g, '-') // Replace multiple - with single -
+        .replace(/^-+/, '') // Trim - from start of text
+        .replace(/-+$/, ''); // Trim - from end of text
+}
+function estimateWordSize(wordLength, letterPixels, constant) {
+    return wordLength * letterPixels + constant;
+}
+function ellipse(input, length) {
+    if (input == null) {
+        return '';
+    }
+    return input.length > length ? input.substr(0, length - 1) + "\u2026" : input;
+}
+function matchAndFormatRangeLabel(formatter) {
+    return function (label) {
+        var match = /^([\d*]+)-([\d*]+)$/.exec(label);
+        if (match == null) {
+            return label;
+        }
+        return formatRange({
+            from: match[1],
+            to: match[2],
+        }, formatter !== null && formatter !== void 0 ? formatter : (function (v) { return v; }));
+    };
+}
+function formatRange(item, formatter) {
+    var _a, _b;
+    var to = item.to === '*' ? '*' : formatter(parseInt((_a = item.to) !== null && _a !== void 0 ? _a : '0', 10)), from = formatter(parseInt((_b = item.from) !== null && _b !== void 0 ? _b : '0', 10));
+    if (from === to) {
+        return "" + from;
+    }
+    return from + " - " + to;
+}
+function ellipseAndFormat(formatter, maxLabelLength) {
+    return function (value) {
+        var strValue = value.toString();
+        if (formatter == null) {
+            return ellipse(strValue, maxLabelLength);
+        }
+        return ellipse("" + formatter(strValue), maxLabelLength);
+    };
+}
+function escapeRegExp(input) {
+    // eslint-disable-next-line
+    return input.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+}
+function isMatching(text0, text1) {
+    var e_1, _a;
+    if (text0 == null || text1 == null) {
+        return false;
+    }
+    text0 = text0.toLowerCase();
+    text1 = text1.toLowerCase();
+    if (text1.match(' ') === null) {
+        return text0.match(escapeRegExp(text1)) !== null;
+    }
+    var splitNeedles = text1
+        .split(' ')
+        .filter(function (s) { return !isStringEmpty(s); })
+        .sort(function (a, b) { return b.length - a.length; });
+    try {
+        for (var splitNeedles_1 = __values(splitNeedles), splitNeedles_1_1 = splitNeedles_1.next(); !splitNeedles_1_1.done; splitNeedles_1_1 = splitNeedles_1.next()) {
+            var needle = splitNeedles_1_1.value;
+            if (text0 === needle) {
+                return true;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (splitNeedles_1_1 && !splitNeedles_1_1.done && (_a = splitNeedles_1.return)) _a.call(splitNeedles_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return false;
+}
+function splitTextInParts(needles, text) {
+    var e_2, _a;
+    if (text == null) {
+        return [];
+    }
+    if (needles.match(' ') === null) {
+        var re = new RegExp('(' + escapeRegExp(needles) + ')', 'gi');
+        return text.split(re);
+    }
+    var splitNeedles = needles
+        .split(' ')
+        .filter(function (s) { return !isStringEmpty(s); })
+        .sort(function (a, b) { return b.length - a.length; }), ret = [text];
+    try {
+        for (var splitNeedles_2 = __values(splitNeedles), splitNeedles_2_1 = splitNeedles_2.next(); !splitNeedles_2_1.done; splitNeedles_2_1 = splitNeedles_2.next()) {
+            var needle = splitNeedles_2_1.value;
+            var re = new RegExp('(' + needle + ')', 'gi');
+            for (var index = 0; index < ret.length; index++) {
+                var currentText = ret[index];
+                if (isMatching(currentText, escapeRegExp(needles))) {
+                    continue;
+                }
+                var newParts = currentText.split(re).filter(function (s) { return s !== ''; });
+                ret.splice.apply(ret, __spread([index, 1], newParts));
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (splitNeedles_2_1 && !splitNeedles_2_1.done && (_a = splitNeedles_2.return)) _a.call(splitNeedles_2);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return ret;
+}
+
+
+/***/ }),
+
+/***/ 5654:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "z8": () => (/* binding */ findChildByComponent)
+/* harmony export */ });
+/* unused harmony exports findChildrenByComponent, hasChildIconOrCheckboxComponent, scrollToTop, zip, sortObjDesc, clone, getDebouncer, deepEqual, rgbToHex */
+/* harmony import */ var _fortawesome_react_fontawesome__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5692);
+/* harmony import */ var _fortawesome_react_fontawesome__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_fortawesome_react_fontawesome__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8156);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _Form_Form__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9316);
+var __read = (undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+
+
+
+function findChildrenByComponent(children, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+component) {
+    var ret = [];
+    react__WEBPACK_IMPORTED_MODULE_1___default().Children.forEach(children, function (element) {
+        if ((element === null || element === void 0 ? void 0 : element.type) === component) {
+            ret.push(element);
+        }
+    });
+    return ret;
+}
+function findChildByComponent(children, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+component) {
+    var _a, _b;
+    return (_b = (_a = findChildrenByComponent(children, component)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : null;
+}
+function hasChildIconOrCheckboxComponent(children) {
+    var ret = false;
+    React.Children.forEach(children, function (element) {
+        if ((element === null || element === void 0 ? void 0 : element.type) != null &&
+            ((element === null || element === void 0 ? void 0 : element.type) === FontAwesomeIcon || (element === null || element === void 0 ? void 0 : element.type) === 'i' || (element === null || element === void 0 ? void 0 : element.type) === Form.Checkbox)) {
+            ret = true;
+            return;
+        }
+    });
+    return ret;
+}
+function scrollToTop() {
+    window.scrollTo(0, 0);
+}
+function zip(arr1, arr2) {
+    var ret = [];
+    var i = 0;
+    while (arr1[i]) {
+        ret.push(arr1[i]);
+        ret.push(arr2[i++]);
+    }
+    return ret;
+}
+// eslint-disable-next-line @typescript-eslint/ban-types
+function sortObjDesc(accessor) {
+    return function (a, b) {
+        var leftVal = 0, rightVal = 0;
+        if ((a === null || a === void 0 ? void 0 : a[accessor]) != null) {
+            leftVal = a === null || a === void 0 ? void 0 : a[accessor];
+        }
+        if ((b === null || b === void 0 ? void 0 : b[accessor]) != null) {
+            rightVal = b === null || b === void 0 ? void 0 : b[accessor];
+        }
+        return leftVal > rightVal ? -1 : 1;
+    };
+}
+function clone(ob) {
+    return JSON.parse(JSON.stringify(ob));
+}
+function getDebouncer(delay) {
+    if (delay === void 0) { delay = 1; }
+    var debounceTimeout = null;
+    return function debounce(f) {
+        if (debounceTimeout !== null) {
+            clearTimeout(debounceTimeout);
+        }
+        debounceTimeout = window.setTimeout(f, delay);
+    };
+}
+function isObject(obj) {
+    return typeof obj === 'object' && obj != null;
+}
+function deepEqual(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (isObject(obj1) && isObject(obj2)) {
+        if (Object.keys(obj1).length !== Object.keys(obj2).length) {
+            return false;
+        }
+        for (var prop in obj1) {
+            if (!deepEqual(obj1[prop], obj2[prop])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function componentToHex(c) {
+    if (isNaN(c)) {
+        throw Error('The color has not been written correctly');
+    }
+    var hex = c.toString(16).toUpperCase();
+    return hex.length === 1 ? '0' + hex : hex;
+}
+function cleanSingleColor(c) {
+    return c.replace(/"|'/g, '').trim();
+}
+function rgbToHex(rgb) {
+    if (rgb.includes('rgba')) {
+        throw Error('not implemented');
+    }
+    var _a = __read(rgb
+        .replace('rgb', '')
+        .replace(/\(|\)/gi, '')
+        .split(',')
+        .map(function (c) { return parseInt(cleanSingleColor(c), 10); }), 3), _b = _a[0], r = _b === void 0 ? 0 : _b, _c = _a[1], g = _c === void 0 ? 0 : _c, _d = _a[2], b = _d === void 0 ? 0 : _d;
+    return '#' + componentToHex(r) + componentToHex(g) + componentToHex(b);
+}
+
+
+/***/ }),
+
+/***/ 6496:
+/***/ ((module) => {
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    module.exports = _typeof = function _typeof(obj) {
+      return typeof obj;
+    };
+
+    module.exports["default"] = module.exports, module.exports.__esModule = true;
+  } else {
+    module.exports = _typeof = function _typeof(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+
+    module.exports["default"] = module.exports, module.exports.__esModule = true;
+  }
+
+  return _typeof(obj);
+}
+
+module.exports = _typeof;
+module.exports["default"] = module.exports, module.exports.__esModule = true;
+
+/***/ }),
+
+/***/ 9673:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = __webpack_require__(3538);
+
+/***/ }),
+
+/***/ 6627:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "MR": () => (/* binding */ boundMethod),
+/* harmony export */   "ZP": () => (/* binding */ autobind)
+/* harmony export */ });
+/* unused harmony export boundClass */
+/* harmony import */ var _babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4329);
+
+
+function _typeof(obj) {
+  if (typeof Symbol === "function" && (0,_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(Symbol.iterator) === "symbol") {
+    _typeof = function _typeof(obj) {
+      return (0,_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(obj);
+    };
+  } else {
+    _typeof = function _typeof(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : (0,_babel_runtime_helpers_typeof__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(obj);
+    };
+  }
+
+  return _typeof(obj);
+}
+/**
+ * Return a descriptor removing the value and returning a getter
+ * The getter will return a .bind version of the function
+ * and memoize the result against a symbol on the instance
+ */
+
+
+function boundMethod(target, key, descriptor) {
+  var fn = descriptor.value;
+
+  if (typeof fn !== 'function') {
+    throw new TypeError("@boundMethod decorator can only be applied to methods not: ".concat(_typeof(fn)));
+  } // In IE11 calling Object.defineProperty has a side-effect of evaluating the
+  // getter for the property which is being replaced. This causes infinite
+  // recursion and an "Out of stack space" error.
+
+
+  var definingProperty = false;
+  return {
+    configurable: true,
+    get: function get() {
+      // eslint-disable-next-line no-prototype-builtins
+      if (definingProperty || this === target.prototype || this.hasOwnProperty(key) || typeof fn !== 'function') {
+        return fn;
+      }
+
+      var boundFn = fn.bind(this);
+      definingProperty = true;
+      Object.defineProperty(this, key, {
+        configurable: true,
+        get: function get() {
+          return boundFn;
+        },
+        set: function set(value) {
+          fn = value;
+          delete this[key];
+        }
+      });
+      definingProperty = false;
+      return boundFn;
+    },
+    set: function set(value) {
+      fn = value;
+    }
+  };
+}
+/**
+ * Use boundMethod to bind all methods on the target.prototype
+ */
+
+function boundClass(target) {
+  // (Using reflect to get all keys including symbols)
+  var keys; // Use Reflect if exists
+
+  if (typeof Reflect !== 'undefined' && typeof Reflect.ownKeys === 'function') {
+    keys = Reflect.ownKeys(target.prototype);
+  } else {
+    keys = Object.getOwnPropertyNames(target.prototype); // Use symbols if support is provided
+
+    if (typeof Object.getOwnPropertySymbols === 'function') {
+      keys = keys.concat(Object.getOwnPropertySymbols(target.prototype));
+    }
+  }
+
+  keys.forEach(function (key) {
+    // Ignore special case target method
+    if (key === 'constructor') {
+      return;
+    }
+
+    var descriptor = Object.getOwnPropertyDescriptor(target.prototype, key); // Only methods need binding
+
+    if (typeof descriptor.value === 'function') {
+      Object.defineProperty(target.prototype, key, boundMethod(target, key, descriptor));
+    }
+  });
+  return target;
+}
+function autobind() {
+  if (arguments.length === 1) {
+    return boundClass.apply(void 0, arguments);
+  }
+
+  return boundMethod.apply(void 0, arguments);
+}
+
+/***/ }),
+
+/***/ 2766:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "ZP": () => (/* binding */ color),
+  "B8": () => (/* binding */ rgb)
+});
+
+// UNUSED EXPORTS: Color, Rgb, brighter, darker, hsl, hslConvert, rgbConvert
+
+;// CONCATENATED MODULE: ./node_modules/d3-color/src/define.js
+/* harmony default export */ function src_define(constructor, factory, prototype) {
+  constructor.prototype = factory.prototype = prototype;
+  prototype.constructor = constructor;
+}
+function extend(parent, definition) {
+  var prototype = Object.create(parent.prototype);
+
+  for (var key in definition) {
+    prototype[key] = definition[key];
+  }
+
+  return prototype;
+}
+;// CONCATENATED MODULE: ./node_modules/d3-color/src/color.js
+
+function Color() {}
+var _darker = 0.7;
+
+
+var _brighter = 1 / _darker;
+
+
+var reI = "\\s*([+-]?\\d+)\\s*",
+    reN = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",
+    reP = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",
+    reHex = /^#([0-9a-f]{3,8})$/,
+    reRgbInteger = new RegExp("^rgb\\(" + [reI, reI, reI] + "\\)$"),
+    reRgbPercent = new RegExp("^rgb\\(" + [reP, reP, reP] + "\\)$"),
+    reRgbaInteger = new RegExp("^rgba\\(" + [reI, reI, reI, reN] + "\\)$"),
+    reRgbaPercent = new RegExp("^rgba\\(" + [reP, reP, reP, reN] + "\\)$"),
+    reHslPercent = new RegExp("^hsl\\(" + [reN, reP, reP] + "\\)$"),
+    reHslaPercent = new RegExp("^hsla\\(" + [reN, reP, reP, reN] + "\\)$");
+var named = {
+  aliceblue: 0xf0f8ff,
+  antiquewhite: 0xfaebd7,
+  aqua: 0x00ffff,
+  aquamarine: 0x7fffd4,
+  azure: 0xf0ffff,
+  beige: 0xf5f5dc,
+  bisque: 0xffe4c4,
+  black: 0x000000,
+  blanchedalmond: 0xffebcd,
+  blue: 0x0000ff,
+  blueviolet: 0x8a2be2,
+  brown: 0xa52a2a,
+  burlywood: 0xdeb887,
+  cadetblue: 0x5f9ea0,
+  chartreuse: 0x7fff00,
+  chocolate: 0xd2691e,
+  coral: 0xff7f50,
+  cornflowerblue: 0x6495ed,
+  cornsilk: 0xfff8dc,
+  crimson: 0xdc143c,
+  cyan: 0x00ffff,
+  darkblue: 0x00008b,
+  darkcyan: 0x008b8b,
+  darkgoldenrod: 0xb8860b,
+  darkgray: 0xa9a9a9,
+  darkgreen: 0x006400,
+  darkgrey: 0xa9a9a9,
+  darkkhaki: 0xbdb76b,
+  darkmagenta: 0x8b008b,
+  darkolivegreen: 0x556b2f,
+  darkorange: 0xff8c00,
+  darkorchid: 0x9932cc,
+  darkred: 0x8b0000,
+  darksalmon: 0xe9967a,
+  darkseagreen: 0x8fbc8f,
+  darkslateblue: 0x483d8b,
+  darkslategray: 0x2f4f4f,
+  darkslategrey: 0x2f4f4f,
+  darkturquoise: 0x00ced1,
+  darkviolet: 0x9400d3,
+  deeppink: 0xff1493,
+  deepskyblue: 0x00bfff,
+  dimgray: 0x696969,
+  dimgrey: 0x696969,
+  dodgerblue: 0x1e90ff,
+  firebrick: 0xb22222,
+  floralwhite: 0xfffaf0,
+  forestgreen: 0x228b22,
+  fuchsia: 0xff00ff,
+  gainsboro: 0xdcdcdc,
+  ghostwhite: 0xf8f8ff,
+  gold: 0xffd700,
+  goldenrod: 0xdaa520,
+  gray: 0x808080,
+  green: 0x008000,
+  greenyellow: 0xadff2f,
+  grey: 0x808080,
+  honeydew: 0xf0fff0,
+  hotpink: 0xff69b4,
+  indianred: 0xcd5c5c,
+  indigo: 0x4b0082,
+  ivory: 0xfffff0,
+  khaki: 0xf0e68c,
+  lavender: 0xe6e6fa,
+  lavenderblush: 0xfff0f5,
+  lawngreen: 0x7cfc00,
+  lemonchiffon: 0xfffacd,
+  lightblue: 0xadd8e6,
+  lightcoral: 0xf08080,
+  lightcyan: 0xe0ffff,
+  lightgoldenrodyellow: 0xfafad2,
+  lightgray: 0xd3d3d3,
+  lightgreen: 0x90ee90,
+  lightgrey: 0xd3d3d3,
+  lightpink: 0xffb6c1,
+  lightsalmon: 0xffa07a,
+  lightseagreen: 0x20b2aa,
+  lightskyblue: 0x87cefa,
+  lightslategray: 0x778899,
+  lightslategrey: 0x778899,
+  lightsteelblue: 0xb0c4de,
+  lightyellow: 0xffffe0,
+  lime: 0x00ff00,
+  limegreen: 0x32cd32,
+  linen: 0xfaf0e6,
+  magenta: 0xff00ff,
+  maroon: 0x800000,
+  mediumaquamarine: 0x66cdaa,
+  mediumblue: 0x0000cd,
+  mediumorchid: 0xba55d3,
+  mediumpurple: 0x9370db,
+  mediumseagreen: 0x3cb371,
+  mediumslateblue: 0x7b68ee,
+  mediumspringgreen: 0x00fa9a,
+  mediumturquoise: 0x48d1cc,
+  mediumvioletred: 0xc71585,
+  midnightblue: 0x191970,
+  mintcream: 0xf5fffa,
+  mistyrose: 0xffe4e1,
+  moccasin: 0xffe4b5,
+  navajowhite: 0xffdead,
+  navy: 0x000080,
+  oldlace: 0xfdf5e6,
+  olive: 0x808000,
+  olivedrab: 0x6b8e23,
+  orange: 0xffa500,
+  orangered: 0xff4500,
+  orchid: 0xda70d6,
+  palegoldenrod: 0xeee8aa,
+  palegreen: 0x98fb98,
+  paleturquoise: 0xafeeee,
+  palevioletred: 0xdb7093,
+  papayawhip: 0xffefd5,
+  peachpuff: 0xffdab9,
+  peru: 0xcd853f,
+  pink: 0xffc0cb,
+  plum: 0xdda0dd,
+  powderblue: 0xb0e0e6,
+  purple: 0x800080,
+  rebeccapurple: 0x663399,
+  red: 0xff0000,
+  rosybrown: 0xbc8f8f,
+  royalblue: 0x4169e1,
+  saddlebrown: 0x8b4513,
+  salmon: 0xfa8072,
+  sandybrown: 0xf4a460,
+  seagreen: 0x2e8b57,
+  seashell: 0xfff5ee,
+  sienna: 0xa0522d,
+  silver: 0xc0c0c0,
+  skyblue: 0x87ceeb,
+  slateblue: 0x6a5acd,
+  slategray: 0x708090,
+  slategrey: 0x708090,
+  snow: 0xfffafa,
+  springgreen: 0x00ff7f,
+  steelblue: 0x4682b4,
+  tan: 0xd2b48c,
+  teal: 0x008080,
+  thistle: 0xd8bfd8,
+  tomato: 0xff6347,
+  turquoise: 0x40e0d0,
+  violet: 0xee82ee,
+  wheat: 0xf5deb3,
+  white: 0xffffff,
+  whitesmoke: 0xf5f5f5,
+  yellow: 0xffff00,
+  yellowgreen: 0x9acd32
+};
+src_define(Color, color, {
+  copy: function copy(channels) {
+    return Object.assign(new this.constructor(), this, channels);
+  },
+  displayable: function displayable() {
+    return this.rgb().displayable();
+  },
+  hex: color_formatHex,
+  // Deprecated! Use color.formatHex.
+  formatHex: color_formatHex,
+  formatHsl: color_formatHsl,
+  formatRgb: color_formatRgb,
+  toString: color_formatRgb
+});
+
+function color_formatHex() {
+  return this.rgb().formatHex();
+}
+
+function color_formatHsl() {
+  return hslConvert(this).formatHsl();
+}
+
+function color_formatRgb() {
+  return this.rgb().formatRgb();
+}
+
+function color(format) {
+  var m, l;
+  format = (format + "").trim().toLowerCase();
+  return (m = reHex.exec(format)) ? (l = m[1].length, m = parseInt(m[1], 16), l === 6 ? rgbn(m) // #ff0000
+  : l === 3 ? new Rgb(m >> 8 & 0xf | m >> 4 & 0xf0, m >> 4 & 0xf | m & 0xf0, (m & 0xf) << 4 | m & 0xf, 1) // #f00
+  : l === 8 ? rgba(m >> 24 & 0xff, m >> 16 & 0xff, m >> 8 & 0xff, (m & 0xff) / 0xff) // #ff000000
+  : l === 4 ? rgba(m >> 12 & 0xf | m >> 8 & 0xf0, m >> 8 & 0xf | m >> 4 & 0xf0, m >> 4 & 0xf | m & 0xf0, ((m & 0xf) << 4 | m & 0xf) / 0xff) // #f000
+  : null // invalid hex
+  ) : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0)
+  : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%)
+  : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)
+  : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1)
+  : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)
+  : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)
+  : named.hasOwnProperty(format) ? rgbn(named[format]) // eslint-disable-line no-prototype-builtins
+  : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0) : null;
+}
+
+function rgbn(n) {
+  return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);
+}
+
+function rgba(r, g, b, a) {
+  if (a <= 0) r = g = b = NaN;
+  return new Rgb(r, g, b, a);
+}
+
+function rgbConvert(o) {
+  if (!(o instanceof Color)) o = color(o);
+  if (!o) return new Rgb();
+  o = o.rgb();
+  return new Rgb(o.r, o.g, o.b, o.opacity);
+}
+function rgb(r, g, b, opacity) {
+  return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);
+}
+function Rgb(r, g, b, opacity) {
+  this.r = +r;
+  this.g = +g;
+  this.b = +b;
+  this.opacity = +opacity;
+}
+src_define(Rgb, rgb, extend(Color, {
+  brighter: function brighter(k) {
+    k = k == null ? _brighter : Math.pow(_brighter, k);
+    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+  },
+  darker: function darker(k) {
+    k = k == null ? _darker : Math.pow(_darker, k);
+    return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+  },
+  rgb: function rgb() {
+    return this;
+  },
+  displayable: function displayable() {
+    return -0.5 <= this.r && this.r < 255.5 && -0.5 <= this.g && this.g < 255.5 && -0.5 <= this.b && this.b < 255.5 && 0 <= this.opacity && this.opacity <= 1;
+  },
+  hex: rgb_formatHex,
+  // Deprecated! Use color.formatHex.
+  formatHex: rgb_formatHex,
+  formatRgb: rgb_formatRgb,
+  toString: rgb_formatRgb
+}));
+
+function rgb_formatHex() {
+  return "#" + hex(this.r) + hex(this.g) + hex(this.b);
+}
+
+function rgb_formatRgb() {
+  var a = this.opacity;
+  a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));
+  return (a === 1 ? "rgb(" : "rgba(") + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", " + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", " + Math.max(0, Math.min(255, Math.round(this.b) || 0)) + (a === 1 ? ")" : ", " + a + ")");
+}
+
+function hex(value) {
+  value = Math.max(0, Math.min(255, Math.round(value) || 0));
+  return (value < 16 ? "0" : "") + value.toString(16);
+}
+
+function hsla(h, s, l, a) {
+  if (a <= 0) h = s = l = NaN;else if (l <= 0 || l >= 1) h = s = NaN;else if (s <= 0) h = NaN;
+  return new Hsl(h, s, l, a);
+}
+
+function hslConvert(o) {
+  if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);
+  if (!(o instanceof Color)) o = color(o);
+  if (!o) return new Hsl();
+  if (o instanceof Hsl) return o;
+  o = o.rgb();
+  var r = o.r / 255,
+      g = o.g / 255,
+      b = o.b / 255,
+      min = Math.min(r, g, b),
+      max = Math.max(r, g, b),
+      h = NaN,
+      s = max - min,
+      l = (max + min) / 2;
+
+  if (s) {
+    if (r === max) h = (g - b) / s + (g < b) * 6;else if (g === max) h = (b - r) / s + 2;else h = (r - g) / s + 4;
+    s /= l < 0.5 ? max + min : 2 - max - min;
+    h *= 60;
+  } else {
+    s = l > 0 && l < 1 ? 0 : h;
+  }
+
+  return new Hsl(h, s, l, o.opacity);
+}
+function hsl(h, s, l, opacity) {
+  return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);
+}
+
+function Hsl(h, s, l, opacity) {
+  this.h = +h;
+  this.s = +s;
+  this.l = +l;
+  this.opacity = +opacity;
+}
+
+src_define(Hsl, hsl, extend(Color, {
+  brighter: function brighter(k) {
+    k = k == null ? _brighter : Math.pow(_brighter, k);
+    return new Hsl(this.h, this.s, this.l * k, this.opacity);
+  },
+  darker: function darker(k) {
+    k = k == null ? _darker : Math.pow(_darker, k);
+    return new Hsl(this.h, this.s, this.l * k, this.opacity);
+  },
+  rgb: function rgb() {
+    var h = this.h % 360 + (this.h < 0) * 360,
+        s = isNaN(h) || isNaN(this.s) ? 0 : this.s,
+        l = this.l,
+        m2 = l + (l < 0.5 ? l : 1 - l) * s,
+        m1 = 2 * l - m2;
+    return new Rgb(hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), hsl2rgb(h, m1, m2), hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), this.opacity);
+  },
+  displayable: function displayable() {
+    return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && 0 <= this.l && this.l <= 1 && 0 <= this.opacity && this.opacity <= 1;
+  },
+  formatHsl: function formatHsl() {
+    var a = this.opacity;
+    a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));
+    return (a === 1 ? "hsl(" : "hsla(") + (this.h || 0) + ", " + (this.s || 0) * 100 + "%, " + (this.l || 0) * 100 + "%" + (a === 1 ? ")" : ", " + a + ")");
+  }
+}));
+/* From FvD 13.37, CSS Color Module Level 3 */
+
+function hsl2rgb(h, m1, m2) {
+  return (h < 60 ? m1 + (m2 - m1) * h / 60 : h < 180 ? m2 : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 : m1) * 255;
+}
+
+/***/ }),
+
+/***/ 1820:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "Z": () => (/* binding */ linear_linear)
+});
+
+// UNUSED EXPORTS: linearish
+
+;// CONCATENATED MODULE: ./node_modules/d3-array/src/ticks.js
+var e10 = Math.sqrt(50),
+    e5 = Math.sqrt(10),
+    e2 = Math.sqrt(2);
+/* harmony default export */ function ticks(start, stop, count) {
+  var reverse,
+      i = -1,
+      n,
+      ticks,
+      step;
+  stop = +stop, start = +start, count = +count;
+  if (start === stop && count > 0) return [start];
+  if (reverse = stop < start) n = start, start = stop, stop = n;
+  if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];
+
+  if (step > 0) {
+    var r0 = Math.round(start / step),
+        r1 = Math.round(stop / step);
+    if (r0 * step < start) ++r0;
+    if (r1 * step > stop) --r1;
+    ticks = new Array(n = r1 - r0 + 1);
+
+    while (++i < n) {
+      ticks[i] = (r0 + i) * step;
+    }
+  } else {
+    step = -step;
+
+    var _r = Math.round(start * step),
+        _r2 = Math.round(stop * step);
+
+    if (_r / step < start) ++_r;
+    if (_r2 / step > stop) --_r2;
+    ticks = new Array(n = _r2 - _r + 1);
+
+    while (++i < n) {
+      ticks[i] = (_r + i) / step;
+    }
+  }
+
+  if (reverse) ticks.reverse();
+  return ticks;
+}
+function tickIncrement(start, stop, count) {
+  var step = (stop - start) / Math.max(0, count),
+      power = Math.floor(Math.log(step) / Math.LN10),
+      error = step / Math.pow(10, power);
+  return power >= 0 ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power) : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
+}
+function tickStep(start, stop, count) {
+  var step0 = Math.abs(stop - start) / Math.max(0, count),
+      step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),
+      error = step0 / step1;
+  if (error >= e10) step1 *= 10;else if (error >= e5) step1 *= 5;else if (error >= e2) step1 *= 2;
+  return stop < start ? -step1 : step1;
+}
+;// CONCATENATED MODULE: ./node_modules/d3-array/src/ascending.js
+/* harmony default export */ function ascending(a, b) {
+  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+}
+;// CONCATENATED MODULE: ./node_modules/d3-array/src/bisector.js
+
+/* harmony default export */ function bisector(f) {
+  var delta = f;
+  var compare = f;
+
+  if (f.length === 1) {
+    delta = function delta(d, x) {
+      return f(d) - x;
+    };
+
+    compare = ascendingComparator(f);
+  }
+
+  function left(a, x, lo, hi) {
+    if (lo == null) lo = 0;
+    if (hi == null) hi = a.length;
+
+    while (lo < hi) {
+      var mid = lo + hi >>> 1;
+      if (compare(a[mid], x) < 0) lo = mid + 1;else hi = mid;
+    }
+
+    return lo;
+  }
+
+  function right(a, x, lo, hi) {
+    if (lo == null) lo = 0;
+    if (hi == null) hi = a.length;
+
+    while (lo < hi) {
+      var mid = lo + hi >>> 1;
+      if (compare(a[mid], x) > 0) hi = mid;else lo = mid + 1;
+    }
+
+    return lo;
+  }
+
+  function center(a, x, lo, hi) {
+    if (lo == null) lo = 0;
+    if (hi == null) hi = a.length;
+    var i = left(a, x, lo, hi - 1);
+    return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
+  }
+
+  return {
+    left: left,
+    center: center,
+    right: right
+  };
+}
+
+function ascendingComparator(f) {
+  return function (d, x) {
+    return ascending(f(d), x);
+  };
+}
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/regenerator/index.js
+var regenerator = __webpack_require__(9673);
+var regenerator_default = /*#__PURE__*/__webpack_require__.n(regenerator);
+;// CONCATENATED MODULE: ./node_modules/d3-array/src/number.js
+
+
+var _marked = /*#__PURE__*/regenerator_default().mark(numbers);
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+/* harmony default export */ function number(x) {
+  return x === null ? NaN : +x;
+}
+function numbers(values, valueof) {
+  var _iterator, _step, value, index, _iterator2, _step2, _value;
+
+  return regenerator_default().wrap(function numbers$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          if (!(valueof === undefined)) {
+            _context.next = 21;
+            break;
+          }
+
+          _iterator = _createForOfIteratorHelper(values);
+          _context.prev = 2;
+
+          _iterator.s();
+
+        case 4:
+          if ((_step = _iterator.n()).done) {
+            _context.next = 11;
+            break;
+          }
+
+          value = _step.value;
+
+          if (!(value != null && (value = +value) >= value)) {
+            _context.next = 9;
+            break;
+          }
+
+          _context.next = 9;
+          return value;
+
+        case 9:
+          _context.next = 4;
+          break;
+
+        case 11:
+          _context.next = 16;
+          break;
+
+        case 13:
+          _context.prev = 13;
+          _context.t0 = _context["catch"](2);
+
+          _iterator.e(_context.t0);
+
+        case 16:
+          _context.prev = 16;
+
+          _iterator.f();
+
+          return _context.finish(16);
+
+        case 19:
+          _context.next = 40;
+          break;
+
+        case 21:
+          index = -1;
+          _iterator2 = _createForOfIteratorHelper(values);
+          _context.prev = 23;
+
+          _iterator2.s();
+
+        case 25:
+          if ((_step2 = _iterator2.n()).done) {
+            _context.next = 32;
+            break;
+          }
+
+          _value = _step2.value;
+
+          if (!((_value = valueof(_value, ++index, values)) != null && (_value = +_value) >= _value)) {
+            _context.next = 30;
+            break;
+          }
+
+          _context.next = 30;
+          return _value;
+
+        case 30:
+          _context.next = 25;
+          break;
+
+        case 32:
+          _context.next = 37;
+          break;
+
+        case 34:
+          _context.prev = 34;
+          _context.t1 = _context["catch"](23);
+
+          _iterator2.e(_context.t1);
+
+        case 37:
+          _context.prev = 37;
+
+          _iterator2.f();
+
+          return _context.finish(37);
+
+        case 40:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _marked, null, [[2, 13, 16, 19], [23, 34, 37, 40]]);
+}
+;// CONCATENATED MODULE: ./node_modules/d3-array/src/bisect.js
+
+
+
+var ascendingBisect = bisector(ascending);
+var bisectRight = ascendingBisect.right;
+var bisectLeft = ascendingBisect.left;
+var bisectCenter = bisector(number).center;
+/* harmony default export */ const bisect = (bisectRight);
+// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
+var esm_typeof = __webpack_require__(4329);
+// EXTERNAL MODULE: ./node_modules/d3-color/src/color.js + 1 modules
+var src_color = __webpack_require__(2766);
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/basis.js
+function basis(t1, v0, v1, v2, v3) {
+  var t2 = t1 * t1,
+      t3 = t2 * t1;
+  return ((1 - 3 * t1 + 3 * t2 - t3) * v0 + (4 - 6 * t2 + 3 * t3) * v1 + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2 + t3 * v3) / 6;
+}
+/* harmony default export */ function src_basis(values) {
+  var n = values.length - 1;
+  return function (t) {
+    var i = t <= 0 ? t = 0 : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n),
+        v1 = values[i],
+        v2 = values[i + 1],
+        v0 = i > 0 ? values[i - 1] : 2 * v1 - v2,
+        v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1;
+    return basis((t - i / n) * n, v0, v1, v2, v3);
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/basisClosed.js
+
+/* harmony default export */ function basisClosed(values) {
+  var n = values.length;
+  return function (t) {
+    var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n),
+        v0 = values[(i + n - 1) % n],
+        v1 = values[i % n],
+        v2 = values[(i + 1) % n],
+        v3 = values[(i + 2) % n];
+    return basis((t - i / n) * n, v0, v1, v2, v3);
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/constant.js
+/* harmony default export */ const src_constant = (function (x) {
+  return function () {
+    return x;
+  };
+});
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/color.js
+
+
+function linear(a, d) {
+  return function (t) {
+    return a + t * d;
+  };
+}
+
+function exponential(a, b, y) {
+  return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function (t) {
+    return Math.pow(a + t * b, y);
+  };
+}
+
+function hue(a, b) {
+  var d = b - a;
+  return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant(isNaN(a) ? b : a);
+}
+function gamma(y) {
+  return (y = +y) === 1 ? nogamma : function (a, b) {
+    return b - a ? exponential(a, b, y) : src_constant(isNaN(a) ? b : a);
+  };
+}
+function nogamma(a, b) {
+  var d = b - a;
+  return d ? linear(a, d) : src_constant(isNaN(a) ? b : a);
+}
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/rgb.js
+
+
+
+
+/* harmony default export */ const rgb = ((function rgbGamma(y) {
+  var color = gamma(y);
+
+  function rgb(start, end) {
+    var r = color((start = (0,src_color/* rgb */.B8)(start)).r, (end = (0,src_color/* rgb */.B8)(end)).r),
+        g = color(start.g, end.g),
+        b = color(start.b, end.b),
+        opacity = nogamma(start.opacity, end.opacity);
+    return function (t) {
+      start.r = r(t);
+      start.g = g(t);
+      start.b = b(t);
+      start.opacity = opacity(t);
+      return start + "";
+    };
+  }
+
+  rgb.gamma = rgbGamma;
+  return rgb;
+})(1));
+
+function rgbSpline(spline) {
+  return function (colors) {
+    var n = colors.length,
+        r = new Array(n),
+        g = new Array(n),
+        b = new Array(n),
+        i,
+        color;
+
+    for (i = 0; i < n; ++i) {
+      color = (0,src_color/* rgb */.B8)(colors[i]);
+      r[i] = color.r || 0;
+      g[i] = color.g || 0;
+      b[i] = color.b || 0;
+    }
+
+    r = spline(r);
+    g = spline(g);
+    b = spline(b);
+    color.opacity = 1;
+    return function (t) {
+      color.r = r(t);
+      color.g = g(t);
+      color.b = b(t);
+      return color + "";
+    };
+  };
+}
+
+var rgbBasis = rgbSpline(src_basis);
+var rgbBasisClosed = rgbSpline(basisClosed);
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/array.js
+
+
+/* harmony default export */ function array(a, b) {
+  return (isNumberArray(b) ? numberArray : genericArray)(a, b);
+}
+function genericArray(a, b) {
+  var nb = b ? b.length : 0,
+      na = a ? Math.min(nb, a.length) : 0,
+      x = new Array(na),
+      c = new Array(nb),
+      i;
+
+  for (i = 0; i < na; ++i) {
+    x[i] = value(a[i], b[i]);
+  }
+
+  for (; i < nb; ++i) {
+    c[i] = b[i];
+  }
+
+  return function (t) {
+    for (i = 0; i < na; ++i) {
+      c[i] = x[i](t);
+    }
+
+    return c;
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/date.js
+/* harmony default export */ function date(a, b) {
+  var d = new Date();
+  return a = +a, b = +b, function (t) {
+    return d.setTime(a * (1 - t) + b * t), d;
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/number.js
+/* harmony default export */ function src_number(a, b) {
+  return a = +a, b = +b, function (t) {
+    return a * (1 - t) + b * t;
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/object.js
+
+
+/* harmony default export */ function object(a, b) {
+  var i = {},
+      c = {},
+      k;
+  if (a === null || (0,esm_typeof/* default */.Z)(a) !== "object") a = {};
+  if (b === null || (0,esm_typeof/* default */.Z)(b) !== "object") b = {};
+
+  for (k in b) {
+    if (k in a) {
+      i[k] = value(a[k], b[k]);
+    } else {
+      c[k] = b[k];
+    }
+  }
+
+  return function (t) {
+    for (k in i) {
+      c[k] = i[k](t);
+    }
+
+    return c;
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/string.js
+
+var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,
+    reB = new RegExp(reA.source, "g");
+
+function zero(b) {
+  return function () {
+    return b;
+  };
+}
+
+function one(b) {
+  return function (t) {
+    return b(t) + "";
+  };
+}
+
+/* harmony default export */ function string(a, b) {
+  var bi = reA.lastIndex = reB.lastIndex = 0,
+      // scan index for next number in b
+  am,
+      // current match in a
+  bm,
+      // current match in b
+  bs,
+      // string preceding current number in b, if any
+  i = -1,
+      // index in s
+  s = [],
+      // string constants and placeholders
+  q = []; // number interpolators
+  // Coerce inputs to strings.
+
+  a = a + "", b = b + ""; // Interpolate pairs of numbers in a & b.
+
+  while ((am = reA.exec(a)) && (bm = reB.exec(b))) {
+    if ((bs = bm.index) > bi) {
+      // a string precedes the next number in b
+      bs = b.slice(bi, bs);
+      if (s[i]) s[i] += bs; // coalesce with previous string
+      else s[++i] = bs;
+    }
+
+    if ((am = am[0]) === (bm = bm[0])) {
+      // numbers in a & b match
+      if (s[i]) s[i] += bm; // coalesce with previous string
+      else s[++i] = bm;
+    } else {
+      // interpolate non-matching numbers
+      s[++i] = null;
+      q.push({
+        i: i,
+        x: src_number(am, bm)
+      });
+    }
+
+    bi = reB.lastIndex;
+  } // Add remains of b.
+
+
+  if (bi < b.length) {
+    bs = b.slice(bi);
+    if (s[i]) s[i] += bs; // coalesce with previous string
+    else s[++i] = bs;
+  } // Special optimization for only a single match.
+  // Otherwise, interpolate each of the numbers and rejoin the string.
+
+
+  return s.length < 2 ? q[0] ? one(q[0].x) : zero(b) : (b = q.length, function (t) {
+    for (var i = 0, o; i < b; ++i) {
+      s[(o = q[i]).i] = o.x(t);
+    }
+
+    return s.join("");
+  });
+}
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/numberArray.js
+/* harmony default export */ function src_numberArray(a, b) {
+  if (!b) b = [];
+  var n = a ? Math.min(b.length, a.length) : 0,
+      c = b.slice(),
+      i;
+  return function (t) {
+    for (i = 0; i < n; ++i) {
+      c[i] = a[i] * (1 - t) + b[i] * t;
+    }
+
+    return c;
+  };
+}
+function numberArray_isNumberArray(x) {
+  return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/value.js
+
+
+
+
+
+
+
+
+
+
+/* harmony default export */ function value(a, b) {
+  var t = (0,esm_typeof/* default */.Z)(b),
+      c;
+
+  return b == null || t === "boolean" ? src_constant(b) : (t === "number" ? src_number : t === "string" ? (c = (0,src_color/* default */.ZP)(b)) ? (b = c, rgb) : string : b instanceof src_color/* default */.ZP ? rgb : b instanceof Date ? date : numberArray_isNumberArray(b) ? src_numberArray : Array.isArray(b) ? genericArray : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object : src_number)(a, b);
+}
+;// CONCATENATED MODULE: ./node_modules/d3-interpolate/src/round.js
+/* harmony default export */ function round(a, b) {
+  return a = +a, b = +b, function (t) {
+    return Math.round(a * (1 - t) + b * t);
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/d3-scale/src/constant.js
+function constants(x) {
+  return function () {
+    return x;
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/d3-scale/src/number.js
+function number_number(x) {
+  return +x;
+}
+;// CONCATENATED MODULE: ./node_modules/d3-scale/src/continuous.js
+
+
+
+
+var unit = [0, 1];
+function identity(x) {
+  return x;
+}
+
+function normalize(a, b) {
+  return (b -= a = +a) ? function (x) {
+    return (x - a) / b;
+  } : constants(isNaN(b) ? NaN : 0.5);
+}
+
+function clamper(a, b) {
+  var t;
+  if (a > b) t = a, a = b, b = t;
+  return function (x) {
+    return Math.max(a, Math.min(b, x));
+  };
+} // normalize(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1].
+// interpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding range value x in [a,b].
+
+
+function bimap(domain, range, interpolate) {
+  var d0 = domain[0],
+      d1 = domain[1],
+      r0 = range[0],
+      r1 = range[1];
+  if (d1 < d0) d0 = normalize(d1, d0), r0 = interpolate(r1, r0);else d0 = normalize(d0, d1), r0 = interpolate(r0, r1);
+  return function (x) {
+    return r0(d0(x));
+  };
+}
+
+function polymap(domain, range, interpolate) {
+  var j = Math.min(domain.length, range.length) - 1,
+      d = new Array(j),
+      r = new Array(j),
+      i = -1; // Reverse descending domains.
+
+  if (domain[j] < domain[0]) {
+    domain = domain.slice().reverse();
+    range = range.slice().reverse();
+  }
+
+  while (++i < j) {
+    d[i] = normalize(domain[i], domain[i + 1]);
+    r[i] = interpolate(range[i], range[i + 1]);
+  }
+
+  return function (x) {
+    var i = bisect(domain, x, 1, j) - 1;
+    return r[i](d[i](x));
+  };
+}
+
+function copy(source, target) {
+  return target.domain(source.domain()).range(source.range()).interpolate(source.interpolate()).clamp(source.clamp()).unknown(source.unknown());
+}
+function transformer() {
+  var domain = unit,
+      range = unit,
+      interpolate = value,
+      transform,
+      untransform,
+      unknown,
+      clamp = identity,
+      piecewise,
+      output,
+      input;
+
+  function rescale() {
+    var n = Math.min(domain.length, range.length);
+    if (clamp !== identity) clamp = clamper(domain[0], domain[n - 1]);
+    piecewise = n > 2 ? polymap : bimap;
+    output = input = null;
+    return scale;
+  }
+
+  function scale(x) {
+    return x == null || isNaN(x = +x) ? unknown : (output || (output = piecewise(domain.map(transform), range, interpolate)))(transform(clamp(x)));
+  }
+
+  scale.invert = function (y) {
+    return clamp(untransform((input || (input = piecewise(range, domain.map(transform), src_number)))(y)));
+  };
+
+  scale.domain = function (_) {
+    return arguments.length ? (domain = Array.from(_, number_number), rescale()) : domain.slice();
+  };
+
+  scale.range = function (_) {
+    return arguments.length ? (range = Array.from(_), rescale()) : range.slice();
+  };
+
+  scale.rangeRound = function (_) {
+    return range = Array.from(_), interpolate = round, rescale();
+  };
+
+  scale.clamp = function (_) {
+    return arguments.length ? (clamp = _ ? true : identity, rescale()) : clamp !== identity;
+  };
+
+  scale.interpolate = function (_) {
+    return arguments.length ? (interpolate = _, rescale()) : interpolate;
+  };
+
+  scale.unknown = function (_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+
+  return function (t, u) {
+    transform = t, untransform = u;
+    return rescale();
+  };
+}
+function continuous() {
+  return transformer()(identity, identity);
+}
+;// CONCATENATED MODULE: ./node_modules/d3-scale/src/init.js
+function initRange(domain, range) {
+  switch (arguments.length) {
+    case 0:
+      break;
+
+    case 1:
+      this.range(domain);
+      break;
+
+    default:
+      this.range(range).domain(domain);
+      break;
+  }
+
+  return this;
+}
+function initInterpolator(domain, interpolator) {
+  switch (arguments.length) {
+    case 0:
+      break;
+
+    case 1:
+      {
+        if (typeof domain === "function") this.interpolator(domain);else this.range(domain);
+        break;
+      }
+
+    default:
+      {
+        this.domain(domain);
+        if (typeof interpolator === "function") this.interpolator(interpolator);else this.range(interpolator);
+        break;
+      }
+  }
+
+  return this;
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/formatSpecifier.js
+// [[fill]align][sign][symbol][0][width][,][.precision][~][type]
+var re = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;
+function formatSpecifier(specifier) {
+  if (!(match = re.exec(specifier))) throw new Error("invalid format: " + specifier);
+  var match;
+  return new FormatSpecifier({
+    fill: match[1],
+    align: match[2],
+    sign: match[3],
+    symbol: match[4],
+    zero: match[5],
+    width: match[6],
+    comma: match[7],
+    precision: match[8] && match[8].slice(1),
+    trim: match[9],
+    type: match[10]
+  });
+}
+formatSpecifier.prototype = FormatSpecifier.prototype; // instanceof
+
+function FormatSpecifier(specifier) {
+  this.fill = specifier.fill === undefined ? " " : specifier.fill + "";
+  this.align = specifier.align === undefined ? ">" : specifier.align + "";
+  this.sign = specifier.sign === undefined ? "-" : specifier.sign + "";
+  this.symbol = specifier.symbol === undefined ? "" : specifier.symbol + "";
+  this.zero = !!specifier.zero;
+  this.width = specifier.width === undefined ? undefined : +specifier.width;
+  this.comma = !!specifier.comma;
+  this.precision = specifier.precision === undefined ? undefined : +specifier.precision;
+  this.trim = !!specifier.trim;
+  this.type = specifier.type === undefined ? "" : specifier.type + "";
+}
+
+FormatSpecifier.prototype.toString = function () {
+  return this.fill + this.align + this.sign + this.symbol + (this.zero ? "0" : "") + (this.width === undefined ? "" : Math.max(1, this.width | 0)) + (this.comma ? "," : "") + (this.precision === undefined ? "" : "." + Math.max(0, this.precision | 0)) + (this.trim ? "~" : "") + this.type;
+};
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/formatDecimal.js
+/* harmony default export */ function formatDecimal(x) {
+  return Math.abs(x = Math.round(x)) >= 1e21 ? x.toLocaleString("en").replace(/,/g, "") : x.toString(10);
+} // Computes the decimal coefficient and exponent of the specified number x with
+// significant digits p, where x is positive and p is in [1, 21] or undefined.
+// For example, formatDecimalParts(1.23) returns ["123", 0].
+
+function formatDecimalParts(x, p) {
+  if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0) return null; // NaN, ±Infinity
+
+  var i,
+      coefficient = x.slice(0, i); // The string returned by toExponential either has the form \d\.\d+e[-+]\d+
+  // (e.g., 1.2e+3) or the form \de[-+]\d+ (e.g., 1e+3).
+
+  return [coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient, +x.slice(i + 1)];
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/exponent.js
+
+/* harmony default export */ function exponent(x) {
+  return x = formatDecimalParts(Math.abs(x)), x ? x[1] : NaN;
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/precisionPrefix.js
+
+/* harmony default export */ function precisionPrefix(step, value) {
+  return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3 - exponent(Math.abs(step)));
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/formatGroup.js
+/* harmony default export */ function formatGroup(grouping, thousands) {
+  return function (value, width) {
+    var i = value.length,
+        t = [],
+        j = 0,
+        g = grouping[0],
+        length = 0;
+
+    while (i > 0 && g > 0) {
+      if (length + g + 1 > width) g = Math.max(1, width - length);
+      t.push(value.substring(i -= g, i + g));
+      if ((length += g + 1) > width) break;
+      g = grouping[j = (j + 1) % grouping.length];
+    }
+
+    return t.reverse().join(thousands);
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/formatNumerals.js
+/* harmony default export */ function formatNumerals(numerals) {
+  return function (value) {
+    return value.replace(/[0-9]/g, function (i) {
+      return numerals[+i];
+    });
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/formatTrim.js
+// Trims insignificant zeros, e.g., replaces 1.2000k with 1.2k.
+/* harmony default export */ function formatTrim(s) {
+  out: for (var n = s.length, i = 1, i0 = -1, i1; i < n; ++i) {
+    switch (s[i]) {
+      case ".":
+        i0 = i1 = i;
+        break;
+
+      case "0":
+        if (i0 === 0) i0 = i;
+        i1 = i;
+        break;
+
+      default:
+        if (!+s[i]) break out;
+        if (i0 > 0) i0 = 0;
+        break;
+    }
+  }
+
+  return i0 > 0 ? s.slice(0, i0) + s.slice(i1 + 1) : s;
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/formatPrefixAuto.js
+
+var prefixExponent;
+/* harmony default export */ function formatPrefixAuto(x, p) {
+  var d = formatDecimalParts(x, p);
+  if (!d) return x + "";
+  var coefficient = d[0],
+      exponent = d[1],
+      i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1,
+      n = coefficient.length;
+  return i === n ? coefficient : i > n ? coefficient + new Array(i - n + 1).join("0") : i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i) : "0." + new Array(1 - i).join("0") + formatDecimalParts(x, Math.max(0, p + i - 1))[0]; // less than 1y!
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/formatRounded.js
+
+/* harmony default export */ function formatRounded(x, p) {
+  var d = formatDecimalParts(x, p);
+  if (!d) return x + "";
+  var coefficient = d[0],
+      exponent = d[1];
+  return exponent < 0 ? "0." + new Array(-exponent).join("0") + coefficient : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1) : coefficient + new Array(exponent - coefficient.length + 2).join("0");
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/formatTypes.js
+
+
+
+/* harmony default export */ const formatTypes = ({
+  "%": function _(x, p) {
+    return (x * 100).toFixed(p);
+  },
+  "b": function b(x) {
+    return Math.round(x).toString(2);
+  },
+  "c": function c(x) {
+    return x + "";
+  },
+  "d": formatDecimal,
+  "e": function e(x, p) {
+    return x.toExponential(p);
+  },
+  "f": function f(x, p) {
+    return x.toFixed(p);
+  },
+  "g": function g(x, p) {
+    return x.toPrecision(p);
+  },
+  "o": function o(x) {
+    return Math.round(x).toString(8);
+  },
+  "p": function p(x, _p) {
+    return formatRounded(x * 100, _p);
+  },
+  "r": formatRounded,
+  "s": formatPrefixAuto,
+  "X": function X(x) {
+    return Math.round(x).toString(16).toUpperCase();
+  },
+  "x": function x(_x) {
+    return Math.round(_x).toString(16);
+  }
+});
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/identity.js
+/* harmony default export */ function src_identity(x) {
+  return x;
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/locale.js
+
+
+
+
+
+
+
+
+var map = Array.prototype.map,
+    prefixes = ["y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y"];
+/* harmony default export */ function locale(locale) {
+  var group = locale.grouping === undefined || locale.thousands === undefined ? src_identity : formatGroup(map.call(locale.grouping, Number), locale.thousands + ""),
+      currencyPrefix = locale.currency === undefined ? "" : locale.currency[0] + "",
+      currencySuffix = locale.currency === undefined ? "" : locale.currency[1] + "",
+      decimal = locale.decimal === undefined ? "." : locale.decimal + "",
+      numerals = locale.numerals === undefined ? src_identity : formatNumerals(map.call(locale.numerals, String)),
+      percent = locale.percent === undefined ? "%" : locale.percent + "",
+      minus = locale.minus === undefined ? "−" : locale.minus + "",
+      nan = locale.nan === undefined ? "NaN" : locale.nan + "";
+
+  function newFormat(specifier) {
+    specifier = formatSpecifier(specifier);
+    var fill = specifier.fill,
+        align = specifier.align,
+        sign = specifier.sign,
+        symbol = specifier.symbol,
+        zero = specifier.zero,
+        width = specifier.width,
+        comma = specifier.comma,
+        precision = specifier.precision,
+        trim = specifier.trim,
+        type = specifier.type; // The "n" type is an alias for ",g".
+
+    if (type === "n") comma = true, type = "g"; // The "" type, and any invalid type, is an alias for ".12~g".
+    else if (!formatTypes[type]) precision === undefined && (precision = 12), trim = true, type = "g"; // If zero fill is specified, padding goes after sign and before digits.
+
+    if (zero || fill === "0" && align === "=") zero = true, fill = "0", align = "="; // Compute the prefix and suffix.
+    // For SI-prefix, the suffix is lazily computed.
+
+    var prefix = symbol === "$" ? currencyPrefix : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "",
+        suffix = symbol === "$" ? currencySuffix : /[%p]/.test(type) ? percent : ""; // What format function should we use?
+    // Is this an integer type?
+    // Can this type generate exponential notation?
+
+    var formatType = formatTypes[type],
+        maybeSuffix = /[defgprs%]/.test(type); // Set the default precision if not specified,
+    // or clamp the specified precision to the supported range.
+    // For significant precision, it must be in [1, 21].
+    // For fixed precision, it must be in [0, 20].
+
+    precision = precision === undefined ? 6 : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision)) : Math.max(0, Math.min(20, precision));
+
+    function format(value) {
+      var valuePrefix = prefix,
+          valueSuffix = suffix,
+          i,
+          n,
+          c;
+
+      if (type === "c") {
+        valueSuffix = formatType(value) + valueSuffix;
+        value = "";
+      } else {
+        value = +value; // Determine the sign. -0 is not less than 0, but 1 / -0 is!
+
+        var valueNegative = value < 0 || 1 / value < 0; // Perform the initial formatting.
+
+        value = isNaN(value) ? nan : formatType(Math.abs(value), precision); // Trim insignificant zeros.
+
+        if (trim) value = formatTrim(value); // If a negative value rounds to zero after formatting, and no explicit positive sign is requested, hide the sign.
+
+        if (valueNegative && +value === 0 && sign !== "+") valueNegative = false; // Compute the prefix and suffix.
+
+        valuePrefix = (valueNegative ? sign === "(" ? sign : minus : sign === "-" || sign === "(" ? "" : sign) + valuePrefix;
+        valueSuffix = (type === "s" ? prefixes[8 + prefixExponent / 3] : "") + valueSuffix + (valueNegative && sign === "(" ? ")" : ""); // Break the formatted value into the integer “value” part that can be
+        // grouped, and fractional or exponential “suffix” part that is not.
+
+        if (maybeSuffix) {
+          i = -1, n = value.length;
+
+          while (++i < n) {
+            if (c = value.charCodeAt(i), 48 > c || c > 57) {
+              valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;
+              value = value.slice(0, i);
+              break;
+            }
+          }
+        }
+      } // If the fill character is not "0", grouping is applied before padding.
+
+
+      if (comma && !zero) value = group(value, Infinity); // Compute the padding.
+
+      var length = valuePrefix.length + value.length + valueSuffix.length,
+          padding = length < width ? new Array(width - length + 1).join(fill) : ""; // If the fill character is "0", grouping is applied after padding.
+
+      if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = ""; // Reconstruct the final output based on the desired alignment.
+
+      switch (align) {
+        case "<":
+          value = valuePrefix + value + valueSuffix + padding;
+          break;
+
+        case "=":
+          value = valuePrefix + padding + value + valueSuffix;
+          break;
+
+        case "^":
+          value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length);
+          break;
+
+        default:
+          value = padding + valuePrefix + value + valueSuffix;
+          break;
+      }
+
+      return numerals(value);
+    }
+
+    format.toString = function () {
+      return specifier + "";
+    };
+
+    return format;
+  }
+
+  function formatPrefix(specifier, value) {
+    var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = "f", specifier)),
+        e = Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3,
+        k = Math.pow(10, -e),
+        prefix = prefixes[8 + e / 3];
+    return function (value) {
+      return f(k * value) + prefix;
+    };
+  }
+
+  return {
+    format: newFormat,
+    formatPrefix: formatPrefix
+  };
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/defaultLocale.js
+
+var defaultLocale_locale;
+var format;
+var formatPrefix;
+defaultLocale({
+  thousands: ",",
+  grouping: [3],
+  currency: ["$", ""]
+});
+function defaultLocale(definition) {
+  defaultLocale_locale = locale(definition);
+  format = defaultLocale_locale.format;
+  formatPrefix = defaultLocale_locale.formatPrefix;
+  return defaultLocale_locale;
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/precisionRound.js
+
+/* harmony default export */ function precisionRound(step, max) {
+  step = Math.abs(step), max = Math.abs(max) - step;
+  return Math.max(0, exponent(max) - exponent(step)) + 1;
+}
+;// CONCATENATED MODULE: ./node_modules/d3-format/src/precisionFixed.js
+
+/* harmony default export */ function precisionFixed(step) {
+  return Math.max(0, -exponent(Math.abs(step)));
+}
+;// CONCATENATED MODULE: ./node_modules/d3-scale/src/tickFormat.js
+
+
+function tickFormat(start, stop, count, specifier) {
+  var step = tickStep(start, stop, count),
+      precision;
+  specifier = formatSpecifier(specifier == null ? ",f" : specifier);
+
+  switch (specifier.type) {
+    case "s":
+      {
+        var value = Math.max(Math.abs(start), Math.abs(stop));
+        if (specifier.precision == null && !isNaN(precision = precisionPrefix(step, value))) specifier.precision = precision;
+        return formatPrefix(specifier, value);
+      }
+
+    case "":
+    case "e":
+    case "g":
+    case "p":
+    case "r":
+      {
+        if (specifier.precision == null && !isNaN(precision = precisionRound(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e");
+        break;
+      }
+
+    case "f":
+    case "%":
+      {
+        if (specifier.precision == null && !isNaN(precision = precisionFixed(step))) specifier.precision = precision - (specifier.type === "%") * 2;
+        break;
+      }
+  }
+
+  return format(specifier);
+}
+;// CONCATENATED MODULE: ./node_modules/d3-scale/src/linear.js
+
+
+
+
+function linearish(scale) {
+  var domain = scale.domain;
+
+  scale.ticks = function (count) {
+    var d = domain();
+    return ticks(d[0], d[d.length - 1], count == null ? 10 : count);
+  };
+
+  scale.tickFormat = function (count, specifier) {
+    var d = domain();
+    return tickFormat(d[0], d[d.length - 1], count == null ? 10 : count, specifier);
+  };
+
+  scale.nice = function (count) {
+    if (count == null) count = 10;
+    var d = domain();
+    var i0 = 0;
+    var i1 = d.length - 1;
+    var start = d[i0];
+    var stop = d[i1];
+    var prestep;
+    var step;
+    var maxIter = 10;
+
+    if (stop < start) {
+      step = start, start = stop, stop = step;
+      step = i0, i0 = i1, i1 = step;
+    }
+
+    while (maxIter-- > 0) {
+      step = tickIncrement(start, stop, count);
+
+      if (step === prestep) {
+        d[i0] = start;
+        d[i1] = stop;
+        return domain(d);
+      } else if (step > 0) {
+        start = Math.floor(start / step) * step;
+        stop = Math.ceil(stop / step) * step;
+      } else if (step < 0) {
+        start = Math.ceil(start * step) / step;
+        stop = Math.floor(stop * step) / step;
+      } else {
+        break;
+      }
+
+      prestep = step;
+    }
+
+    return scale;
+  };
+
+  return scale;
+}
+function linear_linear() {
+  var scale = continuous();
+
+  scale.copy = function () {
+    return copy(scale, linear_linear());
+  };
+
+  initRange.apply(scale, arguments);
+  return linearish(scale);
+}
+
+/***/ }),
+
+/***/ 3538:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+/* module decorator */ module = __webpack_require__.nmd(module);
+var _typeof = __webpack_require__(6496);
+
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var runtime = function (exports) {
+  "use strict";
+
+  var Op = Object.prototype;
+  var hasOwn = Op.hasOwnProperty;
+  var undefined; // More compressible than void 0.
+
+  var $Symbol = typeof Symbol === "function" ? Symbol : {};
+  var iteratorSymbol = $Symbol.iterator || "@@iterator";
+  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  function define(obj, key, value) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+    return obj[key];
+  }
+
+  try {
+    // IE 8 has a broken Object.defineProperty that only works on DOM objects.
+    define({}, "");
+  } catch (err) {
+    define = function define(obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+    var generator = Object.create(protoGenerator.prototype);
+    var context = new Context(tryLocsList || []); // The ._invoke method unifies the implementations of the .next,
+    // .throw, and .return methods.
+
+    generator._invoke = makeInvokeMethod(innerFn, self, context);
+    return generator;
+  }
+
+  exports.wrap = wrap; // Try/catch helper to minimize deoptimizations. Returns a completion
+  // record like context.tryEntries[i].completion. This interface could
+  // have been (and was previously) designed to take a closure to be
+  // invoked without arguments, but in all the cases we care about we
+  // already have an existing method we want to call, so there's no need
+  // to create a new function object. We can even get away with assuming
+  // the method takes exactly one argument, since that happens to be true
+  // in every case, so we don't have to touch the arguments object. The
+  // only additional allocation required is the completion record, which
+  // has a stable shape and so hopefully should be cheap to allocate.
+
+  function tryCatch(fn, obj, arg) {
+    try {
+      return {
+        type: "normal",
+        arg: fn.call(obj, arg)
+      };
+    } catch (err) {
+      return {
+        type: "throw",
+        arg: err
+      };
+    }
+  }
+
+  var GenStateSuspendedStart = "suspendedStart";
+  var GenStateSuspendedYield = "suspendedYield";
+  var GenStateExecuting = "executing";
+  var GenStateCompleted = "completed"; // Returning this object from the innerFn has the same effect as
+  // breaking out of the dispatch switch statement.
+
+  var ContinueSentinel = {}; // Dummy constructor functions that we use as the .constructor and
+  // .constructor.prototype properties for functions that return Generator
+  // objects. For full spec compliance, you may wish to configure your
+  // minifier not to mangle the names of these two functions.
+
+  function Generator() {}
+
+  function GeneratorFunction() {}
+
+  function GeneratorFunctionPrototype() {} // This is a polyfill for %IteratorPrototype% for environments that
+  // don't natively support it.
+
+
+  var IteratorPrototype = {};
+
+  IteratorPrototype[iteratorSymbol] = function () {
+    return this;
+  };
+
+  var getProto = Object.getPrototypeOf;
+  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+
+  if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+    // This environment has a native %IteratorPrototype%; use it instead
+    // of the polyfill.
+    IteratorPrototype = NativeIteratorPrototype;
+  }
+
+  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+  GeneratorFunctionPrototype.constructor = GeneratorFunction;
+  GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"); // Helper for defining the .next, .throw, and .return methods of the
+  // Iterator interface in terms of a single ._invoke method.
+
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function (method) {
+      define(prototype, method, function (arg) {
+        return this._invoke(method, arg);
+      });
+    });
+  }
+
+  exports.isGeneratorFunction = function (genFun) {
+    var ctor = typeof genFun === "function" && genFun.constructor;
+    return ctor ? ctor === GeneratorFunction || // For the native GeneratorFunction constructor, the best we can
+    // do is to check its .name property.
+    (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
+  };
+
+  exports.mark = function (genFun) {
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+    } else {
+      genFun.__proto__ = GeneratorFunctionPrototype;
+      define(genFun, toStringTagSymbol, "GeneratorFunction");
+    }
+
+    genFun.prototype = Object.create(Gp);
+    return genFun;
+  }; // Within the body of any async function, `await x` is transformed to
+  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
+  // `hasOwn.call(value, "__await")` to determine if the yielded value is
+  // meant to be awaited.
+
+
+  exports.awrap = function (arg) {
+    return {
+      __await: arg
+    };
+  };
+
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+
+      if (record.type === "throw") {
+        reject(record.arg);
+      } else {
+        var result = record.arg;
+        var value = result.value;
+
+        if (value && _typeof(value) === "object" && hasOwn.call(value, "__await")) {
+          return PromiseImpl.resolve(value.__await).then(function (value) {
+            invoke("next", value, resolve, reject);
+          }, function (err) {
+            invoke("throw", err, resolve, reject);
+          });
+        }
+
+        return PromiseImpl.resolve(value).then(function (unwrapped) {
+          // When a yielded Promise is resolved, its final value becomes
+          // the .value of the Promise<{value,done}> result for the
+          // current iteration.
+          result.value = unwrapped;
+          resolve(result);
+        }, function (error) {
+          // If a rejected Promise was yielded, throw the rejection back
+          // into the async generator function so it can be handled there.
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+    }
+
+    var previousPromise;
+
+    function enqueue(method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new PromiseImpl(function (resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+
+      return previousPromise = // If enqueue has been called before, then we want to wait until
+      // all previous Promises have been resolved before calling invoke,
+      // so that results are always delivered in the correct order. If
+      // enqueue has not been called before, then it is important to
+      // call invoke immediately, without waiting on a callback to fire,
+      // so that the async generator function has the opportunity to do
+      // any necessary setup in a predictable way. This predictability
+      // is why the Promise constructor synchronously invokes its
+      // executor callback, and why async functions synchronously
+      // execute code before the first await. Since we implement simple
+      // async functions in terms of async generators, it is especially
+      // important to get this right, even though it requires care.
+      previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, // Avoid propagating failures to Promises returned by later
+      // invocations of the iterator.
+      callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+    } // Define the unified helper method that is used to implement .next,
+    // .throw, and .return (see defineIteratorMethods).
+
+
+    this._invoke = enqueue;
+  }
+
+  defineIteratorMethods(AsyncIterator.prototype);
+
+  AsyncIterator.prototype[asyncIteratorSymbol] = function () {
+    return this;
+  };
+
+  exports.AsyncIterator = AsyncIterator; // Note that simple async functions are implemented on top of
+  // AsyncIterator objects; they just return a Promise for the value of
+  // the final result produced by the iterator.
+
+  exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    if (PromiseImpl === void 0) PromiseImpl = Promise;
+    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+    return exports.isGeneratorFunction(outerFn) ? iter // If outerFn is a generator, return the full iterator.
+    : iter.next().then(function (result) {
+      return result.done ? result.value : iter.next();
+    });
+  };
+
+  function makeInvokeMethod(innerFn, self, context) {
+    var state = GenStateSuspendedStart;
+    return function invoke(method, arg) {
+      if (state === GenStateExecuting) {
+        throw new Error("Generator is already running");
+      }
+
+      if (state === GenStateCompleted) {
+        if (method === "throw") {
+          throw arg;
+        } // Be forgiving, per 25.3.3.3.3 of the spec:
+        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+
+
+        return doneResult();
+      }
+
+      context.method = method;
+      context.arg = arg;
+
+      while (true) {
+        var delegate = context.delegate;
+
+        if (delegate) {
+          var delegateResult = maybeInvokeDelegate(delegate, context);
+
+          if (delegateResult) {
+            if (delegateResult === ContinueSentinel) continue;
+            return delegateResult;
+          }
+        }
+
+        if (context.method === "next") {
+          // Setting context._sent for legacy support of Babel's
+          // function.sent implementation.
+          context.sent = context._sent = context.arg;
+        } else if (context.method === "throw") {
+          if (state === GenStateSuspendedStart) {
+            state = GenStateCompleted;
+            throw context.arg;
+          }
+
+          context.dispatchException(context.arg);
+        } else if (context.method === "return") {
+          context.abrupt("return", context.arg);
+        }
+
+        state = GenStateExecuting;
+        var record = tryCatch(innerFn, self, context);
+
+        if (record.type === "normal") {
+          // If an exception is thrown from innerFn, we leave state ===
+          // GenStateExecuting and loop back for another invocation.
+          state = context.done ? GenStateCompleted : GenStateSuspendedYield;
+
+          if (record.arg === ContinueSentinel) {
+            continue;
+          }
+
+          return {
+            value: record.arg,
+            done: context.done
+          };
+        } else if (record.type === "throw") {
+          state = GenStateCompleted; // Dispatch the exception by looping back around to the
+          // context.dispatchException(context.arg) call above.
+
+          context.method = "throw";
+          context.arg = record.arg;
+        }
+      }
+    };
+  } // Call delegate.iterator[context.method](context.arg) and handle the
+  // result, either by returning a { value, done } result from the
+  // delegate iterator, or by modifying context.method and context.arg,
+  // setting context.delegate to null, and returning the ContinueSentinel.
+
+
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+
+    if (method === undefined) {
+      // A .throw or .return when the delegate iterator has no .throw
+      // method always terminates the yield* loop.
+      context.delegate = null;
+
+      if (context.method === "throw") {
+        // Note: ["return"] must be used for ES3 parsing compatibility.
+        if (delegate.iterator["return"]) {
+          // If the delegate iterator has a return method, give it a
+          // chance to clean up.
+          context.method = "return";
+          context.arg = undefined;
+          maybeInvokeDelegate(delegate, context);
+
+          if (context.method === "throw") {
+            // If maybeInvokeDelegate(context) changed context.method from
+            // "return" to "throw", let that override the TypeError below.
+            return ContinueSentinel;
+          }
+        }
+
+        context.method = "throw";
+        context.arg = new TypeError("The iterator does not provide a 'throw' method");
+      }
+
+      return ContinueSentinel;
+    }
+
+    var record = tryCatch(method, delegate.iterator, context.arg);
+
+    if (record.type === "throw") {
+      context.method = "throw";
+      context.arg = record.arg;
+      context.delegate = null;
+      return ContinueSentinel;
+    }
+
+    var info = record.arg;
+
+    if (!info) {
+      context.method = "throw";
+      context.arg = new TypeError("iterator result is not an object");
+      context.delegate = null;
+      return ContinueSentinel;
+    }
+
+    if (info.done) {
+      // Assign the result of the finished delegate to the temporary
+      // variable specified by delegate.resultName (see delegateYield).
+      context[delegate.resultName] = info.value; // Resume execution at the desired location (see delegateYield).
+
+      context.next = delegate.nextLoc; // If context.method was "throw" but the delegate handled the
+      // exception, let the outer generator proceed normally. If
+      // context.method was "next", forget context.arg since it has been
+      // "consumed" by the delegate iterator. If context.method was
+      // "return", allow the original .return call to continue in the
+      // outer generator.
+
+      if (context.method !== "return") {
+        context.method = "next";
+        context.arg = undefined;
+      }
+    } else {
+      // Re-yield the result returned by the delegate method.
+      return info;
+    } // The delegate iterator is finished, so forget it and continue with
+    // the outer generator.
+
+
+    context.delegate = null;
+    return ContinueSentinel;
+  } // Define Generator.prototype.{next,throw,return} in terms of the
+  // unified ._invoke helper method.
+
+
+  defineIteratorMethods(Gp);
+  define(Gp, toStringTagSymbol, "Generator"); // A Generator should always return itself as the iterator object when the
+  // @@iterator function is called on it. Some browsers' implementations of the
+  // iterator prototype chain incorrectly implement this, causing the Generator
+  // object to not be returned from this call. This ensures that doesn't happen.
+  // See https://github.com/facebook/regenerator/issues/274 for more details.
+
+  Gp[iteratorSymbol] = function () {
+    return this;
+  };
+
+  Gp.toString = function () {
+    return "[object Generator]";
+  };
+
+  function pushTryEntry(locs) {
+    var entry = {
+      tryLoc: locs[0]
+    };
+
+    if (1 in locs) {
+      entry.catchLoc = locs[1];
+    }
+
+    if (2 in locs) {
+      entry.finallyLoc = locs[2];
+      entry.afterLoc = locs[3];
+    }
+
+    this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal";
+    delete record.arg;
+    entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    // The root entry object (effectively a try statement without a catch
+    // or a finally block) gives us a place to store values thrown from
+    // locations where there is no enclosing try statement.
+    this.tryEntries = [{
+      tryLoc: "root"
+    }];
+    tryLocsList.forEach(pushTryEntry, this);
+    this.reset(true);
+  }
+
+  exports.keys = function (object) {
+    var keys = [];
+
+    for (var key in object) {
+      keys.push(key);
+    }
+
+    keys.reverse(); // Rather than returning an object with a next method, we keep
+    // things simple and return the next function itself.
+
+    return function next() {
+      while (keys.length) {
+        var key = keys.pop();
+
+        if (key in object) {
+          next.value = key;
+          next.done = false;
+          return next;
+        }
+      } // To avoid creating an additional object, we just hang the .value
+      // and .done properties off the next function object itself. This
+      // also ensures that the minifier will not anonymize the function.
+
+
+      next.done = true;
+      return next;
+    };
+  };
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+
+      if (iteratorMethod) {
+        return iteratorMethod.call(iterable);
+      }
+
+      if (typeof iterable.next === "function") {
+        return iterable;
+      }
+
+      if (!isNaN(iterable.length)) {
+        var i = -1,
+            next = function next() {
+          while (++i < iterable.length) {
+            if (hasOwn.call(iterable, i)) {
+              next.value = iterable[i];
+              next.done = false;
+              return next;
+            }
+          }
+
+          next.value = undefined;
+          next.done = true;
+          return next;
+        };
+
+        return next.next = next;
+      }
+    } // Return an iterator with no values.
+
+
+    return {
+      next: doneResult
+    };
+  }
+
+  exports.values = values;
+
+  function doneResult() {
+    return {
+      value: undefined,
+      done: true
+    };
+  }
+
+  Context.prototype = {
+    constructor: Context,
+    reset: function reset(skipTempReset) {
+      this.prev = 0;
+      this.next = 0; // Resetting context._sent for legacy support of Babel's
+      // function.sent implementation.
+
+      this.sent = this._sent = undefined;
+      this.done = false;
+      this.delegate = null;
+      this.method = "next";
+      this.arg = undefined;
+      this.tryEntries.forEach(resetTryEntry);
+
+      if (!skipTempReset) {
+        for (var name in this) {
+          // Not sure about the optimal order of these conditions:
+          if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
+            this[name] = undefined;
+          }
+        }
+      }
+    },
+    stop: function stop() {
+      this.done = true;
+      var rootEntry = this.tryEntries[0];
+      var rootRecord = rootEntry.completion;
+
+      if (rootRecord.type === "throw") {
+        throw rootRecord.arg;
+      }
+
+      return this.rval;
+    },
+    dispatchException: function dispatchException(exception) {
+      if (this.done) {
+        throw exception;
+      }
+
+      var context = this;
+
+      function handle(loc, caught) {
+        record.type = "throw";
+        record.arg = exception;
+        context.next = loc;
+
+        if (caught) {
+          // If the dispatched exception was caught by a catch block,
+          // then let that catch block handle the exception normally.
+          context.method = "next";
+          context.arg = undefined;
+        }
+
+        return !!caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        var record = entry.completion;
+
+        if (entry.tryLoc === "root") {
+          // Exception thrown outside of any try block that could handle
+          // it, so set the completion value of the entire function to
+          // throw the exception.
+          return handle("end");
+        }
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc");
+          var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            } else if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            }
+          } else if (hasFinally) {
+            if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+          } else {
+            throw new Error("try statement without catch or finally");
+          }
+        }
+      }
+    },
+    abrupt: function abrupt(type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
+        // Ignore the finally entry if control is not jumping to a
+        // location outside the try/catch block.
+        finallyEntry = null;
+      }
+
+      var record = finallyEntry ? finallyEntry.completion : {};
+      record.type = type;
+      record.arg = arg;
+
+      if (finallyEntry) {
+        this.method = "next";
+        this.next = finallyEntry.finallyLoc;
+        return ContinueSentinel;
+      }
+
+      return this.complete(record);
+    },
+    complete: function complete(record, afterLoc) {
+      if (record.type === "throw") {
+        throw record.arg;
+      }
+
+      if (record.type === "break" || record.type === "continue") {
+        this.next = record.arg;
+      } else if (record.type === "return") {
+        this.rval = this.arg = record.arg;
+        this.method = "return";
+        this.next = "end";
+      } else if (record.type === "normal" && afterLoc) {
+        this.next = afterLoc;
+      }
+
+      return ContinueSentinel;
+    },
+    finish: function finish(finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.finallyLoc === finallyLoc) {
+          this.complete(entry.completion, entry.afterLoc);
+          resetTryEntry(entry);
+          return ContinueSentinel;
+        }
+      }
+    },
+    "catch": function _catch(tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+
+          if (record.type === "throw") {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+
+          return thrown;
+        }
+      } // The context.catch method must only be called with a location
+      // argument that corresponds to a known catch block.
+
+
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
+      this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      };
+
+      if (this.method === "next") {
+        // Deliberately forget the last sent value so that we don't
+        // accidentally pass it on to the delegate.
+        this.arg = undefined;
+      }
+
+      return ContinueSentinel;
+    }
+  }; // Regardless of whether this script is executing as a CommonJS module
+  // or not, return the runtime object so that we can declare the variable
+  // regeneratorRuntime in the outer scope, which allows this module to be
+  // injected easily by `bin/regenerator --include-runtime script.js`.
+
+  return exports;
+}( // If this script is executing as a CommonJS module, use module.exports
+// as the regeneratorRuntime namespace. Otherwise create a new empty
+// object. Either way, the resulting object will be used to initialize
+// the regeneratorRuntime variable at the top of this file.
+( false ? 0 : _typeof(module)) === "object" ? module.exports : {});
+
+try {
+  regeneratorRuntime = runtime;
+} catch (accidentalStrictMode) {
+  // This module should not be running in strict mode, so the above
+  // assignment should always work unless something is misconfigured. Just
+  // in case runtime.js accidentally runs in strict mode, we can escape
+  // strict mode using a global Function call. This could conceivably fail
+  // if a Content Security Policy forbids using Function, but in that case
+  // the proper solution is to fix the accidental strict mode problem. If
+  // you've misconfigured your bundler to force strict mode and applied a
+  // CSP to forbid Function, and you're not willing to fix either of those
+  // problems, please detail your unique predicament in a GitHub issue.
+  Function("r", "regeneratorRuntime = r")(runtime);
+}
+
+/***/ }),
+
+/***/ 3402:
+/***/ ((module) => {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__3402__;
+
+/***/ }),
+
+/***/ 5692:
+/***/ ((module) => {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__5692__;
+
+/***/ }),
+
+/***/ 8310:
+/***/ ((module) => {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__8310__;
+
+/***/ }),
+
+/***/ 4159:
+/***/ ((module) => {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__4159__;
+
+/***/ }),
+
+/***/ 855:
+/***/ ((module) => {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__855__;
+
+/***/ }),
+
+/***/ 8156:
+/***/ ((module) => {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__8156__;
+
+/***/ }),
+
+/***/ 8721:
+/***/ ((module) => {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__8721__;
+
+/***/ }),
+
+/***/ 1082:
+/***/ ((module) => {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__1082__;
+
+/***/ }),
+
+/***/ 8763:
+/***/ ((module) => {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__8763__;
+
+/***/ }),
+
+/***/ 6043:
+/***/ ((module) => {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__6043__;
+
+/***/ }),
+
+/***/ 8053:
+/***/ ((module) => {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__8053__;
+
+/***/ }),
+
+/***/ 7111:
+/***/ ((module) => {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__7111__;
+
+/***/ }),
+
+/***/ 7038:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Z": () => (/* binding */ _objectWithoutPropertiesLoose)
+/* harmony export */ });
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+/***/ }),
+
+/***/ 4329:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Z": () => (/* binding */ _typeof)
+/* harmony export */ });
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof(obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function _typeof(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			id: moduleId,
+/******/ 			loaded: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = __webpack_modules__;
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/chunk loaded */
+/******/ 	(() => {
+/******/ 		var deferred = [];
+/******/ 		__webpack_require__.O = (result, chunkIds, fn, priority) => {
+/******/ 			if(chunkIds) {
+/******/ 				priority = priority || 0;
+/******/ 				for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];
+/******/ 				deferred[i] = [chunkIds, fn, priority];
+/******/ 				return;
+/******/ 			}
+/******/ 			var notFulfilled = Infinity;
+/******/ 			for (var i = 0; i < deferred.length; i++) {
+/******/ 				var [chunkIds, fn, priority] = deferred[i];
+/******/ 				var fulfilled = true;
+/******/ 				for (var j = 0; j < chunkIds.length; j++) {
+/******/ 					if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {
+/******/ 						chunkIds.splice(j--, 1);
+/******/ 					} else {
+/******/ 						fulfilled = false;
+/******/ 						if(priority < notFulfilled) notFulfilled = priority;
+/******/ 					}
+/******/ 				}
+/******/ 				if(fulfilled) {
+/******/ 					deferred.splice(i--, 1)
+/******/ 					var r = fn();
+/******/ 					if (r !== undefined) result = r;
+/******/ 				}
+/******/ 			}
+/******/ 			return result;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/node module decorator */
+/******/ 	(() => {
+/******/ 		__webpack_require__.nmd = (module) => {
+/******/ 			module.paths = [];
+/******/ 			if (!module.children) module.children = [];
+/******/ 			return module;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/jsonp chunk loading */
+/******/ 	(() => {
+/******/ 		// no baseURI
+/******/ 		
+/******/ 		// object to store loaded and loading chunks
+/******/ 		// undefined = chunk not loaded, null = chunk preloaded/prefetched
+/******/ 		// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
+/******/ 		var installedChunks = {
+/******/ 			1855: 0,
+/******/ 			8016: 0,
+/******/ 			410: 0,
+/******/ 			1981: 0
+/******/ 		};
+/******/ 		
+/******/ 		// no chunk on demand loading
+/******/ 		
+/******/ 		// no prefetching
+/******/ 		
+/******/ 		// no preloaded
+/******/ 		
+/******/ 		// no HMR
+/******/ 		
+/******/ 		// no HMR manifest
+/******/ 		
+/******/ 		__webpack_require__.O.j = (chunkId) => (installedChunks[chunkId] === 0);
+/******/ 		
+/******/ 		// install a JSONP callback for chunk loading
+/******/ 		var webpackJsonpCallback = (parentChunkLoadingFunction, data) => {
+/******/ 			var [chunkIds, moreModules, runtime] = data;
+/******/ 			// add "moreModules" to the modules object,
+/******/ 			// then flag all "chunkIds" as loaded and fire callback
+/******/ 			var moduleId, chunkId, i = 0;
+/******/ 			if(chunkIds.some((id) => (installedChunks[id] !== 0))) {
+/******/ 				for(moduleId in moreModules) {
+/******/ 					if(__webpack_require__.o(moreModules, moduleId)) {
+/******/ 						__webpack_require__.m[moduleId] = moreModules[moduleId];
+/******/ 					}
+/******/ 				}
+/******/ 				if(runtime) var result = runtime(__webpack_require__);
+/******/ 			}
+/******/ 			if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
+/******/ 			for(;i < chunkIds.length; i++) {
+/******/ 				chunkId = chunkIds[i];
+/******/ 				if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
+/******/ 					installedChunks[chunkId][0]();
+/******/ 				}
+/******/ 				installedChunks[chunkIds[i]] = 0;
+/******/ 			}
+/******/ 			return __webpack_require__.O(result);
+/******/ 		}
+/******/ 		
+/******/ 		var chunkLoadingGlobal = self["webpackChunkatoka_design_system"] = self["webpackChunkatoka_design_system"] || [];
+/******/ 		chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
+/******/ 		chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module depends on other loaded chunks and execution need to be delayed
+/******/ 	var __webpack_exports__ = __webpack_require__.O(undefined, [1981], () => (__webpack_require__(69)))
+/******/ 	__webpack_exports__ = __webpack_require__.O(__webpack_exports__);
+/******/ 	
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});
+//# sourceMappingURL=index.js.map