@evergis/react 3.0.24 → 3.1.0

package/dist/react.cjs.development.js

@@ -2,437 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var React = require('react');
-var React__default = _interopDefault(React);
-var styled = require('styled-components');
-var styled__default = _interopDefault(styled);
-var icons = require('@evergis/icons');
-var svg_js = require('@svgdotjs/svg.js');
-var Color = require('@evergis/color/es/Color');
-var api = require('@evergis/api');
 var dateFns = require('date-fns');
-var condition = require('@evergis/condition');
-var i18n = _interopDefault(require('i18next'));
-var reactI18next = require('react-i18next');
-var LanguageDetector = _interopDefault(require('i18next-browser-languagedetector'));
-var get = _interopDefault(require('lodash/get'));
-var lodash = require('lodash');
-var BrushFill = require('@evergis/sgis/es/symbols/polygon/BrushFill');
-var color = require('@evergis/color');
-var ImageFill = require('@evergis/sgis/es/symbols/polygon/ImageFill');
-var Simple = require('@evergis/sgis/es/symbols/polygon/Simple');
-var PolylineSymbol = require('@evergis/sgis/es/symbols/PolylineSymbol');
-var Poly = require('@evergis/sgis/es/renders/Poly');
-var geotools = require('@evergis/sgis/es/geotools');
-var math = require('@evergis/sgis/es/utils/math');
-var Poly$1 = require('@evergis/sgis/es/features/Poly');
-var Point = require('@evergis/sgis/es/symbols/point/Point');
-var PointFeature = require('@evergis/sgis/es/features/PointFeature');
-var Arc = require('@evergis/sgis/es/renders/Arc');
-var _Symbol = require('@evergis/sgis/es/symbols/Symbol');
-var Render = require('@evergis/sgis/es/renders/Render');
-var SvgRender = require('@evergis/sgis/es/painters/DomPainter/SvgRender');
-var domEvent = require('@evergis/sgis/es/utils/domEvent');
-var EventHandler = require('@evergis/sgis/es/EventHandler');
-var Crs = require('@evergis/sgis/es/Crs');
-var StaticImageSymbol = require('@evergis/sgis/es/symbols/point/StaticImageSymbol');
-var Square = require('@evergis/sgis/es/symbols/point/Square');
-var MaskedImage = require('@evergis/sgis/es/symbols/point/MaskedImage');
-var H3Symbol = require('@evergis/sgis/es/symbols/H3Symbol');
-var CombinedPolylineSymbol = require('@evergis/sgis/es/symbols/CombinedPolylineSymbol');
-var Polygon = require('@evergis/sgis/es/features/Polygon');
-var Polyline = require('@evergis/sgis/es/features/Polyline');
-var H3Feature = require('@evergis/sgis/es/features/H3Feature');
-var CombinedPolyline = require('@evergis/sgis/es/features/CombinedPolyline');
-var Canvas = require('@evergis/sgis/es/painters/DomPainter/Canvas');
-
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
-}
-
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
-  }
-}
-
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  return Constructor;
-}
-
-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 _inherits(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function");
-  }
-
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      writable: true,
-      configurable: true
-    }
-  });
-  if (superClass) _setPrototypeOf(subClass, superClass);
-}
-
-function _getPrototypeOf(o) {
-  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-    return o.__proto__ || Object.getPrototypeOf(o);
-  };
-  return _getPrototypeOf(o);
-}
-
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-
-  return _setPrototypeOf(o, p);
-}
-
-function _isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
-
-  try {
-    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-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;
-}
-
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-  }
-
-  return self;
-}
-
-function _possibleConstructorReturn(self, call) {
-  if (call && (typeof call === "object" || typeof call === "function")) {
-    return call;
-  }
-
-  return _assertThisInitialized(self);
-}
-
-function _createSuper(Derived) {
-  var hasNativeReflectConstruct = _isNativeReflectConstruct();
-
-  return function _createSuperInternal() {
-    var Super = _getPrototypeOf(Derived),
-        result;
-
-    if (hasNativeReflectConstruct) {
-      var NewTarget = _getPrototypeOf(this).constructor;
-
-      result = Reflect.construct(Super, arguments, NewTarget);
-    } else {
-      result = Super.apply(this, arguments);
-    }
-
-    return _possibleConstructorReturn(this, result);
-  };
-}
-
-function _superPropBase(object, property) {
-  while (!Object.prototype.hasOwnProperty.call(object, property)) {
-    object = _getPrototypeOf(object);
-    if (object === null) break;
-  }
-
-  return object;
-}
-
-function _get(target, property, receiver) {
-  if (typeof Reflect !== "undefined" && Reflect.get) {
-    _get = Reflect.get;
-  } else {
-    _get = function _get(target, property, receiver) {
-      var base = _superPropBase(target, property);
-
-      if (!base) return;
-      var desc = Object.getOwnPropertyDescriptor(base, property);
-
-      if (desc.get) {
-        return desc.get.call(receiver);
-      }
-
-      return desc.value;
-    };
-  }
-
-  return _get(target, property, receiver || target);
-}
-
-function _taggedTemplateLiteralLoose(strings, raw) {
-  if (!raw) {
-    raw = strings.slice(0);
-  }
 
-  strings.raw = raw;
-  return strings;
-}
-
-const isParameterType = (types, parameter) => {
-  var _parameter$toLowerCas;
-
-  return (typeof types === 'string' ? parameter == null ? void 0 : (_parameter$toLowerCas = parameter.toLowerCase()) == null ? void 0 : _parameter$toLowerCas.includes(types.toLowerCase()) : types.some(type => {
-    var _parameter$toLowerCas2;
-
-    return parameter == null ? void 0 : (_parameter$toLowerCas2 = parameter.toLowerCase()) == null ? void 0 : _parameter$toLowerCas2.includes(type.toLowerCase());
-  })) || false;
-};
-
-var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10, _templateObject11, _templateObject12, _templateObject13, _templateObject14, _templateObject15, _templateObject16, _templateObject17, _templateObject18, _templateObject19, _templateObject20, _templateObject21, _templateObject22, _templateObject23, _templateObject24, _templateObject25, _templateObject26, _templateObject27, _templateObject28, _templateObject29, _templateObject30, _templateObject31, _templateObject32, _templateObject33, _templateObject34, _templateObject35, _templateObject36, _templateObject37, _templateObject38;
-const MapLegendDescription = /*#__PURE__*/styled__default.div(_templateObject || (_templateObject = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  font-size: 0.75rem;\n"])));
-const ItemText = /*#__PURE__*/styled__default.div(_templateObject2 || (_templateObject2 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  max-width: calc(100% - 2rem);\n  font: ", ";\n"])), (_ref) => {
-  let {
-    theme: {
-      fonts
-    }
-  } = _ref;
-  return fonts.description;
-});
-const ItemSeparator = /*#__PURE__*/styled__default.div(_templateObject3 || (_templateObject3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  :after {\n    content: '-';\n    margin: 0 0.5rem;\n    font-size: 0.75rem;\n  }\n"])));
-const SymbolContainer = /*#__PURE__*/styled__default('span')(_templateObject4 || (_templateObject4 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  justify-content: center;\n  min-width: 1.5rem;\n  margin-right: 0.5rem;\n"])));
-const ClassifiedItem = /*#__PURE__*/styled__default.div(_templateObject5 || (_templateObject5 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  flex-direction: row;\n  align-items: center;\n  cursor: ", ";\n  pointer-events: ", ";\n\n  :not(:last-of-type) {\n    margin-bottom: 0.25rem;\n  }\n\n  ", ", ", " {\n    transition: opacity 150ms;\n  }\n\n  ", " {\n    opacity: ", ";\n  }\n\n  ", " {\n    opacity: ", ";\n  }\n\n  :hover {\n    ", ", ", " {\n      opacity: 1;\n    }\n  }\n\n  ", " {\n    margin-left: 0.5rem;\n  }\n"])), (_ref2) => {
-  let {
-    isClusterFillColor
-  } = _ref2;
-  return isClusterFillColor ? 'default' : 'pointer';
-}, (_ref3) => {
-  let {
-    isClusterFillColor
-  } = _ref3;
-  return isClusterFillColor ? 'none' : 'auto';
-}, ItemText, SymbolContainer, ItemText, (_ref4) => {
-  let {
-    isHidden
-  } = _ref4;
-  return isHidden ? 0.28 : 0.65;
-}, SymbolContainer, (_ref5) => {
-  let {
-    isHidden
-  } = _ref5;
-  return isHidden ? 0.28 : 1;
-}, ItemText, SymbolContainer, icons.IconButton);
-const SymbolButtonWithClick = /*#__PURE__*/styled.css(_templateObject6 || (_templateObject6 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  width: 3.875rem;\n  height: 3.875rem;\n  cursor: pointer;\n\n  &:hover {\n    background-color: ", ";\n  }\n"])), (_ref6) => {
-  let {
-    theme: {
-      palette
-    }
-  } = _ref6;
-  return palette.elementDeep;
-});
-const SymbolButton = /*#__PURE__*/styled__default.span(_templateObject7 || (_templateObject7 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  transition: background-color 150ms;\n  ", ";\n\n  svg {\n    max-width: 4rem;\n    max-height: 4rem;\n  }\n"])), (_ref7) => {
-  let {
-    onClick
-  } = _ref7;
-  return !!onClick && SymbolButtonWithClick;
-});
-const MapLegendContainer = /*#__PURE__*/styled__default.div(_templateObject8 || (_templateObject8 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  flex-direction: column;\n  justify-content: space-between;\n  width: 100%;\n  padding-bottom: 1rem;\n  box-sizing: border-box;\n\n  canvas {\n    height: 1.625rem;\n    width: 1.625rem;\n  }\n"])));
-const MapLegendHeader = /*#__PURE__*/styled__default.div(_templateObject9 || (_templateObject9 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  max-width: 15rem;\n  margin-bottom: 0.25rem;\n  font-size: 0.75rem;\n  font-weight: bold;\n"])));
-const MapLegendDescriptionContainer = /*#__PURE__*/styled__default.div(_templateObject10 || (_templateObject10 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  margin-bottom: 0.5rem;\n  font-weight: 400;\n  font-size: 0.625rem;\n  color: rgba(48, 69, 79, 0.65);\n"])));
-const MapLegendBadge = /*#__PURE__*/styled__default.span(_templateObject11 || (_templateObject11 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  min-width: 0.5rem;\n  height: 0.75rem;\n  display: inline-block;\n  margin-left: 0.25rem;\n  padding: 0.125rem 0.25rem;\n  border-radius: ", ";\n  background-color: ", ";\n  color: ", ";\n  text-align: center;\n"])), (_ref8) => {
-  let {
-    theme: {
-      borderRadius
-    }
-  } = _ref8;
-  return borderRadius.xSmall;
-}, (_ref9) => {
-  let {
-    theme: {
-      palette
-    }
-  } = _ref9;
-  return palette.element;
-}, (_ref10) => {
-  let {
-    theme: {
-      palette
-    }
-  } = _ref10;
-  return palette.textPrimary;
-});
-const MaximizedLegendContainer = /*#__PURE__*/styled__default.div(_templateObject12 || (_templateObject12 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  position: ", ";\n  top: 0;\n  opacity: ", ";\n  visibility: ", ";\n  overflow: hidden;\n  transition: opacity 0.5s, visibility 0.5s;\n"])), (_ref11) => {
-  let {
-    isShown
-  } = _ref11;
-  return isShown ? 'relative' : 'absolute';
-}, (_ref12) => {
-  let {
-    isShown
-  } = _ref12;
-  return isShown ? 1 : 0;
-}, (_ref13) => {
-  let {
-    isShown
-  } = _ref13;
-  return isShown ? 'visible' : 'hidden';
-});
-const MinimizedLegendContainer = /*#__PURE__*/styled__default(MaximizedLegendContainer)(_templateObject13 || (_templateObject13 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  width: calc(100% - 1.5rem);\n  padding-right: 1.5rem;\n"])));
-const LegendHeaderButton = /*#__PURE__*/styled__default.span(_templateObject14 || (_templateObject14 = /*#__PURE__*/_taggedTemplateLiteralLoose([""])));
-const MapLegendSectionContainer = /*#__PURE__*/styled__default.div(_templateObject15 || (_templateObject15 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  width: 100%;\n\n  :not(:last-child) {\n    margin-bottom: 1rem;\n  }\n\n  ", " {\n    padding-left: 0.75rem;\n    visibility: hidden;\n\n    :first-child {\n      padding-left: 1rem;\n    }\n\n    :last-child {\n      margin-left: 0.75rem;\n      border-left: 1px ", " solid;\n    }\n  }\n  \n  :hover {\n    ", " {\n      visibility: visible;\n    }\n  }\n"])), LegendHeaderButton, (_ref14) => {
-  let {
-    theme: {
-      palette
-    }
-  } = _ref14;
-  return palette.elementDeep;
-}, LegendHeaderButton);
-const MapLegendSectionItems = /*#__PURE__*/styled__default.div(_templateObject16 || (_templateObject16 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  position: relative;\n  height: ", "px;\n  overflow: ", ";\n  transition: height 0.5s;\n"])), (_ref15) => {
-  let {
-    minHeight,
-    maxHeight,
-    isExpanded
-  } = _ref15;
-  return isExpanded ? (maxHeight || 0) + 4 : minHeight;
-}, (_ref16) => {
-  let {
-    isExpanded
-  } = _ref16;
-  return isExpanded ? 'none' : 'hidden';
-});
-const MapLegendValueDescr = /*#__PURE__*/styled__default.div(_templateObject17 || (_templateObject17 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  min-height: 1rem;\n  margin-bottom: 0.25rem;\n  font-size: 0.75rem;\n  font-weight: 600;\n  line-height: 1rem;\n"])));
-
-const SizeLegendItemMixin = function SizeLegendItemMixin(value) {
-  if (value === void 0) {
-    value = 0;
-  }
-
-  return styled.css(_templateObject18 || (_templateObject18 = _taggedTemplateLiteralLoose(["\n  position: absolute;\n  bottom: 0;\n  left: 50%;\n  display: flex;\n  align-items: flex-end;\n  flex: none;\n  height: inherit;\n  width: inherit;\n  margin: 0 auto;\n  background: none;\n  border: none;\n\n  :after {\n    content: '';\n    display: flex;\n    border: 1px rgba(48, 69, 79, 0.28) solid;\n    border-radius: 50%;\n    margin: 0 0 0 -", "px;\n    width: ", "px;\n    height: ", "px;\n  }\n"])), value / 2, value, value);
-};
-
-const StrokeWidthLegendItemMixin = function StrokeWidthLegendItemMixin(value) {
-  if (value === void 0) {
-    value = 0;
-  }
-
-  return styled.css(_templateObject19 || (_templateObject19 = _taggedTemplateLiteralLoose(["\n  position: relative;\n  background: none;\n  border: none;\n  display: flex;\n  align-items: center;\n  flex: none;\n  width: calc(100% - 2rem);\n  height: ", "px;\n  margin: 0 0 0.25rem 0;\n  padding-left: 2rem;\n  font-size: 0.75rem;\n\n  :first-child,\n  :last-child {\n    height: auto;\n  }\n\n  :after {\n    content: '';\n    position: absolute;\n    top: 50%;\n    left: 0;\n    width: 1.5rem;\n    height: ", "px;\n    margin-top: -", "px;\n    background: rgb(224, 224, 224);\n  }\n"])), value, value, Math.round(value / 2));
-};
-
-const StrokeColorLegendItemMixin = /*#__PURE__*/styled.css(_templateObject20 || (_templateObject20 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  margin-right: 0.5rem;\n  width: 1.5rem;\n"])));
-const MapLegendItem = /*#__PURE__*/styled__default.div(_templateObject21 || (_templateObject21 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  flex: 1;\n  height: ", "rem;\n  background: ", ";\n  border: 1px rgba(48, 69, 79, 0.1) solid;\n  margin-right: -1px;\n  color: rgba(48, 69, 79, 0.65);\n  opacity: ", ";\n\n  ", "\n\n  ", "\n"])), (_ref17) => {
-  let {
-    parameter
-  } = _ref17;
-  return isParameterType(['strokeColor', 'stroke.color'], parameter) ? 0.25 : 1;
-}, (_ref18) => {
-  let {
-    value
-  } = _ref18;
-  return typeof value === 'number' ? 'none' : value;
-}, (_ref19) => {
-  let {
-    isHidden
-  } = _ref19;
-  return isHidden ? 0.28 : 1;
-}, (_ref20) => {
-  let {
-    value,
-    parameter
-  } = _ref20;
-  return isParameterType('size', parameter) && SizeLegendItemMixin(value);
-}, (_ref21) => {
-  let {
-    value,
-    parameter
-  } = _ref21;
-  return isParameterType(['strokeWidth', 'stroke.width'], parameter) && StrokeWidthLegendItemMixin(value);
-});
-const MapLegendOther = /*#__PURE__*/styled__default(MapLegendItem)(_templateObject22 || (_templateObject22 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  align-items: center;\n  flex: none;\n  position: relative;\n  width: 1rem;\n  margin-left: 0.25rem;\n  border-radius: 0.125rem;\n"])));
-const SizeLegendItemsMixin = /*#__PURE__*/styled.css(_templateObject23 || (_templateObject23 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  position: relative;\n  width: 2rem;\n  height: 2rem;\n  margin: 0 auto;\n\n  ", " {\n    width: auto;\n    margin-left: 0;\n  }\n"])), MapLegendOther);
-const StrokeWidthLegendItemsMixin = /*#__PURE__*/styled.css(_templateObject24 || (_templateObject24 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  position: relative;\n  flex-direction: column;\n  width: auto;\n\n  ", " {\n    width: calc(100% - 2rem);\n    margin-left: 0;\n  }\n"])), MapLegendOther);
-const SizeMinimizedLegend = /*#__PURE__*/styled__default.div(_templateObject25 || (_templateObject25 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  flex-wrap: nowrap;\n  align-items: center;\n  margin: 0.5rem 0 0.25rem;\n"])));
-const SizeMinimizedLegendSymbol = /*#__PURE__*/styled__default.div(_templateObject26 || (_templateObject26 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  width: 4rem;\n  margin-right: 0.75rem;\n"])));
-const SizeMinimizedLegendLabel = /*#__PURE__*/styled__default.div(_templateObject27 || (_templateObject27 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  max-width: 9.75rem;\n  font-size: 0.75rem;\n"])));
-const SizeMinimizedLegendDown = /*#__PURE__*/styled__default.div(_templateObject28 || (_templateObject28 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  color: rgba(48, 69, 79, 0.65);\n"])));
-const SizeMinimizedLegendUp = /*#__PURE__*/styled__default(SizeMinimizedLegendDown)(_templateObject29 || (_templateObject29 = /*#__PURE__*/_taggedTemplateLiteralLoose([""])));
-const SingleSizeLegendItemsMixin = /*#__PURE__*/styled.css(_templateObject30 || (_templateObject30 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  width: 4rem;\n  margin-right: 0.75rem;\n\n  ", ":after {\n    margin: 0 auto;\n  }\n"])), MapLegendItem);
-const SingleLegendItemsMixin = /*#__PURE__*/styled.css(_templateObject31 || (_templateObject31 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  justify-content: center;\n  width: 2rem;\n  height: auto;\n  margin: 0;\n  ", "\n\n  ", " {\n    position: relative;\n    top: 0;\n    left: 0;\n    display: flex;\n    align-content: center;\n    justify-content: center;\n    margin: 0;\n    height: auto;\n    width: auto;\n\n    ", "\n  }\n"])), (_ref22) => {
-  let {
-    isSize
-  } = _ref22;
-  return isSize && SingleSizeLegendItemsMixin;
-}, MapLegendItem, (_ref23) => {
-  let {
-    parameter
-  } = _ref23;
-  return isParameterType(['strokeColor', 'stroke.color'], parameter) && StrokeColorLegendItemMixin;
-});
-const MapLegendItems = /*#__PURE__*/styled__default.div(_templateObject32 || (_templateObject32 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  align-items: center;\n  width: 100%;\n  border-radius: 0.125rem;\n\n  ", ";\n  ", ";\n  ", ";\n"])), (_ref24) => {
-  let {
-    isSize
-  } = _ref24;
-  return isSize && SizeLegendItemsMixin;
-}, (_ref25) => {
-  let {
-    isStrokeWidth
-  } = _ref25;
-  return isStrokeWidth && StrokeWidthLegendItemsMixin;
-}, (_ref26) => {
-  let {
-    isSingle
-  } = _ref26;
-  return isSingle && SingleLegendItemsMixin;
-});
-const MapLegendItemsContainer = /*#__PURE__*/styled__default.div(_templateObject33 || (_templateObject33 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  width: 100%;\n\n  ", " {\n    :first-child {\n      border-top-left-radius: 0.125rem;\n      border-bottom-left-radius: 0.125rem;\n    }\n\n    :last-child {\n      border-top-right-radius: 0.125rem;\n      border-bottom-right-radius: 0.125rem;\n    }\n  }\n"])), MapLegendItem);
-const MapLegendValues = /*#__PURE__*/styled__default.div(_templateObject34 || (_templateObject34 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  width: 100%;\n  margin-top: 0.5rem;\n  font-size: 0.75rem;\n  color: rgba(48, 69, 79, 0.65);\n"])));
-const MapLegendValuesRange = /*#__PURE__*/styled__default.div(_templateObject35 || (_templateObject35 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  justify-content: space-between;\n  width: calc(100% - 1.25rem);\n\n  div {\n    flex: 1;\n    text-overflow: ellipsis;\n    overflow: hidden;\n    white-space: nowrap;\n\n    :first-child {\n      margin-right: 0.5rem;\n    }\n\n    :last-child {\n      margin-left: 0.5rem;\n      text-align: right;\n    }\n  }\n"])));
-const MapLegendValuesOther = /*#__PURE__*/styled__default(MapLegendOther)(_templateObject36 || (_templateObject36 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  justify-content: center;\n  border: 0;\n  overflow: visible;\n"])));
-const MapLegendExpandButton = /*#__PURE__*/styled__default.div(_templateObject37 || (_templateObject37 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  cursor: pointer;\n  margin-top: 0.1rem;\n  font-size: 0.625rem;\n  color: #1fb3aa;\n"])));
-const ClusterLegendContainer = /*#__PURE__*/styled__default.div(_templateObject38 || (_templateObject38 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  margin: -0.9rem;\n  transform: scale(0.5);\n"])));
-
-const NO_CONTENT_VALUE = '—';
+const NO_CONTENT_VALUE = "—";
 
 (function (DateFormat) {
   DateFormat["ClientDefaultFormat"] = "dd.MM.yyyy HH:mm";
@@ -474,4444 +46,15 @@ const formatDate = function formatDate(date, _temp) {
   return defaultValue.toString();
 };
 
-function numberWithSpaces(x, fractionDigits, delim) {
-  if (fractionDigits === void 0) {
-    fractionDigits = 2;
-  }
-
-  if (delim === void 0) {
-    delim = ',';
-  }
-
-  const [num, frac] = x.toFixed(fractionDigits).split('.');
-  const numWithSpaces = num.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
-  return [numWithSpaces, frac].join(delim);
-}
-
-function matchPhone(value) {
-  const phoneRegexp = /((8|\+7)[- ]?)?(\(?\d{3,4}\)?[- ]?)?[\d\- ]{7,10}/g;
-  return !isStringAsInn(value) && value.match(phoneRegexp);
-}
-function isStringAsInn(value) {
-  const innRegexp = /^(([0-9]{12})|([0-9]{10}))$/;
-  return innRegexp.test(value);
-}
-function isStringAsKpp(value) {
-  const kppRegexp = /^(([0-9]{9}))$/;
-  return kppRegexp.test(value);
-}
-function isStringAsOgrn(value) {
-  const ogrnRegexp = /^([0-9]{13})?$/;
-  return ogrnRegexp.test((+value).toString());
-}
-function isStringContainsDate(value) {
-  const dateRegexp = /\d{4}(-|\/)\d{2}(-|\/)\d{2}/g;
-  return dateRegexp.test(value);
-}
-function isRequisiteNumbers(value) {
-  return isStringAsInn(value) || isStringAsKpp(value) || isStringAsOgrn(value);
-}
-function isStringAsPhone(value) {
-  const phoneRegexp = /^((8|\+7)[- ]?)?(\(?\d{3,4}\)?[- ]?)?[\d\- ]{7,10}/;
-  return !isRequisiteNumbers(value) && !isStringContainsDate(value) && phoneRegexp.test(value);
-}
-function isStringAsMail(value) {
-  return isStringAsUrl(value) && value.includes('@');
-}
-function isStringAsUrl(value) {
-  if (isValidUrl(value)) {
-    return true;
-  }
-
-  const urlRegexp = /(http(s)?:\/\/.)?(www\.)?[-a-zA-Z0-9@:%._+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_+.~#?&//=]*)/g;
-  const urlKind = value.match(urlRegexp);
-  return urlKind !== null;
-}
-function isValidUrl(value) {
-  try {
-    new URL(value);
-  } catch (_) {
-    return false;
-  }
-
-  return true;
-}
-const mailHref = mail => "mailto:" + mail;
-const phoneHref = mail => "tel:" + mail;
-const urlHref = url => isValidUrl(url) ? url : "//" + url;
-
-const stringAttribute = value => ({
-  type: 0
-  /* String */
-  ,
-  value
-});
-
-const urlAttribute = value => ({
-  type: 2
-  /* Url */
-  ,
-  value
-});
-
-const mailAttribute = value => ({
-  type: 3
-  /* Mail */
-  ,
-  value
-});
-
-const phoneAttribute = value => ({
-  type: 1
-  /* Phone */
-  ,
-  value
-});
-
-const convertStringAttribute = value => {
-  if (isStringAsMail(value)) {
-    return mailAttribute(value);
-  }
-
-  if (isStringAsUrl(value)) {
-    return urlAttribute(value);
-  }
-
-  if (isStringAsPhone(value)) {
-    return phoneAttribute(value);
-  }
-
-  return stringAttribute(value);
-};
-
-const formatStringAttribute = value => {
-  const phones = matchPhone(value);
-
-  if (!isRequisiteNumbers(value) && !isStringContainsDate(value) && phones && phones.length) {
-    return phones.map(phoneAttribute);
-  }
-
-  const attributeValues = value.split(/[\s|]/).map(convertStringAttribute);
-
-  if (attributeValues.every((_ref) => {
-    let {
-      type
-    } = _ref;
-    return type === 0;
-  }
-  /* String */
-  )) {
-    return [stringAttribute(attributeValues.map((_ref2) => {
-      let {
-        value
-      } = _ref2;
-      return isNaN(+value) || isRequisiteNumbers(value) ? isStringAsOgrn(value) ? +value : value : numberWithSpaces(+value, 0, '');
-    }).join(' '))];
-  }
-
-  return attributeValues;
-};
-
-const formatDateTimeAttribute = value => stringAttribute(value.toString());
-
-const formatIntAttribute = value => stringAttribute(numberWithSpaces(value, 0, ''));
-
-const DOUBLE_FRACTIONS = 2;
-
-const formatDoubleAttribute = value => stringAttribute(numberWithSpaces(value, DOUBLE_FRACTIONS, '.'));
-
-const isNullOrUndefined = value => value === null || value === undefined;
-
-const NO_CONTENT_ATTRIBUTE = {
-  type: 0
-  /* String */
-  ,
-  value: NO_CONTENT_VALUE
-};
-const formatAttributeValue = attribute => {
-  if (isNullOrUndefined(attribute.value)) {
-    return [NO_CONTENT_ATTRIBUTE];
-  }
-
-  switch (attribute.type) {
-    case 'String':
-      return formatStringAttribute(attribute.value);
-
-    case 'DateTime':
-      return [formatDateTimeAttribute(attribute.value)];
-
-    case 'Int32':
-    case 'Int64':
-      return [formatIntAttribute(attribute.value)];
-
-    case 'Double':
-      return [formatDoubleAttribute(attribute.value)];
-
-    default:
-      return [NO_CONTENT_ATTRIBUTE];
-  }
-};
-
-function isRangeClass(value) {
-  return Boolean(value && 'from' in value);
-}
-function isUniqueClass(value) {
-  return Boolean(value && 'uniqueValue' in value);
-}
-
-const NULL_EXPRESSION = {
-  // @ts-ignore TODO
-  attribute: null,
-  // @ts-ignore TODO
-  operation: null,
-  value: null
-};
-let ClassificationCondition = /*#__PURE__*/function () {
-  function ClassificationCondition(condition$1) {
-    _classCallCheck(this, ClassificationCondition);
-
-    this.expressions = [];
-    this.condition = condition$1;
-    const conditionResult = new condition.ConditionInterpreter(condition$1).value;
-    this.expressions = conditionResult instanceof Error ? [] : conditionResult.expressions;
-  }
-
-  _createClass(ClassificationCondition, [{
-    key: "attributeName",
-    get: function get() {
-      return this.leftExpression.attribute;
-    }
-  }, {
-    key: "uniqueValue",
-    get: function get() {
-      if (this.isUnique()) {
-        const {
-          value
-        } = this.leftExpression;
-        return typeof value === 'string' ? value : '';
-      }
-
-      console.warn("Trying to get unique from range condition " + this.condition);
-      return '';
-    }
-  }, {
-    key: "range",
-    get: function get() {
-      if (!this.isRange()) {
-        console.warn("Trying to get range from unique condition " + this.condition);
-        return [0, 0];
-      }
-
-      if (this.expressions.length === 2) {
-        const {
-          value: from
-        } = this.leftExpression;
-        const {
-          value: to
-        } = this.rightExpression;
-        return [from, to];
-      }
-
-      if (this.expressions.length === 1) {
-        const {
-          operation,
-          value
-        } = this.leftExpression;
-        const isFrom = operation === condition.TokenType.ArGr;
-        return [isFrom ? value : null, isFrom ? null : value];
-      }
-
-      return [0, 0];
-    }
-  }, {
-    key: "type",
-    get: function get() {
-      return this.isUnique() ? 1
-      /* Unique */
-      : 0
-      /* Range */
-      ;
-    }
-  }, {
-    key: "isUnique",
-    value: function isUnique() {
-      return this.leftExpression.operation === condition.TokenType.ArEq;
-    }
-  }, {
-    key: "isRange",
-    value: function isRange() {
-      return [condition.TokenType.ArGr, condition.TokenType.ArGre, condition.TokenType.ArLs, condition.TokenType.ArLse].includes(this.leftExpression.operation);
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return this.condition;
-    }
-  }, {
-    key: "leftExpression",
-    get: function get() {
-      return this.expressions.length > 0 ? this.expressions[0] : NULL_EXPRESSION;
-    }
-  }, {
-    key: "rightExpression",
-    get: function get() {
-      return this.expressions.length > 1 ? this.expressions[1] : NULL_EXPRESSION;
-    }
-  }]);
-
-  return ClassificationCondition;
-}();
-
-const PARAMETER_SEPARATOR = '.';
-const parameterToPaths = parameter => parameter.split(PARAMETER_SEPARATOR);
-const pathsToParameter = paths => paths.join(PARAMETER_SEPARATOR);
+const isNumeric = number => !isNaN(parseFloat(number)) && isFinite(number);
 
 function isObject(value) {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-const isParameterByAttribute = value => Boolean(isObject(value) && (value == null ? void 0 : value.type) === 'byAttribute');
-const isCalculatedParameter = value => Boolean(isObject(value) && (value == null ? void 0 : value.type) === 'calculated');
-const getParameterValue = value => {
-  if (isParameterByAttribute(value) || isCalculatedParameter(value)) {
-    return value.defaultValue;
-  }
-
-  return value;
-};
-const symbolParameterWalker = valueModifier => (symbol, parameter) => {
-  const paths = Array.isArray(parameter) ? parameter : parameterToPaths(parameter);
-  const [firstKey, ...restKeys] = paths; // @ts-ignore
-
-  const symbolPart = symbol[firstKey];
-
-  if (restKeys.length) {
-    const goDeeper = symbolParameterWalker(valueModifier);
-    return _extends({}, symbol, {
-      [firstKey]: goDeeper(symbolPart, restKeys) || symbolPart
-    });
-  }
-
-  return _extends({}, symbol, {
-    [firstKey]: valueModifier(symbolPart) || symbolPart
-  });
-};
-const setDefaultParameterValue = /*#__PURE__*/symbolParameterWalker(getParameterValue);
-const setParameterValue = (symbol, path, value) => symbolParameterWalker(() => value)(symbol, path);
-function applyParameterValue(symbol, path, value) {
-  if (path === 'symbol') {
-    return value;
-  }
-
-  return setParameterValue(symbol, path, value);
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-const symbolTypeGuard = type => symbol => symbol && symbol.type === type;
-
-const isPointLabelSymbol = /*#__PURE__*/symbolTypeGuard('labelPointSymbol');
-const isPolygonLabelSymbol = /*#__PURE__*/symbolTypeGuard('polygonLabelSymbol');
-const isPolylineLabelSymbol = /*#__PURE__*/symbolTypeGuard('polylineLabelSymbol');
-const isLabelSymbol = symbol => Boolean(symbol && (isPointLabelSymbol(symbol) || isPolygonLabelSymbol(symbol) || isPolylineLabelSymbol(symbol)));
-
-const _excluded = ["ignoreLabel", "label", "symbol", "raster", "children"];
-const createCompositeSymbol = childSymbols => ({
-  type: 'compositeSymbol',
-  childSymbols
-});
-const getChildSymbols = symbol => {
-  if (!symbol || !isCompositeSymbol(symbol)) return [];
-  return symbol.childSymbols || [];
-};
-const extractSymbol = symbol => {
-  const childSymbols = getChildSymbols(symbol);
-  return {
-    // @ts-ignore
-    symbol: childSymbols.find(isSimpleSymbol),
-    label: childSymbols.find(isLabelSymbol) || null,
-    raster: childSymbols.find(isRasterSymbol) || null
-  };
-};
-const extractStyle = style => {
-  // @ts-ignore
-  if (isCompositeSymbol(style.symbol)) {
-    return _extends({}, style, extractSymbol(style.symbol), {
-      // @ts-ignore
-      children: style.children && style.children.map(extractStyle)
-    });
-  } // NOTE: for cases when style is exist style object should have same reference for all extractStyle calls
-
-
-  return style || {};
-};
-const packStyle = style => {
-  const {
-    ignoreLabel,
-    label,
-    symbol,
-    raster,
-    children
-  } = style,
-        styleDc = _objectWithoutPropertiesLoose(style, _excluded);
-
-  const childSymbols = [!ignoreLabel && label, raster].filter(Boolean);
-  return _extends({}, styleDc, {
-    symbol: childSymbols.length ? // @ts-ignore
-    createCompositeSymbol([symbol, ...childSymbols]) : symbol,
-    // @ts-ignore
-    children: children ? // @ts-ignore
-    children.map(childStyle => packStyle(_extends({}, childStyle, {
-      ignoreLabel,
-      label
-    }))) : children
-  });
-};
-
-const isPointSymbol = /*#__PURE__*/symbolTypeGuard('circlePointSymbol');
-const isSquareSymbol = /*#__PURE__*/symbolTypeGuard('squarePointSymbol');
-const isMaskedImageSymbol = /*#__PURE__*/symbolTypeGuard('maskedImagePointSymbol');
-const isStaticImageSymbol = /*#__PURE__*/symbolTypeGuard('imagePointSymbol');
-const isCombinedPolylineSymbol = /*#__PURE__*/symbolTypeGuard("combinedPolylineSymbol");
-const isPolygonSymbol = /*#__PURE__*/symbolTypeGuard('polygonSymbol');
-const isSimplePolylineSymbol = /*#__PURE__*/symbolTypeGuard('simplePolylineSymbol');
-const isPolylineSymbols = symbol => Boolean(symbol && (isCombinedPolylineSymbol(symbol) || isSimplePolylineSymbol(symbol)));
-const isCompositeSymbol = /*#__PURE__*/symbolTypeGuard('compositeSymbol');
-const isRasterSymbol = /*#__PURE__*/symbolTypeGuard('rasterSymbol');
-const isImageSymbol = symbol => Boolean(symbol && (isMaskedImageSymbol(symbol) || isStaticImageSymbol(symbol)));
-const isTwoDimensionalSymbol = symbol => Boolean(symbol && 'width' in symbol);
-const isSizableSymbol = symbol => Boolean(symbol && 'size' in symbol);
-const isStrokeStyledSymbol = symbol => Boolean(symbol && (isPolygonSymbol(symbol) || isPolylineSymbols(symbol)));
-const isScalablePolylineSymbol = symbol => symbol.beginning !== null && symbol.ending !== null || symbol.stroke && symbol.stroke.type !== 'solid';
-const isSimpleSymbol = symbol => Boolean(symbol && !isLabelSymbol(symbol) && !isCompositeSymbol(symbol) && !isRasterSymbol(symbol));
-const isH3GridSymbol = /*#__PURE__*/symbolTypeGuard("h3grid");
-const isSvgPointSymbol = /*#__PURE__*/symbolTypeGuard("svgPointSymbol");
-const isClusterSymbol = /*#__PURE__*/symbolTypeGuard("cluster");
-const isClusterFillColor = (symbol, parameter) => {
-  return isClusterSymbol(symbol) && parameter === "fillColor";
-};
-const getExtractedSymbol = function getExtractedSymbol(symbol, extractCluster) {
-  var _extractSymbol;
-
-  if (extractCluster === void 0) {
-    extractCluster = false;
-  }
-
-  const extracted = isCompositeSymbol(symbol) ? (_extractSymbol = extractSymbol(symbol)) == null ? void 0 : _extractSymbol.symbol : symbol;
-  return extractCluster && isClusterSymbol(extracted) ? extracted.singleObjectSymbol : extracted;
-};
-
-const isHatchBrush = /*#__PURE__*/symbolTypeGuard('hatch');
-const isPatternBrush = /*#__PURE__*/symbolTypeGuard('pattern');
-const isDashedBrush = /*#__PURE__*/symbolTypeGuard('dashed');
-const isSolidBrush = /*#__PURE__*/symbolTypeGuard('solid');
-const isPolygonHasPatternBrush = symbol => Boolean(symbol && isPolygonSymbol(symbol) && isPatternBrush(symbol.fill));
-const isPolygonHasHatchBrush = symbol => Boolean(symbol && isPolygonSymbol(symbol) && isHatchBrush(symbol.fill));
-
-const isMiterExist = miter => Boolean(miter && miter.type !== api.LineEndingType.None);
-const isFilledLineMitter = miter => miter.type === api.LineEndingType.FilledCircle || miter.type === api.LineEndingType.FilledArrow || miter.type === api.LineEndingType.FilledSquare;
-const isArrowLineMiter = miter => miter.type === api.LineEndingType.Arrow || miter.type === api.LineEndingType.FilledArrow;
-const isSquareLineMiter = miter => miter.type === api.LineEndingType.Square || miter.type === api.LineEndingType.FilledSquare;
-const isCircleLineMiter = miter => miter.type === api.LineEndingType.Circle || miter.type === api.LineEndingType.FilledCircle;
-
-const isSimpleOffset = offset => offset && !isParameterByAttribute(offset[0]) && !isParameterByAttribute(offset[1]);
-const isSymbolWithOffset = symbol => Boolean(symbol && 'offset' in symbol);
-
-const isStringParameterValue = parameterValue => typeof parameterValue === 'string';
-const isParameterValueSimple = parameterValue => typeof parameterValue === 'number' || typeof parameterValue === 'string';
-const isParameterValueSymbol = parameterValue => !isParameterValueSimple(parameterValue);
-
-const isStyle = value => 'symbol' in value;
-
-let EvergisStyle = /*#__PURE__*/function () {
-  function EvergisStyle(style) {
-    _classCallCheck(this, EvergisStyle);
-
-    this.style = extractStyle(style);
-    this.classificationManager = new ClassificationManager(this.style);
-  }
-
-  _createClass(EvergisStyle, [{
-    key: "serialize",
-    value: function serialize() {
-      return packStyle(this.style);
-    }
-  }, {
-    key: "hasRasters",
-    value: function hasRasters() {
-      return !!(this.style.raster || (this.style.children || []).some(style => style.raster));
-    }
-  }, {
-    key: "symbol",
-    get: function get() {
-      return this.style.symbol;
-    }
-  }, {
-    key: "raster",
-    get: function get() {
-      return this.style.raster;
-    }
-  }, {
-    key: "label",
-    get: function get() {
-      return this.style.label;
-    }
-  }, {
-    key: "children",
-    get: function get() {
-      return this.style.children;
-    }
-  }, {
-    key: "title",
-    get: function get() {
-      return this.style.title;
-    }
-  }, {
-    key: "condition",
-    get: function get() {
-      return this.style.condition;
-    }
-  }, {
-    key: "ignoreLabel",
-    get: function get() {
-      return this.style.ignoreLabel;
-    }
-  }, {
-    key: "resolution",
-    get: function get() {
-      const {
-        minResolution,
-        maxResolution
-      } = this.style;
-      return minResolution === void 0 || maxResolution === void 0 ? null : [minResolution, maxResolution];
-    }
-  }]);
-
-  return EvergisStyle;
-}();
-
-const toClassificationClass = (parameterValue, title, condition) => _extends({
-  parameterValue,
-  title
-}, condition.isUnique() ? {
-  uniqueValue: condition.uniqueValue
-} : {
-  from: condition.range[0],
-  to: condition.range[1]
-});
-
-const DEFAULT_EXTRAS = {
-  defaultTitle: '',
-  // @ts-ignore
-  defaultValue: null
-};
-const toClassification = function toClassification(values, parameter, extras) {
-  if (extras === void 0) {
-    extras = DEFAULT_EXTRAS;
-  }
-
-  return (// @ts-ignore
-    values.reduce( // @ts-ignore
-    (classification, value) => {
-      const classificationCondition = new ClassificationCondition(value.condition || '');
-      const classificationValue = toClassificationClass(isStyle(value) ? value.symbol : value.value, // @ts-ignore
-      value.title, classificationCondition);
-      classification.values.push(classificationValue);
-      return _extends({}, classification, {
-        type: classification.type || classificationCondition.type,
-        attribute: classification.attribute || classificationCondition.attributeName
-      });
-    }, _extends({}, extras, {
-      attribute: null,
-      parameter,
-      type: null,
-      values: []
-    }))
-  );
-};
-const getClassifications = function getClassifications(symbol, pathContext) {
-  if (pathContext === void 0) {
-    pathContext = [];
-  }
-
-  return Object.entries(symbol).reduce((classifications, _ref) => {
-    let [parameter, parameterValue] = _ref;
-    const skipHeight = isTwoDimensionalSymbol(symbol) && parameter === 'height';
-    const skip = !isObject(parameterValue) || skipHeight;
-
-    if (skip) {
-      return classifications;
-    }
-
-    if (!isParameterByAttribute(parameterValue)) {
-      return [...classifications, // @ts-ignore
-      ...getClassifications(symbol[parameter], [...pathContext, parameter])];
-    }
-
-    const classification = toClassification(parameterValue.values, pathsToParameter([...pathContext, parameter]), {
-      // @ts-ignore
-      defaultTitle: parameterValue.title,
-      defaultValue: parameterValue.defaultValue
-    });
-    return [...classifications, classification];
-  }, []);
-};
-
-let ClassificationManager = /*#__PURE__*/function () {
-  function ClassificationManager(style) {
-    _classCallCheck(this, ClassificationManager);
-
-    this.style = style;
-    this.classifications = [];
-    this.collectClassifications();
-  }
-
-  _createClass(ClassificationManager, [{
-    key: "values",
-    get: function get() {
-      return this.classifications;
-    }
-  }, {
-    key: "find",
-    value: function find(predicate) {
-      for (const classification of this.classifications) {
-        if (predicate(classification)) {
-          return classification;
-        }
-      }
-
-      return null;
-    }
-  }, {
-    key: "filter",
-    value: function filter(callback) {
-      return this.classifications.filter(callback);
-    }
-  }, {
-    key: "map",
-    value: function map(callback) {
-      return this.classifications.map(callback);
-    }
-  }, {
-    key: "reduce",
-    value: function reduce(callback, initial) {
-      return this.classifications.reduce(callback, initial);
-    }
-  }, {
-    key: "hasClassifications",
-    value: function hasClassifications() {
-      return this.classifications.length > 0;
-    }
-  }, {
-    key: "collectClassifications",
-    value: function collectClassifications() {
-      if (this.style.children && this.style.children.length) {
-        this.classifications.push(toClassification(this.style.children, 'symbol'));
-      }
-
-      if (this.style.symbol) {
-        this.classifications.push(...getClassifications(this.style.symbol));
-      }
-    }
-  }]);
-
-  return ClassificationManager;
-}();
-
-const unClassify = symbol => Object.entries(symbol).reduce((flatSymbol, _ref) => {
-  let [parameter, parameterValue] = _ref;
-  let result = Array.isArray(parameterValue) ? parameterValue.map(getParameterValue) : getParameterValue(parameterValue);
-
-  if (isObject(result)) {
-    return _extends({}, flatSymbol, {
-      [parameter]: unClassify(parameterValue)
-    });
-  }
-
-  return _extends({}, flatSymbol, {
-    [parameter]: result
-  });
-}, {});
-
-const DEFAULT_LANGUAGE = "ru";
-const resources = {
-  en: {},
-  ru: {}
-};
-i18n.use(LanguageDetector).use(reactI18next.initReactI18next).init({
-  fallbackLng: DEFAULT_LANGUAGE,
-  ns: Object.keys(resources[DEFAULT_LANGUAGE]),
-  interpolation: {
-    escapeValue: false
-  },
-  resources,
-  supportedLngs: Object.keys(resources)
-});
-
-const printRangeClass = (value, index) => {
-  var _value$attribute, _value$attribute2;
-
-  const isDouble = Boolean(((_value$attribute = value.attribute) == null ? void 0 : _value$attribute.type) === 'Double');
-  const isDate = Boolean(((_value$attribute2 = value.attribute) == null ? void 0 : _value$attribute2.type) === 'DateTime');
-  const {
-    from,
-    to
-  } = getRangeValues(value, isDouble, isDate, index);
-
-  if (from === null) {
-    return to + " " + (isDate ? i18n.t("andBefore", {
-      ns: "style"
-    }) : i18n.t("andLess", {
-      ns: "style"
-    }));
-  }
-
-  if (to === null) {
-    return (isDate ? i18n.t("after", {
-      ns: "style"
-    }) : i18n.t("more", {
-      ns: "style"
-    })) + " " + from;
-  }
-
-  return from === to ? "" + from : from + " - " + to;
-};
-
-function getRangeValues(_ref, isDouble, isDate, index) {
-  let {
-    from,
-    to
-  } = _ref;
-  return {
-    from: from !== null && index !== 0 ? isDate ? from : isDouble ? +from : +from + 1 : from,
-    to
-  };
-}
-
-function evaluateCondition(condition$1, attributes) {
-  try {
-    const evaluator = new condition.ConditionEvaluator(attributes);
-    const result = evaluator.evaluate(condition$1);
-
-    if (result instanceof Error) {
-      return null;
-    }
-
-    return result;
-  } catch (_unused) {
-    return null;
-  }
-}
-
-function getAttributeValue(attributes, attributeName) {
-  const attributeMeta = attributes.find((_ref) => {
-    let {
-      name
-    } = _ref;
-    return name === attributeName;
-  });
-  return attributeMeta ? attributeMeta.value : null;
-}
-
-const getAttributeNameFromCondition = condition => new ClassificationCondition(condition).attributeName;
-const getAttributeNameFromClassified = values => values.length > 0 ? getAttributeNameFromCondition(values[0].condition) : null;
-
-function findFeatureValue(parameterValues, _ref2) {
-  let [name, value] = _ref2;
-  return value !== null ? parameterValues.find((_ref3) => {
-    let {
-      condition
-    } = _ref3;
-    return value !== undefined && evaluateCondition(condition, {
-      [name]: value
-    });
-  }) : null;
-}
-
-function extractValuesAttribute(parameterValues, attributes) {
-  const name = getAttributeNameFromClassified(parameterValues) || '';
-  const value = name && getAttributeValue(attributes, name);
-  return [name, value];
-}
-
-function evaluateFeatureSymbol(attributes) {
-  // @ts-ignore
-  function calc(result, _ref4) {
-    let [parameterName, parameterValue] = _ref4;
-    let newParameterValue;
-
-    if (isParameterByAttribute(parameterValue)) {
-      const [attributeName, attributeValue] = extractValuesAttribute(parameterValue.values, attributes);
-      const featureValue = findFeatureValue(parameterValue.values, [attributeName, attributeValue]);
-      newParameterValue = featureValue ? featureValue.value : parameterValue.defaultValue;
-    } else if (isObject(parameterValue)) {
-      // @ts-ignore
-      newParameterValue = Object.entries(parameterValue).reduce(calc, parameterValue);
-    }
-
-    return newParameterValue !== undefined ? _extends({}, result, {
-      [parameterName]: newParameterValue
-    }) : result;
-  }
-
-  return calc;
-}
-
-function findChildFeatureStyle(childStyles, attributes) {
-  return (childStyles || []).find((_ref5) => {
-    let {
-      condition
-    } = _ref5;
-    const attributeName = condition && getAttributeNameFromCondition(condition);
-    const attributeValue = attributeName && getAttributeValue(attributes, attributeName);
-
-    if (condition && attributeName && attributeValue !== undefined) {
-      return evaluateCondition(condition, {
-        [attributeName]: attributeValue
-      });
-    }
-
-    return false;
-  }) || null;
-}
-function findChildFeatureSymbol(childStyles, attributes) {
-  const featureStyle = findChildFeatureStyle(childStyles, attributes);
-  return featureStyle ? featureStyle.symbol : null;
-}
-function getFeatureSymbol(style, attributes) {
-  if (!style || !style.symbol) {
-    return null;
-  }
-
-  if (style.children !== null) {
-    return findChildFeatureSymbol(style.children, attributes) || style.symbol;
-  }
-
-  return Object.entries(style.symbol).reduce(evaluateFeatureSymbol(attributes), style.symbol);
-}
-
-function createValueTitle(value, index) {
-  if (value.title) return value.title;
-  if (isRangeClass(value)) return printRangeClass(value, index);
-  if (isUniqueClass(value)) return value.uniqueValue;
-  return '';
-}
-
-function isValidParameter(parameter) {
-  return !(parameter != null && parameter.includes("labelSymbol")) && !(parameter != null && parameter.includes("singleObjectSymbol"));
-}
-
-(function (FilterConditionOperation) {
-  FilterConditionOperation["AND"] = "&&";
-  FilterConditionOperation["OR"] = "||";
-})(exports.FilterConditionOperation || (exports.FilterConditionOperation = {}));
-
-(function (ComparisonOperator) {
-  /** `==` */
-  ComparisonOperator["Equals"] = "Equals";
-  /** `!=` */
-
-  ComparisonOperator["NotEquals"] = "NotEquals";
-  /** `>` */
-
-  ComparisonOperator["GreaterThan"] = "GreaterThan";
-  /** `<` */
-
-  ComparisonOperator["LessThan"] = "LessThan";
-  /** `>=` */
-
-  ComparisonOperator["GreaterOrEquals"] = "GreaterOrEquals";
-  /** `<=` */
-
-  ComparisonOperator["LessOrEquals"] = "LessOrEquals";
-  ComparisonOperator["Filled"] = "Filled";
-  ComparisonOperator["Empty"] = "Empty";
-  /** `==` */
-
-  ComparisonOperator["Contains"] = "Contains";
-  /** `!=` */
-
-  ComparisonOperator["NotContains"] = "NotContains";
-  ComparisonOperator["StartsWith"] = "StartsWith";
-  ComparisonOperator["NotStartsWith"] = "NotStartsWith";
-  ComparisonOperator["EndsWith"] = "EndsWith";
-  ComparisonOperator["NotEndsWith"] = "NotEndsWith";
-  ComparisonOperator["Between"] = "Between";
-  ComparisonOperator["Outside"] = "Outside";
-})(exports.ComparisonOperator || (exports.ComparisonOperator = {}));
-
-const DEFAULT_LEGEND_SYMBOL_SIZE = 26;
-const EXTRA_BORDER_SIZE = 4;
-const DEFAULT_SYMBOL_SIZE = 20;
-const DEFAULT_SYMBOL_WITH_BG_SIZE = 24;
-const DEFAULT_SYMBOL_FILL_COLOR = 'rgba(0, 163, 245, 1)';
-const DEFAULT_SYMBOL_STROKE_COLOR = 'rgb(255, 255, 255)';
-const DEFAULT_SYMBOL_OFFSET = [0, 0];
-const DEFAULT_CLUSTER_SVG = "\n<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 56 56\" width=\"56px\" height=\"56px\">\n  <circle cx=\"28\" cy=\"28\" r=\"22\" fill=\"#00AAFF\" stroke=\"#00AAFF\" stroke-opacity=\"0.28\" stroke-width=\"12\" id=\"symbol-bg\" />\n</svg>\n";
-const SYMBOL_CLASSIFICATION = {
-  [api.GeometryType.Polygon]: ['fill.color', 'stroke.color', 'stroke.width'],
-  [api.GeometryType.Polyline]: ['stroke.color', 'stroke.width'],
-  [api.GeometryType.Point]: ['angle', 'size', 'fill.color', 'fillColor', 'background.fillColor', 'background.strokeColor', 'background.strokeWidth', 'figure.fillColor', 'figure.strokeColor', 'figure.strokeWidth', 'singleObjectSymbol.size', 'singleObjectSymbol.figure.fillColor', 'singleObjectSymbol.figure.strokeColor', 'singleObjectSymbol.figure.strokeWidth', 'singleObjectSymbol.background.fillColor', 'singleObjectSymbol.background.strokeColor', 'singleObjectSymbol.background.strokeWidth']
-};
-const SYMBOL_LIMITS = {
-  SIZE_MIN: 1,
-  SIZE_MAX: 64,
-  SIZE_STEP: 1,
-  GRID_SIZE_MIN: 0.1,
-  GRID_SIZE_MAX: 120,
-  MIN_OBJECTS_COUNT: 2,
-  MAX_OBJECTS_COUNT: 10000,
-  MIN_CLUSTER_SIZE: 16,
-  MAX_CLUSTER_SIZE: 120,
-  STROKE_WIDTH_MIN: 0,
-  STROKE_WIDTH_MAX: 32,
-  STROKE_WIDTH_STEP: 0.25,
-  ANGLE_MIN: -360,
-  ANGLE_MAX: 360,
-  ANGLE_STEP: 1,
-  PREVIEW_SIZE_MAX: 32,
-  PREVIEW_SIZE_MAX_WIDTH: 26
-};
-const DEFAULT_PARAMETER_INFO = {
-  classifyAble: true,
-  min: SYMBOL_LIMITS.STROKE_WIDTH_MIN,
-  max: SYMBOL_LIMITS.STROKE_WIDTH_MAX,
-  step: SYMBOL_LIMITS.STROKE_WIDTH_STEP,
-  units: "px"
-  /* Pixels */
-  ,
-  serialize: value => value,
-  deserialize: value => value
-};
-const PARAMETER_INFOS = {
-  size: /*#__PURE__*/_extends({}, DEFAULT_PARAMETER_INFO, {
-    min: SYMBOL_LIMITS.SIZE_MIN,
-    max: SYMBOL_LIMITS.SIZE_MAX,
-    step: SYMBOL_LIMITS.SIZE_STEP,
-    units: "px"
-    /* Pixels */
-
-  })
-};
-const OPERATOR_CONDITION_REMAP = {
-  [exports.ComparisonOperator.Equals]: '==',
-  [exports.ComparisonOperator.NotEquals]: '!=',
-  [exports.ComparisonOperator.GreaterThan]: '>',
-  [exports.ComparisonOperator.GreaterOrEquals]: '>=',
-  [exports.ComparisonOperator.LessThan]: '<',
-  [exports.ComparisonOperator.LessOrEquals]: '<=',
-  [exports.ComparisonOperator.Filled]: '!=',
-  [exports.ComparisonOperator.Empty]: '==',
-  [exports.ComparisonOperator.Contains]: '==',
-  [exports.ComparisonOperator.NotContains]: '!=',
-  [exports.ComparisonOperator.StartsWith]: '==',
-  [exports.ComparisonOperator.NotStartsWith]: '!=',
-  [exports.ComparisonOperator.EndsWith]: '==',
-  [exports.ComparisonOperator.NotEndsWith]: '!=',
-  [exports.ComparisonOperator.Between]: 'between',
-  [exports.ComparisonOperator.Outside]: '!between'
-};
-const BASE_OPERATORS = [exports.ComparisonOperator.Equals, exports.ComparisonOperator.NotEquals];
-const CONTAINS_OPERATORS = [exports.ComparisonOperator.Contains, exports.ComparisonOperator.NotContains];
-const FILLED_OPERATORS = [exports.ComparisonOperator.Filled, exports.ComparisonOperator.Empty];
-const STARTS_WITH_OPERATORS = [exports.ComparisonOperator.StartsWith, exports.ComparisonOperator.NotStartsWith];
-const ENDS_WITH_OPERATORS = [exports.ComparisonOperator.EndsWith, exports.ComparisonOperator.NotEndsWith];
-const RANGE_OPERATORS = [exports.ComparisonOperator.LessThan, exports.ComparisonOperator.LessOrEquals, exports.ComparisonOperator.GreaterThan, exports.ComparisonOperator.GreaterOrEquals];
-const BETWEEN_OPERATORS = [exports.ComparisonOperator.Between, exports.ComparisonOperator.Outside];
-const numberComparisonOperators = [...BASE_OPERATORS, ...RANGE_OPERATORS, ...FILLED_OPERATORS, ...BETWEEN_OPERATORS];
-const dateComparisonOperators = [...BASE_OPERATORS, ...RANGE_OPERATORS, ...FILLED_OPERATORS, ...BETWEEN_OPERATORS];
-const textComparisonOperators = [...BASE_OPERATORS, ...CONTAINS_OPERATORS, ...STARTS_WITH_OPERATORS, ...ENDS_WITH_OPERATORS, ...FILLED_OPERATORS];
-
-(function (SvgSymbolBg) {
-  SvgSymbolBg["Rect"] = "rect";
-  SvgSymbolBg["Circle"] = "circle";
-})(exports.SvgSymbolBg || (exports.SvgSymbolBg = {}));
-
-const DEFAULT_STROKE_OPACITY = 0.28;
-const convertSvgToBase64 = svg => "data:image/svg+xml;base64," + window.btoa(svg);
-const createSvgGradient = (svg, values) => svg.gradient('linear', add => {
-  values == null ? void 0 : values.forEach((_ref, index) => {
-    let {
-      value
-    } = _ref;
-    add.stop(index / ((values == null ? void 0 : values.length) - 1), value);
-  });
-}).from(0, 0).to(1, 1); // eslint-disable-next-line max-lines-per-function
-
-const manipulateSvgSymbol = (_ref2) => {
-  var _$exec2;
-
-  let {
-    SVGContainer,
-    symbol,
-    svg,
-    bg,
-    isClassified
-  } = _ref2;
-  if (!symbol) return SVGContainer;
-  const symbolData = getParameterValue(svg || symbol.data);
-  if (!symbolData) return SVGContainer;
-  SVGContainer.clear();
-  const {
-    size,
-    angle,
-    background,
-    figure
-  } = symbol;
-  const isUploadedFile = !bg && !symbolData.includes('symbol-bg') && !symbolData.includes('symbol-figure');
-  const innerSvg = symbolData.replace(/<\?xml[^?]*\?>|<svg[^>]*>|<\/svg>/g, '');
-
-  if (isUploadedFile) {
-    var _$exec;
-
-    SVGContainer.svg(innerSvg);
-    const uploadedViewBox = (_$exec = /viewBox="([^"]+)"/g.exec(symbolData)) == null ? void 0 : _$exec[1];
-
-    if (uploadedViewBox != null && uploadedViewBox[1]) {
-      SVGContainer.viewbox(uploadedViewBox);
-    }
-
-    SVGContainer.size(size);
-  } else {
-    const hasBg = bg || (innerSvg == null ? void 0 : innerSvg.includes('symbol-bg'));
-    let defaultSize = hasBg ? DEFAULT_SYMBOL_WITH_BG_SIZE : DEFAULT_SYMBOL_SIZE;
-    const currentSize = size || defaultSize;
-    let viewBox = [0, 0, defaultSize, defaultSize];
-    const strokeWidth = getParameterValue(background == null ? void 0 : background.strokeWidth) || (typeof (background == null ? void 0 : background.strokeColor) === 'object' ? 1 : 0);
-
-    if (strokeWidth) {
-      defaultSize += strokeWidth;
-      viewBox = [-strokeWidth / 2, -strokeWidth / 2, defaultSize, defaultSize];
-    }
-
-    if (hasBg) {
-      SVGContainer.size(currentSize + "px", currentSize + "px").viewbox(viewBox.join(' '));
-      const currentBg = bg || (background == null ? void 0 : background.type);
-
-      if (currentBg) {
-        const strokeColor = getParameterValue(background == null ? void 0 : background.strokeColor);
-        const fillColor = getParameterValue(background == null ? void 0 : background.fillColor);
-        SVGContainer.svg(currentBg === exports.SvgSymbolBg.Circle ? "<circle\n                id=\"symbol-bg\"\n                cx=\"" + DEFAULT_SYMBOL_WITH_BG_SIZE / 2 + "\"\n                cy=\"" + DEFAULT_SYMBOL_WITH_BG_SIZE / 2 + "\"\n                r=\"" + DEFAULT_SYMBOL_WITH_BG_SIZE / 2 + "\"\n                fill=\"" + (fillColor || DEFAULT_SYMBOL_FILL_COLOR) + "\"\n                stroke=\"" + (strokeColor || DEFAULT_SYMBOL_STROKE_COLOR) + "\"\n                stroke-width=\"" + strokeWidth + "\"\n              />" : "<rect\n                id=\"symbol-bg\"\n                width=\"" + DEFAULT_SYMBOL_WITH_BG_SIZE + "\"\n                height=\"" + DEFAULT_SYMBOL_WITH_BG_SIZE + "\"\n                rx=\"4\"\n                fill=\"" + (fillColor || DEFAULT_SYMBOL_FILL_COLOR) + "\"\n                stroke=\"" + (strokeColor || DEFAULT_SYMBOL_STROKE_COLOR) + "\"\n                stroke-width=\"" + strokeWidth + "\"\n              />");
-        SVGContainer.svg(innerSvg);
-        SVGContainer.find('#symbol-bg:not(:first-child)').each(item => item.remove());
-        SVGContainer.find(':not(#symbol-bg)').each(item => item.center(DEFAULT_SYMBOL_WITH_BG_SIZE / 2, DEFAULT_SYMBOL_WITH_BG_SIZE / 2).fill('white'));
-        const symbolBg = SVGContainer.find('#symbol-bg')[0];
-
-        if (isClassified) {
-          symbolBg == null ? void 0 : symbolBg.stroke({
-            opacity: DEFAULT_STROKE_OPACITY
-          });
-        } // eslint-disable-next-line max-depth
-
-
-        if (isParameterByAttribute(background == null ? void 0 : background.fillColor)) {
-          var _background$fillColor;
-
-          symbolBg == null ? void 0 : symbolBg.fill(createSvgGradient(SVGContainer, background == null ? void 0 : (_background$fillColor = background.fillColor) == null ? void 0 : _background$fillColor.values));
-        }
-
-        if (isParameterByAttribute(background == null ? void 0 : background.strokeColor)) {
-          var _background$strokeCol;
-
-          symbolBg == null ? void 0 : symbolBg.stroke({
-            color: createSvgGradient(SVGContainer, background == null ? void 0 : (_background$strokeCol = background.strokeColor) == null ? void 0 : _background$strokeCol.values)
-          });
-        }
-      } else {
-        SVGContainer.svg(innerSvg);
-      }
-    } else {
-      const strokeColor = getParameterValue(figure == null ? void 0 : figure.strokeColor);
-      const strokeWidth = getParameterValue(figure == null ? void 0 : figure.strokeWidth) || (typeof (figure == null ? void 0 : figure.strokeColor) === 'object' ? 1 : 0);
-      const fillColor = getParameterValue(figure == null ? void 0 : figure.fillColor);
-      SVGContainer.size(currentSize + "px", currentSize + "px").viewbox(viewBox.join(' '));
-      SVGContainer.svg(innerSvg);
-      SVGContainer.find('#symbol-figure').each(item => {
-        item.center(DEFAULT_SYMBOL_SIZE / 2, DEFAULT_SYMBOL_SIZE / 2).fill(fillColor || DEFAULT_SYMBOL_FILL_COLOR).stroke({
-          color: strokeColor,
-          width: strokeWidth
-        });
-
-        if (isParameterByAttribute(figure == null ? void 0 : figure.fillColor)) {
-          var _figure$fillColor;
-
-          item == null ? void 0 : item.fill(createSvgGradient(SVGContainer, figure == null ? void 0 : (_figure$fillColor = figure.fillColor) == null ? void 0 : _figure$fillColor.values));
-        }
-
-        if (isParameterByAttribute(figure == null ? void 0 : figure.strokeColor)) {
-          var _figure$strokeColor;
-
-          item == null ? void 0 : item.stroke({
-            color: createSvgGradient(SVGContainer, figure == null ? void 0 : (_figure$strokeColor = figure.strokeColor) == null ? void 0 : _figure$strokeColor.values)
-          });
-        }
-      });
-    }
-  }
-
-  const rootTransform = (_$exec2 = /<svg[^>]*transform="([^"]+)"/g.exec(symbolData)) == null ? void 0 : _$exec2[1];
-
-  if (rootTransform) {
-    const transformParts = rootTransform.slice(0, -1).split('(');
-    SVGContainer.transform({
-      [transformParts[0]]: transformParts[1].split(',')
-    });
-  }
-
-  const rotatedAngle = SVGContainer.transform('rotate');
-
-  if (rotatedAngle) {
-    SVGContainer.rotate(-rotatedAngle, 0, 0);
-  }
-
-  if (angle !== undefined) {
-    SVGContainer.rotate(angle * (180 / Math.PI), 0, 0);
-  }
-
-  return SVGContainer;
-};
-
-const isNumeric = number => !isNaN(parseFloat(number)) && isFinite(number);
-
-const comparisonOperatorMapReversed = {
-  [condition.TokenType.ArEq]: exports.ComparisonOperator.Equals,
-  [condition.TokenType.ArNotEq]: exports.ComparisonOperator.NotEquals,
-  [condition.TokenType.ArGr]: exports.ComparisonOperator.GreaterThan,
-  [condition.TokenType.ArLs]: exports.ComparisonOperator.LessThan,
-  [condition.TokenType.ArGre]: exports.ComparisonOperator.GreaterOrEquals,
-  [condition.TokenType.ArLse]: exports.ComparisonOperator.LessOrEquals,
-  [condition.TokenType.Between]: exports.ComparisonOperator.Between,
-  [condition.TokenType.Outside]: exports.ComparisonOperator.Outside
-};
-const NUMERIC_ATTRIBUTE_TYPES = [api.AttributeType.Int32, api.AttributeType.Int64, api.AttributeType.DateTime, api.AttributeType.Double];
-
-const formatValue = (value, isDate) => {
-  return isDate ? "#'" + formatDate(value, {
-    dateFormat: exports.DateFormat.UTC,
-    defaultValue: value
-  }) + "'" : value ? value.toString() : 0;
-};
-
-function formatCondition(condition$1) {
-  const {
-    comparisonOperator,
-    value,
-    type,
-    attribute
-  } = condition$1;
-  const operator = OPERATOR_CONDITION_REMAP[comparisonOperator] || comparisonOperator;
-  const preparedValue = typeof value === "string" && value.includes(" - ") ? value.split(" - ") : value;
-  const isDate = type === api.AttributeType.DateTime;
-  const isBetweenOutside = BETWEEN_OPERATORS.includes(comparisonOperator);
-  const escapeValue = !NUMERIC_ATTRIBUTE_TYPES.includes(type) && preparedValue !== null;
-
-  if (isBetweenOutside && Array.isArray(preparedValue) && preparedValue[0] !== undefined) {
-    return OPERATOR_CONDITION_REMAP[comparisonOperator] + "(" + attribute + ", " + formatValue(preparedValue[0], isDate) + ", " + formatValue(preparedValue[1], isDate) + ")";
-  }
-
-  const formattedValue = Array.isArray(preparedValue) ? preparedValue.map(val => formatValue(val, isDate)) : formatValue(preparedValue, isDate);
-  const nulledValue = lodash.isNil(preparedValue) ? "{null}" : formattedValue;
-  const valueEscaped = escapeValue && typeof nulledValue === "string" ? "'" + condition.Char.escapeSpecChars(addOperationToValue(nulledValue, comparisonOperator)) + "'" : nulledValue;
-  return attribute + " " + operator + " " + valueEscaped;
-}
-function createConditionString(condition) {
-  if (Array.isArray(condition)) {
-    return "( " + formatCondition(condition[0]) + " " + condition[0].operation + " " + formatCondition(condition[1]) + " )";
-  }
-
-  return formatCondition(condition);
-}
-function createCondition(_ref) {
-  let {
-    attribute,
-    operation,
-    value
-  } = _ref;
-  const comparisonOperator = comparisonOperatorMapReversed[operation];
-  const convertedResult = convertOperatorValue(value, comparisonOperator);
-  return _extends({
-    attribute
-  }, convertedResult);
-}
-
-function convertOperatorValue(value, comparisonOperator) {
-  if (typeof value === "string") {
-    const operatorIndex = +(comparisonOperator === exports.ComparisonOperator.NotEquals);
-
-    if (value.startsWith(condition.Char.PERCENTAGE) && value.endsWith(condition.Char.PERCENTAGE)) {
-      return {
-        value: value.slice(1, -1),
-        comparisonOperator: CONTAINS_OPERATORS[operatorIndex]
-      };
-    }
-
-    if (value.startsWith(condition.Char.PERCENTAGE)) {
-      return {
-        value: value.slice(1),
-        comparisonOperator: ENDS_WITH_OPERATORS[operatorIndex]
-      };
-    }
-
-    if (value.endsWith(condition.Char.PERCENTAGE)) {
-      return {
-        value: value.slice(0, -1),
-        comparisonOperator: STARTS_WITH_OPERATORS[operatorIndex]
-      };
-    }
-  }
-
-  return {
-    value,
-    comparisonOperator
-  };
-}
-
-const addContains = value => "%" + value + "%";
-
-const addStartsWith = value => value + "%";
-
-const addEndsWith = value => "%" + value;
-
-function addOperationToValue(value, operator) {
-  switch (operator) {
-    case exports.ComparisonOperator.Contains:
-    case exports.ComparisonOperator.NotContains:
-      return addContains(value);
-
-    case exports.ComparisonOperator.StartsWith:
-    case exports.ComparisonOperator.NotStartsWith:
-      return addStartsWith(value);
-
-    case exports.ComparisonOperator.EndsWith:
-    case exports.ComparisonOperator.NotEndsWith:
-      return addEndsWith(value);
-
-    case exports.ComparisonOperator.Between:
-      return condition.Char.BETWEEN;
-
-    case exports.ComparisonOperator.Outside:
-      return condition.Char.OUTSIDE;
-
-    default:
-      return value;
-  }
-}
-
-let FilterCondition = /*#__PURE__*/function () {
-  function FilterCondition(condition$1) {
-    if (condition$1 === void 0) {
-      condition$1 = null;
-    }
-
-    _classCallCheck(this, FilterCondition);
-
-    this.condition = condition$1;
-    this.conditionInterpreter = new condition.ConditionInterpreter(condition$1);
-  }
-
-  _createClass(FilterCondition, [{
-    key: "conditions",
-    get: function get() {
-      const {
-        value
-      } = this.conditionInterpreter;
-
-      if (value instanceof Error) {
-        // TODO handle errors in client notifications
-        console.warn(value.message);
-      }
-
-      return value instanceof Error ? [] : value.expressions.map(createCondition);
-    }
-  }, {
-    key: "conditionOperation",
-    get: function get() {
-      const {
-        value
-      } = this.conditionInterpreter;
-
-      if (value instanceof Error) {
-        return null;
-      }
-
-      const isOrCondition = value.boolOperations.includes(condition.TokenType.BoolOr);
-      const isAndCondition = value.boolOperations.includes(condition.TokenType.BoolAnd);
-
-      if (isOrCondition && isAndCondition) {
-        return null;
-      }
-
-      return isOrCondition ? exports.FilterConditionOperation.OR : isAndCondition ? exports.FilterConditionOperation.AND : null;
-    }
-  }, {
-    key: "isParsingError",
-    value: function isParsingError() {
-      return this.conditionInterpreter.value instanceof Error;
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return this.condition;
-    }
-  }], [{
-    key: "from",
-    value: function from(conditions, operation) {
-      const condition = (conditions == null ? void 0 : conditions.map(createConditionString).join(" " + operation + " ")) || null;
-      return new FilterCondition(condition);
-    }
-  }]);
-
-  return FilterCondition;
-}();
-
-const isLayerService = value => isObject(value) && 'name' in value;
-const getAttributeFromCondition = condition => {
-  const parts = condition.split(' ');
-  return parts[0].startsWith('(') ? parts[0].slice(1) : parts[0];
-};
-const getExprFromCondition = (condition, partIndex) => {
-  var _expr;
-
-  let expr;
-
-  if (partIndex) {
-    const parts = condition.split(' && ').map(part => part.slice(1, -1));
-    expr = parts[partIndex - 1];
-  } else {
-    expr = condition;
-  }
-
-  return (_expr = expr) == null ? void 0 : _expr.split(' ');
-};
-const getSignFromConditionPart = (condition, partIndex) => {
-  var _getExprFromCondition;
-
-  return (_getExprFromCondition = getExprFromCondition(condition, partIndex)) == null ? void 0 : _getExprFromCondition[1];
-};
-const getValueFromConditionPart = (condition, partIndex) => {
-  var _getExprFromCondition2;
-
-  return (_getExprFromCondition2 = getExprFromCondition(condition, partIndex)) == null ? void 0 : _getExprFromCondition2[2];
-};
-const isRangeCondition = condition => (condition == null ? void 0 : condition.includes('(')) || false;
-const getSymbolParameterInfo = parameter => {
-  return PARAMETER_INFOS[parameter] || DEFAULT_PARAMETER_INFO;
-};
-const formatUniqueClassValue = (value, formatValue) => {
-  const {
-    attribute,
-    uniqueValue
-  } = value;
-  return attribute && formatValue ? formatValue(attribute.type, uniqueValue, attribute.stringFormat) : uniqueValue;
-};
-const getRangeValues$1 = (_ref, isDouble, isDate, index) => {
-  let {
-    from,
-    to
-  } = _ref;
-  return {
-    from: from !== null && index !== 0 ? isDate ? from : isDouble ? +from : +from + 1 : from,
-    to
-  };
-};
-const formatRangeClassValue = (value, formatValue, index) => {
-  var _value$attribute, _value$attribute2, _value$attribute3, _value$attribute4, _value$attribute5, _value$attribute6;
-
-  const isDouble = ((_value$attribute = value.attribute) == null ? void 0 : _value$attribute.type) === 'Double';
-  const isDate = ((_value$attribute2 = value.attribute) == null ? void 0 : _value$attribute2.type) === 'DateTime';
-  const {
-    from,
-    to
-  } = getRangeValues$1(value, isDouble, isDate, index);
-  const formattedFrom = formatValue ? formatValue((_value$attribute3 = value.attribute) == null ? void 0 : _value$attribute3.type, from, (_value$attribute4 = value.attribute) == null ? void 0 : _value$attribute4.stringFormat) : from;
-  const formattedTo = formatValue ? formatValue((_value$attribute5 = value.attribute) == null ? void 0 : _value$attribute5.type, to, (_value$attribute6 = value.attribute) == null ? void 0 : _value$attribute6.stringFormat) : to;
-
-  if (from === null) {
-    return "" + formattedTo + (!isDate ? " " + i18n.t("andLess", {
-      ns: "style"
-    }) : '');
-  }
-
-  if (to === null) {
-    return "" + (!isDate ? i18n.t("more", {
-      ns: "style"
-    }) + " " : '') + formattedFrom;
-  }
-
-  return from === to ? "" + formattedFrom : formattedFrom + " - " + formattedTo;
-};
-const checkLayerHasLegend = layerInfo => {
-  var _SYMBOL_CLASSIFICATIO;
-
-  return ((_SYMBOL_CLASSIFICATIO = SYMBOL_CLASSIFICATION[layerInfo.geometryType]) == null ? void 0 : _SYMBOL_CLASSIFICATIO.some(param => {
-    var _layerInfo$style;
-
-    const paramValue = get((_layerInfo$style = layerInfo.style) == null ? void 0 : _layerInfo$style.symbol, param);
-    return (paramValue == null ? void 0 : paramValue.type) === 'byAttribute';
-  })) || false;
-};
-const getTitleFromCondition = (_ref2) => {
-  let {
-    condition,
-    attribute,
-    formatValue
-  } = _ref2;
-  const parts = condition == null ? void 0 : condition.split(' == ');
-  const uniqueValue = parts != null && parts[1] ? parts[1].startsWith("'") && parts[1].endsWith("'") ? parts[1].slice(1, -1) : parts[1] : '';
-  return attribute && formatValue ? formatValue(attribute.type, uniqueValue, attribute.stringFormat) : uniqueValue;
-};
-function createValueTitleFromCondition(paramValue, attribute, formatValue, index) {
-  if (!attribute) return '';
-  if (paramValue.title) return paramValue.title;
-  const value = {
-    parameterValue: getParameterValue(paramValue.value),
-    attribute
-  };
-  const sign = getSignFromConditionPart(paramValue.condition, 1);
-  const isFirstFrom = sign.includes('>');
-  value.from = isFirstFrom ? getValueFromConditionPart(paramValue.condition, 1) : null;
-  value.to = paramValue.condition.includes(' && ') && isFirstFrom ? getValueFromConditionPart(paramValue.condition, 2) : !isFirstFrom ? getValueFromConditionPart(paramValue.condition, 1) : null;
-  if (isRangeClass(value)) return formatRangeClassValue(value, formatValue, index);
-  if (isUniqueClass(value)) return formatUniqueClassValue(value, formatValue);
-  return '';
-} // Основывается на http://cf.everpoint.ru/pages/viewpage.action?pageId=45024217 ->
-// пункт "Настраиваемые значения параметров символики в системе"
-// Для добавления подготовленных значений размеров символов нужно использовать константу PREPARED_SYMBOL_SIZES
-
-const DEFAULT_LEGEND_STYLES = {
-  [0
-  /* Point */
-  ]: {
-    fillColor: '#00000047',
-    strokeWidth: 1,
-    strokeColor: '#0000001f'
-  },
-  [1
-  /* ImagePoint */
-  ]: {
-    maskedColor: '#00000047'
-  },
-  [2
-  /* Line */
-  ]: {
-    stroke: {
-      width: 2,
-      color: '#00000047'
-    }
-  },
-  [3
-  /* Polygon */
-  ]: {
-    fill: {
-      color: '#00000000',
-      hatchColor: '#00000000'
-    },
-    stroke: {
-      width: 1,
-      color: '#0000001f'
-    }
-  }
-};
-const SYMBOL_SIZE_PARAMETERS = ['size', 'width', 'height']; // Основывается на http://cf.everpoint.ru/pages/viewpage.action?pageId=45024217 -> пункт "Библиотека символов"
-
-const DEFAULT_LEGEND_SIZES = {
-  circlePointSymbol: 8,
-  squarePointSymbol: 12,
-  imagePointSymbol: 24,
-  maskedImagePointSymbol: 24,
-  svgPointSymbol: 24
-};
-
-const getNonClassifiedParamValue = (baseSymbol, parameter, classificationsParams, type) => {
-  if (classificationsParams.includes(parameter)) {
-    const defaultParameterValue = getParameterFromSymbol(DEFAULT_LEGEND_STYLES[type], parameter);
-
-    if (defaultParameterValue) {
-      return defaultParameterValue;
-    }
-
-    if (SYMBOL_SIZE_PARAMETERS.includes(parameter) && DEFAULT_LEGEND_SIZES[baseSymbol.type]) {
-      return DEFAULT_LEGEND_SIZES[baseSymbol.type];
-    }
-  }
-
-  return getParameterValue(getParameterFromSymbol(baseSymbol, parameter));
-};
-
-const updateSymbolParameter = (symbol, path, value) => symbolParameterWalker(() => value)(symbol, path);
-
-const createPointSymbol = (baseSymbol, parameter, classificationsParams, parameterValue) => {
-  return updateSymbolParameter(_extends({}, baseSymbol, {
-    fillColor: getNonClassifiedParamValue(baseSymbol, 'fillColor', classificationsParams, 0
-    /* Point */
-    ),
-    strokeColor: getNonClassifiedParamValue(baseSymbol, 'strokeColor', classificationsParams, 0
-    /* Point */
-    ),
-    strokeWidth: getNonClassifiedParamValue(baseSymbol, 'strokeWidth', classificationsParams, 0
-    /* Point */
-    ),
-    size: getNonClassifiedParamValue(baseSymbol, 'size', classificationsParams, 0
-    /* Point */
-    ),
-    offset: [0, 0]
-  }), parameter, parameterValue);
-};
-
-function getDimensions(symbol, size) {
-  const height = getParameterValue(symbol.height);
-  const width = getParameterValue(symbol.width);
-
-  if (width === height) {
-    return {
-      width: size,
-      height: size
-    };
-  }
-
-  const ratio = height / width;
-
-  if (width < height) {
-    return {
-      width: size,
-      height: height + (size - width) * ratio
-    };
-  }
-
-  return {
-    width: width + (size - height) * ratio,
-    height: size
-  };
-}
-
-const createImagePointSymbol = (baseSymbol, parameter, classificationsParams, parameterValue) => {
-  let symbol = _extends({}, baseSymbol);
-
-  if (isMaskedImageSymbol(symbol)) {
-    symbol.maskedColor = getNonClassifiedParamValue(baseSymbol, 'maskedColor', classificationsParams, 1
-    /* ImagePoint */
-    );
-  }
-
-  if (parameter === 'height' || parameter === 'width') {
-    const {
-      height,
-      width
-    } = getDimensions(baseSymbol, parameterValue);
-    symbol.height = height;
-    symbol.width = width;
-  } else {
-    symbol.width = getNonClassifiedParamValue(baseSymbol, 'width', classificationsParams, 1
-    /* ImagePoint */
-    );
-    symbol.height = symbol.width;
-    symbol = updateSymbolParameter(symbol, parameter, parameterValue);
-  }
-
-  symbol.offset = [getParameterValue(symbol.height) / 2, getParameterValue(symbol.width) / 2];
-  return symbol;
-};
-
-const createLineSymbol = (baseSymbol, parameter, classificationsParams, parameterValue) => {
-  return updateSymbolParameter(_extends({}, baseSymbol, {
-    type: 'simplePolylineSymbol',
-    stroke: {
-      color: getNonClassifiedParamValue(baseSymbol, 'stroke.color', classificationsParams, 2
-      /* Line */
-      ),
-      width: getNonClassifiedParamValue(baseSymbol, 'stroke.width', classificationsParams, 2
-      /* Line */
-      )
-    }
-  }), parameter, parameterValue);
-};
-
-const createPolygonSymbol = (baseSymbol, parameter, classificationsParams, parameterValue) => {
-  return updateSymbolParameter(_extends({}, baseSymbol, {
-    fill: {
-      color: getNonClassifiedParamValue(baseSymbol, 'fill.color', classificationsParams, 3
-      /* Polygon */
-      ),
-      hatchColor: getNonClassifiedParamValue(baseSymbol, 'fill.hatchColor', classificationsParams, 3
-      /* Polygon */
-      )
-    },
-    stroke: {
-      color: getNonClassifiedParamValue(baseSymbol, 'stroke.color', classificationsParams, 3
-      /* Polygon */
-      ),
-      width: getNonClassifiedParamValue(baseSymbol, 'stroke.width', classificationsParams, 3
-      /* Polygon */
-      )
-    }
-  }), parameter, parameterValue);
-};
-
-const createH3Symbol = (baseSymbol, parameter, classificationsParams, parameterValue) => {
-  return updateSymbolParameter(_extends({}, baseSymbol, {
-    fill: {
-      color: getNonClassifiedParamValue(baseSymbol, 'fill.color', classificationsParams, 3
-      /* Polygon */
-      )
-    },
-    stroke: {
-      color: getNonClassifiedParamValue(baseSymbol, 'stroke.color', classificationsParams, 3
-      /* Polygon */
-      ),
-      width: getNonClassifiedParamValue(baseSymbol, 'stroke.width', classificationsParams, 3
-      /* Polygon */
-      )
-    }
-  }), parameter, parameterValue);
-};
-
-const createClusterSymbol = (baseSymbol, parameter, classificationsParams, parameterValue) => {
-  return updateSymbolParameter(_extends({}, baseSymbol, {
-    fillColor: getNonClassifiedParamValue(baseSymbol, 'fillColor', classificationsParams, 0
-    /* Point */
-    )
-  }), parameter, parameterValue);
-};
-
-const createLegendSymbol = (parameterValue, parameter, classificationsParams, baseSymbol) => {
-  if (isParameterValueSymbol(parameterValue)) {
-    return parameterValue;
-  }
-
-  if (isClusterSymbol(baseSymbol)) {
-    return createClusterSymbol(baseSymbol, parameter, classificationsParams, parameterValue);
-  }
-
-  if (isSizableSymbol(baseSymbol)) {
-    return createPointSymbol(baseSymbol, parameter, classificationsParams, parameterValue);
-  }
-
-  if (isTwoDimensionalSymbol(baseSymbol)) {
-    return createImagePointSymbol(baseSymbol, parameter, classificationsParams, parameterValue);
-  }
-
-  if (isPolylineSymbols(baseSymbol)) {
-    return createLineSymbol(baseSymbol, parameter, classificationsParams, parameterValue);
-  }
-
-  if (isPolygonSymbol(baseSymbol)) {
-    return createPolygonSymbol(baseSymbol, parameter, classificationsParams, parameterValue);
-  }
-
-  if (isH3GridSymbol(baseSymbol)) {
-    return createH3Symbol(baseSymbol, parameter, classificationsParams, parameterValue);
-  }
-
-  return null;
-};
-function createHiddenCondition(attributeName, attributeType, value) {
-  let newValue;
-  let comparisonOperator;
-
-  if (isRangeClass(value)) {
-    if (value.from && value.to) {
-      newValue = [value.from, value.to];
-      comparisonOperator = exports.ComparisonOperator.Outside;
-    } else if (value.from) {
-      newValue = value.from;
-      comparisonOperator = exports.ComparisonOperator.LessThan;
-    } else if (value.to) {
-      newValue = value.to;
-      comparisonOperator = exports.ComparisonOperator.GreaterThan;
-    }
-  } else {
-    newValue = value.uniqueValue || value.title;
-    comparisonOperator = exports.ComparisonOperator.NotEquals;
-  }
-
-  return new FilterCondition(createConditionString({
-    attribute: attributeName,
-    type: attributeType,
-    comparisonOperator: comparisonOperator,
-    value: newValue
-  })).toString();
-}
-const createOtherHiddenCondition = (values, attributeName, attributeType) => {
-  const value = values[values.length - 1];
-  let hiddenCondition;
-
-  if (isRangeClass(value)) {
-    hiddenCondition = new FilterCondition(createConditionString({
-      attribute: attributeName,
-      type: attributeType,
-      comparisonOperator: exports.ComparisonOperator.LessOrEquals,
-      value: value.to || value.from
-    })).toString();
-  } else {
-    const conditions = values.map(val => new FilterCondition(createConditionString({
-      attribute: attributeName,
-      type: attributeType,
-      comparisonOperator: exports.ComparisonOperator.Equals,
-      value: val.uniqueValue
-    })).toString());
-    hiddenCondition = "( " + conditions.filter(Boolean).join(" " + exports.FilterConditionOperation.OR + " ") + " )";
-  }
-
-  return hiddenCondition;
-};
-const getMinimizedLegendValues = (attribute, classified, formatValue, index, otherTitle) => {
-  const other = {
-    title: otherTitle,
-    parameterValue: classified.defaultValue,
-    hiddenCondition: createOtherHiddenCondition(classified.values.map(val => getClassificationValue(val.value, otherTitle, new ClassificationCondition(val.condition))), attribute.name, attribute.type)
-  };
-  const items = classified.values.map(paramValue => {
-    const parameterValue = getParameterValue(paramValue.value);
-    const result = {
-      parameterValue,
-      attribute
-    };
-
-    if (isRangeCondition(paramValue.condition)) {
-      const from = getValueFromConditionPart(paramValue.condition, 1);
-      const to = getValueFromConditionPart(paramValue.condition, 2);
-      result.from = from ? isNumeric(from) ? +from : formatDate(from) : null;
-      result.to = to ? isNumeric(to) ? +to : formatDate(to) : null;
-      result.title = createValueTitleFromCondition(paramValue, attribute, formatValue, index);
-      return result;
-    }
-
-    result.uniqueValue = formatValue ? formatValue(attribute.type, paramValue.value, attribute.stringFormat) : paramValue.value.toString();
-    result.title = getTitleFromCondition({
-      condition: paramValue.condition
-    });
-    result.hiddenCondition = createHiddenCondition(attribute.name, attribute.type, getClassificationValue(paramValue.value, result.title, new ClassificationCondition(paramValue.condition)));
-    return result;
-  });
-  return [...items, other];
-};
-const getMaximizedLegendValues = (attribute, param, params, classified, symbol, formatValue, sectionIndex, otherTitle) => {
-  const other = {
-    title: otherTitle,
-    symbol: createLegendSymbol(classified.defaultValue, param, params, symbol),
-    hiddenCondition: createOtherHiddenCondition(classified.values.map(val => getClassificationValue(val.value, otherTitle, new ClassificationCondition(val.condition))), attribute.name, attribute.type)
-  };
-  const items = classified.values.map((paramValue, index) => {
-    const result = {
-      symbol: createLegendSymbol(paramValue.value, param, params, symbol)
-    };
-    result.title = isRangeCondition(paramValue.condition) ? createValueTitleFromCondition(paramValue, attribute, formatValue, sectionIndex) : getTitleFromCondition({
-      condition: paramValue.condition
-    });
-    result.hiddenCondition = createHiddenCondition(attribute.name, attribute.type, getClassificationValue(paramValue.value, result.title, new ClassificationCondition(classified.values[index].condition)));
-    return result;
-  });
-  return [...items, other];
-};
-const classifyParamsReduce = (symbol, classifyParams, index) => {
-  return classifyParams == null ? void 0 : classifyParams.reduce((result, classified) => {
-    const param = get(symbol, classified);
-    return (param == null ? void 0 : param.type) === 'byAttribute' ? _extends({}, result, {
-      [classified]: _extends({
-        index
-      }, param)
-    }) : result;
-  }, {});
-};
-const getClassified = layerInfo => {
-  var _layerInfo$style2, _layerInfo$style2$chi, _layerInfo$style4, _layerInfo$style5;
-
-  if (!layerInfo) return undefined;
-
-  if ((_layerInfo$style2 = layerInfo.style) != null && (_layerInfo$style2$chi = _layerInfo$style2.children) != null && _layerInfo$style2$chi.length) {
-    var _layerInfo$style3;
-
-    return {
-      symbol: {
-        type: 'byAttribute',
-        defaultValue: layerInfo.style.symbol,
-        title: null,
-        values: (_layerInfo$style3 = layerInfo.style) == null ? void 0 : _layerInfo$style3.children
-      }
-    };
-  }
-
-  const classifyParams = SYMBOL_CLASSIFICATION[layerInfo.geometryType];
-
-  if ((_layerInfo$style4 = layerInfo.style) != null && _layerInfo$style4.symbol && isCombinedPolylineSymbol(layerInfo.style.symbol)) {
-    var _layerInfo$style$symb;
-
-    if (!((_layerInfo$style$symb = layerInfo.style.symbol.values) != null && _layerInfo$style$symb.length)) return undefined;
-    return layerInfo.style.symbol.values.reduce((result, polyline, index) => {
-      return _extends({}, result, classifyParamsReduce(polyline, classifyParams, index));
-    }, {});
-  }
-
-  return classifyParamsReduce((_layerInfo$style5 = layerInfo.style) == null ? void 0 : _layerInfo$style5.symbol, classifyParams);
-};
-const getSymbolStrokeWidth = symbol => {
-  var _symbol$background;
-
-  return isSvgPointSymbol(symbol) ? (_symbol$background = symbol.background) == null ? void 0 : _symbol$background.strokeWidth : symbol.strokeWidth;
-};
-const getParameterFromSymbol = (symbol, parameter) => {
-  let parameterFromSymbol = {};
-  symbolParameterWalker(parameterValue => {
-    parameterFromSymbol = parameterValue;
-  })(symbol, parameter);
-  return parameterFromSymbol;
-};
-const getLegendSymbolSize = symbol => {
-  let size = 0;
-
-  if (isSvgPointSymbol(symbol)) {
-    size = getParameterValue(symbol.size);
-  }
-
-  if (isH3GridSymbol(symbol)) {
-    size = getParameterValue(symbol.cellSize);
-  }
-
-  if (isTwoDimensionalSymbol(symbol)) {
-    size = Math.max(getParameterValue(symbol.width), getParameterValue(symbol.height));
-  }
-
-  if (isSizableSymbol(symbol)) {
-    const strokeWidth = getSymbolStrokeWidth(symbol);
-    size = getParameterValue(symbol.size) + (strokeWidth ? getParameterValue(strokeWidth) + EXTRA_BORDER_SIZE : 0);
-  }
-
-  if (isPolylineSymbols(symbol)) {
-    size = getParameterValue(getParameterFromSymbol(symbol, 'stroke.width'));
-  }
-
-  return Math.max(DEFAULT_LEGEND_SYMBOL_SIZE, size);
-};
-const serializeSvgPointSymbol = symbol => {
-  var _symbol$figure, _symbol$background2, _symbol$background3, _symbol$background4, _symbol$background5, _symbol$figure2, _symbol$figure3;
-
-  if (!symbol) return null;
-  const figureFillColor = ((_symbol$figure = symbol.figure) == null ? void 0 : _symbol$figure.fillColor) || null;
-  const bgFillColor = ((_symbol$background2 = symbol.background) == null ? void 0 : _symbol$background2.fillColor) || null;
-  return _extends({
-    type: 'svgPointSymbol',
-    size: symbol.size,
-    offset: symbol.offset,
-    angle: symbol.angle
-  }, bgFillColor ? {
-    background: {
-      id: 'symbol-bg',
-      fillColor: bgFillColor,
-      strokeColor: ((_symbol$background3 = symbol.background) == null ? void 0 : _symbol$background3.strokeColor) || null,
-      strokeWidth: ((_symbol$background4 = symbol.background) == null ? void 0 : _symbol$background4.strokeWidth) || null,
-      type: ((_symbol$background5 = symbol.background) == null ? void 0 : _symbol$background5.type) || exports.SvgSymbolBg.Circle
-    }
-  } : {}, figureFillColor ? {
-    figure: {
-      id: 'symbol-figure',
-      fillColor: figureFillColor,
-      strokeColor: ((_symbol$figure2 = symbol.figure) == null ? void 0 : _symbol$figure2.strokeColor) || null,
-      strokeWidth: ((_symbol$figure3 = symbol.figure) == null ? void 0 : _symbol$figure3.strokeWidth) || null
-    }
-  } : {});
-};
-const SIZE_PARAMETERS = ['size', 'height', 'strokeWidth', 'stroke.width'];
-const isSizeClassification = parameter => SIZE_PARAMETERS.includes(parameter);
-const getServiceConfiguration = layer => {
-  const emptyServiceConfiguration = {
-    name: ''
-  };
-  if (!isLayerService(layer) || !('configuration' in layer)) return emptyServiceConfiguration;
-  return _extends({}, emptyServiceConfiguration, layer.configuration || {});
-};
-/** default attribute name which use for geometry info */
-
-const GEOMETRY_ATTRIBUTE = 'geometry';
-/** default attribute name which contains unique id info */
-
-const DEFAULT_ID_ATTRIBUTE_NAME = 'gid';
-const getClassificationValue = (parameterValue, title, condition) => _extends({
-  parameterValue,
-  title
-}, condition.isUnique() ? {
-  uniqueValue: condition.uniqueValue
-} : {
-  from: condition.range[0],
-  to: condition.range[1]
-});
-
-const getHexColor = colorString => colorString ? new color.Color(colorString).toString('hex') : undefined;
-
-// TODO reduce
-const PREVIEW_LIMITS = {
-  STROKE_WIDTH_MIN: 0.25,
-  STROKE_WIDTH_MAX: 6.5
-};
-
-function clamp(num, min, max) {
-  return Math.min(Math.max(num, min), max);
-}
-
-/* eslint-disable @typescript-eslint/no-magic-numbers */
-const SOLID_INTERVALS = [];
-const solidStrokeStylePreset = {
-  style: 0
-  /* Solid */
-  ,
-  type: 'solid',
-  intervals: SOLID_INTERVALS
-};
-const strokeStylePresets = [solidStrokeStylePreset, {
-  style: 2
-  /* Dot */
-  ,
-  type: 'dashed',
-  intervals: [2, 2]
-}, {
-  style: 1
-  /* Dash */
-  ,
-  type: 'dashed',
-  intervals: [3, 3, 3, 3]
-}, {
-  style: 3
-  /* DashDot */
-  ,
-  type: 'dashed',
-  intervals: [5, 2, 1, 2]
-}, {
-  style: 4
-  /* DashDotDot */
-  ,
-  type: 'dashed',
-  intervals: [5, 2, 1, 1, 1, 2]
-}, {
-  style: 5
-  /* Custom */
-  ,
-  type: 'dashed',
-  intervals: [5, 4]
-}];
-
-const walkByNumbersGroup = (numbers, offset, walker) => {
-  if (!numbers || !numbers.length) return [];
-  const newNumbers = [];
-
-  for (let i = 0; i < numbers.length; i++) {
-    if (i % 2) {
-      newNumbers.push(...walker([numbers[i - 1], numbers[i]], offset));
-    }
-  }
-
-  return newNumbers;
-};
-
-const toIntervals = (numbers, width) => walkByNumbersGroup(numbers, clamp(getParameterValue(width), PREVIEW_LIMITS.STROKE_WIDTH_MIN, PREVIEW_LIMITS.STROKE_WIDTH_MAX), (_ref, offset) => {
-  let [length, gap] = _ref;
-  return [length * offset, gap * offset];
-});
-const toLineDash = (numbers, width) => walkByNumbersGroup(numbers, clamp(getParameterValue(width), PREVIEW_LIMITS.STROKE_WIDTH_MIN, PREVIEW_LIMITS.STROKE_WIDTH_MAX), (_ref2, offset) => {
-  let [length, gap] = _ref2;
-  return [Math.round(length / Math.max(1, Math.min(offset, 16) / 4)), Math.round(gap + 1 + Math.max(1, Math.min(offset, 16) / 2))];
-});
-const getLineDash = brush => {
-  if (!brush || brush.type === 'solid') return []; // @ts-ignore
-
-  return toLineDash(brush.intervals, brush.width);
-};
-const defineStrokeStylePreset = intervals => {
-  if (!intervals.length) return solidStrokeStylePreset;
-  return strokeStylePresets.find(preset => {
-    if (preset.intervals.length !== intervals.length) return false;
-    const uniqueStrokeWidths = preset.intervals.map((presetInterval, i) => intervals[i] / presetInterval).filter(api.unique);
-    return uniqueStrokeWidths.length === 1;
-  });
-};
-const getDashStylePreset = dashStyle => strokeStylePresets.find(preset => preset.style === dashStyle);
-
-const ALPHA_NORMALIZER = 65025;
-
-const sum = numbers => numbers.reduce((result, num) => result + num, 0);
-
-const shouldFillMatrixCell = (matrixSize, hatchAngle, x, y) => {
-  const center = Math.round(matrixSize / 2);
-
-  if ((hatchAngle === 0 || hatchAngle === Math.PI) && x === center) {
-    return true;
-  }
-
-  if (hatchAngle === Math.PI / 4 && y === x) {
-    return true;
-  }
-
-  if (hatchAngle === Math.PI / 2 && y === center) {
-    return true;
-  }
-
-  return hatchAngle === 3 * Math.PI / 4 && matrixSize - 1 - y === x;
-};
-
-const createEmptyMatrix = size => Array(size).fill(null).map(() => Array(size));
-
-const fillMatrix = (matrix, filler) => {
-  const matrixSize = matrix.length;
-
-  for (let x = 0; x < matrixSize; x++) {
-    for (let y = 0; y < matrixSize; y++) {
-      matrix[x][y] = filler(x, y, matrixSize);
-    }
-  }
-};
-
-const createFillBrushMatrix = (hatchAngle, hatchWidth, scalingFactor) => {
-  const matrixSize = Math.max(Math.round(sum([Math.max(...scalingFactor), hatchWidth])), hatchWidth);
-  const matrix = createEmptyMatrix(matrixSize);
-  fillMatrix(matrix, (x, y, size) => shouldFillMatrixCell(size, hatchAngle, x, y) ? 255 : 0);
-  return matrix;
-};
-
-const createSymbolFillBrush = fillBrush => {
-  if (fillBrush.type !== 'hatch') return undefined;
-  return createFillBrushMatrix( // @ts-ignore
-  getParameterValue(fillBrush.hatchAngle), // @ts-ignore
-  Math.round(fillBrush.hatchWidth), fillBrush.scalingFactor);
-};
-
-let SGisBrushFill = /*#__PURE__*/function (_sBrushFill) {
-  _inherits(SGisBrushFill, _sBrushFill);
-
-  var _super = /*#__PURE__*/_createSuper(SGisBrushFill);
-
-  function SGisBrushFill(originalSymbol) {
-    var _originalSymbol$strok, _originalSymbol$strok2, _originalSymbol$fill, _originalSymbol$fill2;
-
-    var _this;
-
-    _classCallCheck(this, SGisBrushFill);
-
-    _this = _super.call(this, {
-      // @ts-ignore
-      strokeColor: getHexColor(getParameterValue((_originalSymbol$strok = originalSymbol.stroke) == null ? void 0 : _originalSymbol$strok.color)),
-      // @ts-ignore
-      strokeWidth: getParameterValue((_originalSymbol$strok2 = originalSymbol.stroke) == null ? void 0 : _originalSymbol$strok2.width),
-      lineDash: getLineDash(originalSymbol.stroke),
-      fillBackground: getHexColor( // @ts-ignore
-      getParameterValue((_originalSymbol$fill = originalSymbol.fill) == null ? void 0 : _originalSymbol$fill.color)),
-      fillForeground: isHatchBrush(originalSymbol.fill) ? // @ts-ignore
-      getHexColor(getParameterValue((_originalSymbol$fill2 = originalSymbol.fill) == null ? void 0 : _originalSymbol$fill2.hatchColor)) : void 0,
-      fillBrush: createSymbolFillBrush(originalSymbol.fill),
-      lineCap: 'square'
-    });
-    _this.originalSymbol = originalSymbol;
-    return _this;
-  }
-
-  _createClass(SGisBrushFill, [{
-    key: "_updateBrush",
-    value: function _updateBrush() {
-      // @ts-ignore
-      if (!this._initialized) return;
-      const canvas = document.createElement('canvas');
-      const ctx = canvas.getContext('2d');
-
-      if (!ctx) {
-        return;
-      }
-
-      const brush = this.fillBrush;
-      const brushSize = brush.length;
-      const foreground = new color.Color(this.fillForeground);
-      const background = new color.Color(this.fillBackground);
-      canvas.height = brushSize;
-      canvas.width = brushSize;
-
-      for (let i = 0; i < brushSize; i++) {
-        // eslint-disable-next-line id-length
-        for (let j = 0; j < brush[i].length; j++) {
-          const srcA = brush[i][j] * foreground.a / ALPHA_NORMALIZER;
-          const dstA = background.a / 255 * (1 - srcA);
-          const alpha = +Math.min(1, srcA + dstA).toFixed(2);
-          const red = Math.round(Math.min(255, background.r * dstA + foreground.r * srcA));
-          const green = Math.round(Math.min(255, background.g * dstA + foreground.g * srcA));
-          const blue = Math.round(Math.min(255, background.b * dstA + foreground.b * srcA));
-          ctx.fillStyle = "rgba(" + red + "," + green + "," + blue + "," + alpha + ")";
-          ctx.fillRect(j, i, 1, 1);
-        }
-      }
-
-      this._brush = new Image();
-      this._brush.src = canvas.toDataURL();
-    }
-  }, {
-    key: "clone",
-    value: function clone() {
-      return new SGisBrushFill(this.originalSymbol);
-    }
-  }]);
-
-  return SGisBrushFill;
-}(BrushFill.BrushFill);
-
-let SGisImageFill = /*#__PURE__*/function (_sImageFill) {
-  _inherits(SGisImageFill, _sImageFill);
-
-  var _super = /*#__PURE__*/_createSuper(SGisImageFill);
-
-  function SGisImageFill(originalSymbol) {
-    var _originalSymbol$strok, _originalSymbol$strok2;
-
-    var _this;
-
-    _classCallCheck(this, SGisImageFill);
-
-    _this = _super.call(this, {
-      // @ts-ignore
-      strokeColor: getHexColor(getParameterValue((_originalSymbol$strok = originalSymbol.stroke) == null ? void 0 : _originalSymbol$strok.color)),
-      // @ts-ignore
-      strokeWidth: getParameterValue((_originalSymbol$strok2 = originalSymbol.stroke) == null ? void 0 : _originalSymbol$strok2.width),
-      lineDash: getLineDash(originalSymbol.stroke),
-      src: "data:image/png;base64," + originalSymbol.fill.pattern,
-      lineCap: isDashedBrush(originalSymbol.stroke) ? 'square' : 'round'
-    });
-    _this.originalSymbol = originalSymbol;
-    return _this;
-  }
-
-  _createClass(SGisImageFill, [{
-    key: "clone",
-    value: function clone() {
-      return new SGisImageFill(this.originalSymbol);
-    }
-  }]);
-
-  return SGisImageFill;
-}(ImageFill.ImageFill);
-
-let SGisPolygonSymbol = /*#__PURE__*/function (_sPolygonSymbol) {
-  _inherits(SGisPolygonSymbol, _sPolygonSymbol);
-
-  var _super = /*#__PURE__*/_createSuper(SGisPolygonSymbol);
-
-  function SGisPolygonSymbol(originalSymbol) {
-    var _originalSymbol$strok, _originalSymbol$strok2, _originalSymbol$fill;
-
-    var _this;
-
-    _classCallCheck(this, SGisPolygonSymbol);
-
-    _this = _super.call(this, {
-      // @ts-ignore
-      strokeColor: getHexColor(getParameterValue((_originalSymbol$strok = originalSymbol.stroke) == null ? void 0 : _originalSymbol$strok.color)),
-      // @ts-ignore
-      strokeWidth: getParameterValue((_originalSymbol$strok2 = originalSymbol.stroke) == null ? void 0 : _originalSymbol$strok2.width),
-      lineDash: getLineDash(originalSymbol.stroke),
-      // @ts-ignore
-      fillColor: getHexColor(getParameterValue((_originalSymbol$fill = originalSymbol.fill) == null ? void 0 : _originalSymbol$fill.color)),
-      // TODO?: may be it should be defined by user
-      lineCap: isDashedBrush(originalSymbol.stroke) ? 'square' : 'round'
-    });
-    _this.originalSymbol = originalSymbol;
-    return _this;
-  }
-
-  _createClass(SGisPolygonSymbol, [{
-    key: "clone",
-    value: function clone() {
-      return new SGisPolygonSymbol(this.originalSymbol);
-    }
-  }]);
-
-  return SGisPolygonSymbol;
-}(Simple.PolygonSymbol);
-
-const adaptMiterRings = (rings, resolution, fromCrs, toCrs) => {
-  const projected = geotools.projectRings(rings, fromCrs, toCrs);
-  return math.simplifyCoordinates(projected.map(ring => // @ts-ignore
-  ring.map((_ref) => {
-    let [x, y] = _ref;
-    return [x / resolution, y / -resolution];
-  })), 1);
-};
-
-const miterSizeCalcs = {
-  ["small"
-  /* Small */
-  ]: strokeWidth => (strokeWidth + 1) * 3 + 1,
-  ["large"
-  /* Large */
-  ]: strokeWidth => (strokeWidth + 1) * 5 - 1
-};
-let LineMiterRender = /*#__PURE__*/function () {
-  function LineMiterRender(baseInfo) {
-    _classCallCheck(this, LineMiterRender);
-
-    this.getAnchor = rings => {
-      if (this.position === 'right') {
-        const lastRing = rings[rings.length - 1];
-        return lastRing && lastRing[lastRing.length - 1] || null;
-      }
-
-      const firstRing = rings[0];
-      return firstRing && firstRing[0] || null;
-    };
-
-    Object.assign(this, baseInfo);
-  }
-
-  _createClass(LineMiterRender, [{
-    key: "getRender",
-    value: function getRender(anchorRings, anchorCrs, resolution, currentCrs) {
-      const xMultiplier = this.position === 'right' ? 1 : -1;
-      const miterAnchor = this.getAnchor(anchorRings);
-      const miterRings = this.createRings(miterAnchor, xMultiplier);
-      const projectedMiterRings = adaptMiterRings(miterRings, resolution, anchorCrs, currentCrs);
-      return this.createRender(projectedMiterRings);
-    }
-  }, {
-    key: "miterSize",
-    get: function get() {
-      const calcMiterSize = miterSizeCalcs[this.size];
-      return calcMiterSize ? calcMiterSize(this.strokeWidth) : 1;
-    }
-  }]);
-
-  return LineMiterRender;
-}();
-
-let ArrowLineMiterRender = /*#__PURE__*/function (_LineMiterRender) {
-  _inherits(ArrowLineMiterRender, _LineMiterRender);
-
-  var _super = /*#__PURE__*/_createSuper(ArrowLineMiterRender);
-
-  function ArrowLineMiterRender() {
-    _classCallCheck(this, ArrowLineMiterRender);
-
-    return _super.apply(this, arguments);
-  }
-
-  _createClass(ArrowLineMiterRender, [{
-    key: "usageSize",
-    get: function get() {
-      return this.miterSize + this.strokeWidth;
-    }
-  }, {
-    key: "createRings",
-    value: function createRings(_ref, xMultiplier) {
-      let [x, y] = _ref;
-      return [[[x, y + this.miterSize / 2], [x + this.miterSize * xMultiplier, y], [x, y - this.miterSize / 2]]];
-    }
-  }, {
-    key: "createRender",
-    value: function createRender(miterRings) {
-      const isFilled = this.kind === api.LineEndingType.FilledArrow;
-      return new Poly.PolyRender(miterRings, {
-        enclosed: isFilled,
-        fillColor: isFilled ? this.color : void 0,
-        fillStyle: isFilled ? Poly.FillStyle.Color : Poly.FillStyle.None,
-        lineCap: 'square',
-        lineJoin: 'miter',
-        strokeColor: this.color,
-        strokeWidth: this.strokeWidth
-      });
-    }
-  }]);
-
-  return ArrowLineMiterRender;
-}(LineMiterRender);
-
-let CircleLineMiterRender = /*#__PURE__*/function (_LineMiterRender) {
-  _inherits(CircleLineMiterRender, _LineMiterRender);
-
-  var _super = /*#__PURE__*/_createSuper(CircleLineMiterRender);
-
-  function CircleLineMiterRender() {
-    _classCallCheck(this, CircleLineMiterRender);
-
-    return _super.apply(this, arguments);
-  }
-
-  _createClass(CircleLineMiterRender, [{
-    key: "usageSize",
-    get: function get() {
-      return this.miterSize + this.strokeWidth * 3;
-    }
-  }, {
-    key: "createRings",
-    value: function createRings(_ref, xMultiplier) {
-      let [x, y] = _ref;
-      return [[[x + (this.miterSize / 2 + this.strokeWidth) * xMultiplier, y]]];
-    }
-  }, {
-    key: "createRender",
-    value: function createRender(miterRings) {
-      const isFilled = this.kind === api.LineEndingType.FilledCircle;
-      return new Poly.PolyRender(polygonCircleFromPoint(miterRings[0][0], this.miterSize), {
-        fillColor: isFilled ? this.color : 'transparent',
-        strokeColor: this.color,
-        strokeWidth: this.strokeWidth,
-        enclosed: true
-      });
-    }
-  }]);
-
-  return CircleLineMiterRender;
-}(LineMiterRender);
-
-let SquareLineMiterRender = /*#__PURE__*/function (_LineMiterRender) {
-  _inherits(SquareLineMiterRender, _LineMiterRender);
-
-  var _super = /*#__PURE__*/_createSuper(SquareLineMiterRender);
-
-  function SquareLineMiterRender() {
-    _classCallCheck(this, SquareLineMiterRender);
-
-    return _super.apply(this, arguments);
-  }
-
-  _createClass(SquareLineMiterRender, [{
-    key: "usageSize",
-    get: function get() {
-      return this.miterSize + this.strokeWidth;
-    }
-  }, {
-    key: "createRings",
-    value: function createRings(_ref, xMultiplier) {
-      let [x, y] = _ref;
-      return [[[x, y + this.miterSize / 2], [x, y - this.miterSize / 2], [x + this.miterSize * xMultiplier, y - this.miterSize / 2], [x + this.miterSize * xMultiplier, y + this.miterSize / 2]]];
-    }
-  }, {
-    key: "createRender",
-    value: function createRender(miterRings) {
-      const isFilled = this.kind === api.LineEndingType.FilledSquare;
-      return new Poly.PolyRender(miterRings, {
-        enclosed: true,
-        fillColor: isFilled ? this.color : void 0,
-        fillStyle: isFilled ? Poly.FillStyle.Color : Poly.FillStyle.None,
-        lineCap: 'square',
-        lineJoin: 'miter',
-        strokeColor: this.color,
-        strokeWidth: this.strokeWidth
-      });
-    }
-  }]);
-
-  return SquareLineMiterRender;
-}(LineMiterRender);
-
-const getLineMiterRender = options => {
-  switch (options.kind) {
-    case api.LineEndingType.Arrow:
-    case api.LineEndingType.FilledArrow:
-      return new ArrowLineMiterRender(options);
-
-    case api.LineEndingType.Square:
-    case api.LineEndingType.FilledSquare:
-      return new SquareLineMiterRender(options);
-
-    case api.LineEndingType.Circle:
-    case api.LineEndingType.FilledCircle:
-      return new CircleLineMiterRender(options);
-
-    default:
-      return null;
-  }
-};
-
-const updateRingForRightMiter = (ring, miterSize, isLastRing) => {
-  const reversedRing = ring.slice().reverse();
-
-  for (let i = 0; i < reversedRing.length; i++) {
-    const coordinates = reversedRing[i];
-
-    if (isLastRing && i === 0) {
-      reversedRing[i] = [coordinates[0] - miterSize, coordinates[1]];
-    }
-
-    const nextCoordinates = reversedRing[i - 1];
-
-    if (nextCoordinates && nextCoordinates[0] < coordinates[0]) {
-      reversedRing[i] = [nextCoordinates[0] - Math.abs(nextCoordinates[0] - coordinates[0]), coordinates[1]];
-    }
-  }
-
-  return reversedRing.reverse();
-};
-
-const updateRingForLeftMiter = (ring, miterSize, isFirstRing) => {
-  const newRing = ring.slice();
-
-  for (let i = 0; i < newRing.length; i++) {
-    const coordinates = newRing[i];
-
-    if (i === 0 && isFirstRing) {
-      newRing[i] = [coordinates[0] + miterSize, coordinates[1]];
-    }
-
-    const prevCoordinates = newRing[i - 1];
-
-    if (prevCoordinates && prevCoordinates[0] > coordinates[0]) {
-      newRing[i] = [prevCoordinates[0] + Math.abs(coordinates[0] - prevCoordinates[0]), coordinates[1]];
-    }
-  }
-
-  return newRing;
-};
-
-const updateRingsForMiter = (rings, position, miterSize) => {
-  return rings.map((ring, ringIndex) => {
-    switch (position) {
-      case 'right':
-        return updateRingForRightMiter(ring, miterSize, ringIndex === rings.length - 1);
-
-      default:
-        return updateRingForLeftMiter(ring, miterSize, ringIndex === 0);
-    }
-  });
-};
-
-const copyRings = rings => rings.map(ring => ring.map(coordinates => coordinates.slice()));
-let SGisPolylineSymbol = /*#__PURE__*/function (_sPolylineSymbol) {
-  _inherits(SGisPolylineSymbol, _sPolylineSymbol);
-
-  var _super = /*#__PURE__*/_createSuper(SGisPolylineSymbol);
-
-  function SGisPolylineSymbol(originalSymbol) {
-    var _originalSymbol$strok, _originalSymbol$strok2;
-
-    var _this;
-
-    _classCallCheck(this, SGisPolylineSymbol);
-
-    _this = _super.call(this, {
-      // @ts-ignore
-      strokeColor: getHexColor(getParameterValue((_originalSymbol$strok = originalSymbol.stroke) == null ? void 0 : _originalSymbol$strok.color)),
-      strokeWidth: clamp( // @ts-ignore
-      getParameterValue((_originalSymbol$strok2 = originalSymbol.stroke) == null ? void 0 : _originalSymbol$strok2.width), PREVIEW_LIMITS.STROKE_WIDTH_MIN, PREVIEW_LIMITS.STROKE_WIDTH_MAX),
-      // @ts-ignore
-      lineDash: getLineDash(originalSymbol.stroke),
-      // @ts-ignore
-      lineCap: isDashedBrush(originalSymbol.stroke) ? 'square' : 'round'
-    });
-    _this.originalSymbol = originalSymbol;
-    return _this;
-  }
-
-  _createClass(SGisPolylineSymbol, [{
-    key: "renderFunction",
-    value: function renderFunction(feature, resolution, crs) {
-      if (!isSimplePolylineSymbol(this.originalSymbol)) return _get(_getPrototypeOf(SGisPolylineSymbol.prototype), "renderFunction", this).call(this, feature, resolution, crs);
-      const {
-        ending,
-        beginning
-      } = this.originalSymbol;
-      const renders = [];
-      const featureCopy = feature.clone();
-      const beginningMiterRender = getLineMiterRender({
-        color: this.strokeColor,
-        // @ts-ignore
-        kind: beginning.type,
-        position: 'left',
-        // @ts-ignore
-        size: beginning.size,
-        strokeWidth: this.strokeWidth
-      });
-      const endingMiterRender = getLineMiterRender({
-        color: this.strokeColor,
-        // @ts-ignore
-        kind: ending.type,
-        position: 'right',
-        // @ts-ignore
-        size: ending.size,
-        strokeWidth: this.strokeWidth
-      });
-
-      if (beginningMiterRender) {
-        const updatedRings = updateRingsForMiter(featureCopy.rings, 'left', beginningMiterRender.usageSize);
-        const render = beginningMiterRender.getRender(updatedRings, feature.crs, resolution, crs);
-        featureCopy.rings = updatedRings;
-        renders.push(render);
-      }
-
-      if (endingMiterRender) {
-        const updatedRings = updateRingsForMiter(featureCopy.rings, 'right', endingMiterRender.usageSize);
-        const render = endingMiterRender.getRender(updatedRings, feature.crs, resolution, crs);
-        featureCopy.rings = updatedRings;
-        renders.push(render);
-      } // NOTE: линия должна быть в начале чтобы быть под митерами
-
-
-      renders.unshift(..._get(_getPrototypeOf(SGisPolylineSymbol.prototype), "renderFunction", this).call(this, featureCopy, resolution, crs));
-      return renders;
-    }
-  }, {
-    key: "clone",
-    value: function clone() {
-      return new SGisPolylineSymbol(this.originalSymbol);
-    }
-  }]);
-
-  return SGisPolylineSymbol;
-}(PolylineSymbol.PolylineSymbol);
-
-let ShadowedPointSymbol = /*#__PURE__*/function (_PointSymbol) {
-  _inherits(ShadowedPointSymbol, _PointSymbol);
-
-  var _super = /*#__PURE__*/_createSuper(ShadowedPointSymbol);
-
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-  function ShadowedPointSymbol(options) {
-    _classCallCheck(this, ShadowedPointSymbol);
-
-    return _super.call(this, options);
-  }
-
-  _createClass(ShadowedPointSymbol, [{
-    key: "renderFunction",
-    value: function renderFunction(feature, resolution, crs) {
-      if (!(feature instanceof PointFeature.PointFeature)) return [];
-      const {
-        position
-      } = feature.projectTo(crs);
-      const pxPosition = [position[0] / resolution + (this.offset[0] || 0), -position[1] / resolution + (this.offset[1] || 0)];
-      const shadowRender = this.getShadow(pxPosition, feature, position);
-      const pointArc = this.getPoint(pxPosition, feature, position);
-      return shadowRender ? [shadowRender, pointArc] : [pointArc];
-    }
-  }, {
-    key: "getShadow",
-    value: function getShadow(position, _feature, mapCoordinates) {
-      return ShadowedPointSymbol.getShadowArc(position, this, mapCoordinates);
-    }
-  }, {
-    key: "getPoint",
-    value: function getPoint(position, _feature, mapCoordinates) {
-      return ShadowedPointSymbol.getPointArc(position, this, mapCoordinates);
-    }
-  }], [{
-    key: "getShadowArc",
-    value: function getShadowArc(position, _ref, mapCoordinates) {
-      let {
-        strokeWidth = 2,
-        shadowColor,
-        shadowSize,
-        size = 6
-      } = _ref;
-      return new Arc.Arc(position, {
-        fillColor: "transparent",
-        strokeColor: shadowColor,
-        strokeWidth: shadowSize,
-        radius: (size + strokeWidth + shadowSize) / 2,
-        mapCoordinates
-      });
-    }
-  }, {
-    key: "getPointArc",
-    value: function getPointArc(position, _ref2, mapCoordinates) {
-      let {
-        strokeWidth,
-        fillColor,
-        strokeColor,
-        size = 6
-      } = _ref2;
-      return new Arc.Arc(position, {
-        fillColor,
-        strokeColor,
-        strokeWidth,
-        radius: size / 2,
-        mapCoordinates
-      });
-    }
-  }]);
-
-  return ShadowedPointSymbol;
-}(Point.PointSymbol);
-
-const getSimplifiedPolygonCoordinates = function getSimplifiedPolygonCoordinates(feature, crs, tolerance) {
-  if (tolerance === void 0) {
-    tolerance = 1;
-  }
-
-  const projected = feature.crs.equals(crs) ? feature.rings : feature.projectTo(crs).rings;
-  return math.simplifyCoordinates(projected, tolerance);
-};
-function createShadowRender(position, _ref) {
-  let {
-    strokeWidth = 1,
-    shadowColor,
-    shadowSize,
-    size = 3,
-    mapCoordinates
-  } = _ref;
-  const shadowRadius = (size + strokeWidth + shadowSize) / 2;
-  return new Arc.Arc(position, {
-    fillColor: "transparent",
-    strokeColor: shadowColor,
-    strokeWidth: shadowSize,
-    radius: shadowRadius,
-    mapCoordinates
-  });
-}
-function createPointRender(position, _ref2) {
-  let {
-    strokeColor,
-    strokeWidth,
-    fillColor,
-    size = 3,
-    mapCoordinates
-  } = _ref2;
-  const radius = size / 2;
-  return new Arc.Arc(position, {
-    fillColor,
-    strokeColor,
-    strokeWidth,
-    radius,
-    mapCoordinates
-  });
-}
-let ShadowedPolySymbol = /*#__PURE__*/function (_PolylineSymbol) {
-  _inherits(ShadowedPolySymbol, _PolylineSymbol);
-
-  var _super = /*#__PURE__*/_createSuper(ShadowedPolySymbol);
-
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-  function ShadowedPolySymbol(options) {
-    _classCallCheck(this, ShadowedPolySymbol);
-
-    return _super.call(this, options);
-  }
-
-  _createClass(ShadowedPolySymbol, [{
-    key: "renderFunction",
-    value: function renderFunction(feature, resolution, crs) {
-      if (!(feature instanceof Poly$1.Poly)) return [];
-
-      const coordinates = _get(_getPrototypeOf(ShadowedPolySymbol.prototype), "getRenderedCoordinates", this).call(this, feature, resolution, crs);
-
-      const simplifiedFeatureCoordinates = getSimplifiedPolygonCoordinates(feature, crs);
-      const polyRender = this.getPolyRender(coordinates, feature, simplifiedFeatureCoordinates);
-      const shadowRender = this.getShadow(coordinates, feature, simplifiedFeatureCoordinates);
-      const vertexRenders = this.getVertexRenders(coordinates, simplifiedFeatureCoordinates);
-      let renders = [polyRender];
-
-      if (shadowRender) {
-        renders = [shadowRender, polyRender];
-      }
-
-      if (vertexRenders) {
-        renders = renders.concat(vertexRenders);
-      }
-
-      return renders;
-    }
-  }, {
-    key: "getShadow",
-    value: function getShadow(coordinates, _feature, mapCoordinates) {
-      return new Poly.PolyRender(coordinates, {
-        fillStyle: Poly.FillStyle.None,
-        enclosed: this.enclose,
-        strokeColor: this.shadowColor,
-        strokeWidth: this.shadowSize,
-        lineDash: this.lineDash,
-        mapCoordinates
-      });
-    }
-  }, {
-    key: "getPolyRender",
-    value: function getPolyRender(coordinates, _feature, mapCoordinates) {
-      return new Poly.PolyRender(coordinates, {
-        fillStyle: this.enclose ? Poly.FillStyle.Color : Poly.FillStyle.None,
-        enclosed: this.enclose,
-        fillColor: this.fillColor,
-        strokeColor: this.strokeColor,
-        strokeWidth: this.strokeWidth,
-        lineDash: this.lineDash,
-        mapCoordinates
-      });
-    }
-  }, {
-    key: "getVertexRenders",
-    value: function getVertexRenders(coordinates, mapCoordinates) {
-      if (!this.showVertex) return;
-      const pointRenderers = [];
-      const shadowRenderers = [];
-
-      for (let i = 0; i < coordinates.length; i++) {
-        const ring = coordinates[i];
-
-        for (let j = 0; j < ring.length; j++) {
-          const point = ring[j];
-          const featurePoint = mapCoordinates[i][j];
-          const shadowRender = createShadowRender(point, {
-            size: 6,
-            strokeWidth: 2,
-            shadowColor: this.shadowColor,
-            strokeColor: this.strokeColor,
-            shadowSize: this.vertexShadowSize !== undefined ? this.vertexShadowSize : 2,
-            fillColor: 'transparent',
-            mapCoordinates: featurePoint
-          });
-          const pointRender = createPointRender(point, {
-            size: 6,
-            strokeWidth: 2,
-            shadowColor: this.shadowColor,
-            strokeColor: this.strokeColor,
-            shadowSize: this.vertexShadowSize !== undefined ? this.vertexShadowSize : 2,
-            fillColor: '#ffffff',
-            mapCoordinates: featurePoint
-          });
-          shadowRenderers.push(shadowRender);
-          pointRenderers.push(pointRender);
-        }
-      }
-
-      return [...pointRenderers, ...shadowRenderers];
-    }
-  }]);
-
-  return ShadowedPolySymbol;
-}(PolylineSymbol.PolylineSymbol);
-const polySymbolParams = {
-  strokeWidth: 2,
-  strokeColor: '#e33600',
-  shadowSize: 8,
-  shadowColor: 'rgba(227, 54, 0, 0.3)'
-};
-const measureSymbolParams = {
-  strokeColor: '#ff6933',
-  shadowSize: 0,
-  vertexShadowSize: 0
-};
-const measureLengthSymbol = /*#__PURE__*/new ShadowedPolySymbol( /*#__PURE__*/_extends({}, polySymbolParams, measureSymbolParams, {
-  enclose: false,
-  showVertex: true
-}));
-const measureAreaSymbol = /*#__PURE__*/new ShadowedPolySymbol( /*#__PURE__*/_extends({}, polySymbolParams, measureSymbolParams, {
-  fillColor: 'rgba(255, 105, 51, 0.25)',
-  enclose: true,
-  showVertex: true
-}));
-const snapSymbolParams = {
-  size: 10,
-  strokeWidth: 2,
-  strokeColor: '#e33600',
-  fillColor: '#ffffff',
-  shadowColor: 'rgba(227, 54, 0, 0.3)',
-  shadowSize: 3
-};
-const measurePolygonSnapSymbol = /*#__PURE__*/new ShadowedPointSymbol( /*#__PURE__*/_extends({}, snapSymbolParams, {
-  strokeColor: '#ff6933',
-  shadowSize: 0
-}));
-
-let SelectedPointSymbol = /*#__PURE__*/function (_ShadowedPointSymbol) {
-  _inherits(SelectedPointSymbol, _ShadowedPointSymbol);
-
-  var _super = /*#__PURE__*/_createSuper(SelectedPointSymbol);
-
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-  function SelectedPointSymbol(props) {
-    _classCallCheck(this, SelectedPointSymbol);
-
-    return _super.call(this, props);
-  }
-
-  _createClass(SelectedPointSymbol, [{
-    key: "getShadow",
-    value: function getShadow(position, feature, mapCoordinates) {
-      if (feature.isSelected) {
-        return _get(_getPrototypeOf(SelectedPointSymbol.prototype), "getShadow", this).call(this, position, feature, mapCoordinates);
-      }
-    }
-  }, {
-    key: "getPoint",
-    value: function getPoint(position, feature, mapCoordinates) {
-      const pointRender = _get(_getPrototypeOf(SelectedPointSymbol.prototype), "getPoint", this).call(this, position, feature, mapCoordinates);
-
-      if (feature.isSelected) {
-        pointRender.strokeColor = this.selectedStrokeColor;
-        pointRender.fillColor = this.selectedFillColor;
-      }
-
-      return pointRender;
-    }
-  }]);
-
-  return SelectedPointSymbol;
-}(ShadowedPointSymbol);
-
-let SelectedPolySymbol = /*#__PURE__*/function (_ShadowedPolySymbol) {
-  _inherits(SelectedPolySymbol, _ShadowedPolySymbol);
-
-  var _super = /*#__PURE__*/_createSuper(SelectedPolySymbol);
-
-  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
-  function SelectedPolySymbol(props) {
-    _classCallCheck(this, SelectedPolySymbol);
-
-    return _super.call(this, props);
-  }
-
-  _createClass(SelectedPolySymbol, [{
-    key: "getShadow",
-    value: function getShadow(coordinates, feature, mapCoordinates) {
-      if (feature.isSelected) {
-        return _get(_getPrototypeOf(SelectedPolySymbol.prototype), "getShadow", this).call(this, coordinates, feature, mapCoordinates);
-      }
-    }
-  }, {
-    key: "getPolyRender",
-    value: function getPolyRender(coordinates, feature, mapCoordinates) {
-      const polyRender = _get(_getPrototypeOf(SelectedPolySymbol.prototype), "getPolyRender", this).call(this, coordinates, feature, mapCoordinates);
-
-      if (feature.isSelected) {
-        polyRender.fillColor = this.selectedFillColor;
-        polyRender.strokeColor = this.selectedStrokeColor;
-
-        if (this.selectedStrokeWidth !== void 0) {
-          polyRender.strokeWidth = this.selectedStrokeWidth;
-        }
-      }
-
-      return polyRender;
-    }
-  }]);
-
-  return SelectedPolySymbol;
-}(ShadowedPolySymbol);
-
-const selectedPoint = /*#__PURE__*/new SelectedPointSymbol({
-  size: 8,
-  strokeWidth: 2,
-  strokeColor: 'rgba(255, 87, 34, 0.3)',
-  fillColor: 'rgba(255, 255, 255, 0.65)',
-  shadowColor: 'rgba(255, 87, 34, 0.3)',
-  shadowSize: 3,
-  selectedStrokeColor: '#ff5722',
-  selectedFillColor: 'rgba(255, 255, 255, 0.65)'
-});
-const selectedPolyline = /*#__PURE__*/new SelectedPolySymbol({
-  strokeWidth: 6,
-  strokeColor: 'rgba(255, 87, 34, 0.2)',
-  shadowSize: 8,
-  shadowColor: 'rgba(255, 87, 34, 0.3)',
-  selectedStrokeColor: '#ff5722',
-  selectedStrokeWidth: 2
-});
-const selectedPolygon = /*#__PURE__*/new SelectedPolySymbol({
-  strokeWidth: 2,
-  strokeColor: 'rgba(255, 87, 34, 0.3)',
-  shadowSize: 8,
-  shadowColor: 'rgba(255, 87, 34, 0.3)',
-  fillColor: 'rgba(255, 255, 255, 0.36)',
-  enclose: true,
-  selectedFillColor: 'rgba(255, 255, 255, 0.56)',
-  selectedStrokeColor: '#ff5722'
-});
-
-const metersToPixels = (meters, _ref) => {
-  let {
-    painter,
-    crs = Crs.geo
-  } = _ref;
-  const {
-    width
-  } = painter;
-  const zeroPoint = painter.getPointFromPxPosition(0, 0).projectTo(crs);
-  const maxWidthPoint = painter.getPointFromPxPosition(width, 0).projectTo(crs);
-  const widthDistance = geotools.distance(zeroPoint, maxWidthPoint);
-  const pxK = width / (widthDistance || 1);
-  return Math.round(meters * pxK);
-};
-
-const defaultPathStyles = {
-  strokeWidth: 2,
-  strokeColor: 'rgb(0, 163, 245)',
-  fillStyle: Poly.FillStyle.None
-};
-let SVGPoly = /*#__PURE__*/function (_Symbol) {
-  _inherits(SVGPoly, _Symbol);
-
-  var _super = /*#__PURE__*/_createSuper(SVGPoly);
-
-  function SVGPoly(_temp) {
-    var _this;
-
-    let {
-      redrawFeatureNode,
-      pathStyles,
-      circle,
-      className,
-      appendToSvg
-    } = _temp === void 0 ? {} : _temp;
-
-    _classCallCheck(this, SVGPoly);
-
-    _this = _super.call(this);
-    _this.container = document.createElement('div');
-    _this.container.style.position = 'absolute';
-    _this.redrawFeatureNode = redrawFeatureNode;
-    _this.pathStyles = _extends({
-      center: [0, 0],
-      fillColor: 'none'
-    }, pathStyles);
-    _this.circle = circle;
-    _this.className = className;
-    _this.appendToSvg = appendToSvg;
-    return _this;
-  }
-
-  _createClass(SVGPoly, [{
-    key: "renderFunction",
-    value: function renderFunction(feature, resolution, crs) {
-      const coordinates = feature instanceof Poly$1.Poly ? new PolylineSymbol.PolylineSymbol().getRenderedCoordinates(feature, resolution, crs) : feature.centroid;
-      this.setCirclePxRaius(crs);
-      this.container.innerHTML = '';
-      const svg = this.setSvg(coordinates);
-      svg && this.container.append(svg);
-      feature.__dynamicSymbolRender = new Render.DynamicRender({
-        node: this.container,
-        update: (bbox, resolution) => this.update({
-          bbox,
-          resolution,
-          feature,
-          crs
-        }),
-        redraw: () => {
-          this.redrawFeatureNode && this.redrawFeatureNode(feature);
-        }
-      });
-
-      this._setEventListeners(feature);
-
-      return [feature.__dynamicSymbolRender];
-    }
-  }, {
-    key: "setCirclePxRaius",
-    value: function setCirclePxRaius(crs) {
-      if (this.circle && this.pathStyles) {
-        var _this$circle;
-
-        this.pathStyles.radius = metersToPixels(this.circle.radius, {
-          painter: this.circle.painter,
-          crs
-        }) + (((_this$circle = this.circle) == null ? void 0 : _this$circle.pxOffset) || 0);
-      }
-    }
-  }, {
-    key: "update",
-    value: function update(_ref) {
-      var _this$pathStyles, _this$pathStyles2, _this$pathStyles3, _this$pathStyles4;
-
-      let {
-        bbox,
-        resolution,
-        feature,
-        crs
-      } = _ref;
-      if (!feature) return;
-      if (!bbox) bbox = feature.__lastBbox;
-      if (!resolution) resolution = feature.__lastResolution;
-      if (!bbox || !resolution || !feature.crs.canProjectTo(bbox.crs)) return;
-
-      if (feature.__lastResolution && resolution !== feature.__lastResolution) {
-        const newCoordinates = feature instanceof Poly$1.Poly ? new PolylineSymbol.PolylineSymbol().getRenderedCoordinates(feature, resolution, crs) : feature.centroid;
-        this.setCirclePxRaius(crs);
-        this.container.innerHTML = '';
-        const svg = this.setSvg(newCoordinates);
-        svg && this.container.append(svg);
-      }
-
-      const polygon = feature.projectTo(bbox.crs);
-      const radiusOffset = (_this$pathStyles = this.pathStyles) != null && _this$pathStyles.radius ? ((_this$pathStyles2 = this.pathStyles) == null ? void 0 : _this$pathStyles2.radius) + ((_this$pathStyles3 = this.pathStyles) != null && _this$pathStyles3.strokeWidth ? ((_this$pathStyles4 = this.pathStyles) == null ? void 0 : _this$pathStyles4.strokeWidth) / 2 : 0) : 0;
-      const dx = Math.round((polygon.bbox.xMin - bbox.xMin) / resolution) - radiusOffset;
-      const dy = Math.round((bbox.yMax - polygon.bbox.yMax) / resolution) - radiusOffset;
-      this.container.style.left = dx.toString() + "px";
-      this.container.style.top = dy.toString() + "px";
-      feature.__lastBbox = bbox;
-      feature.__lastResolution = resolution;
-    }
-  }, {
-    key: "setSvg",
-    value: function setSvg(coordinates) {
-      const {
-        lineCap,
-        lineJoin,
-        miterLimit,
-        lineDash,
-        dashOffset
-      } = this.pathStyles || {};
-      const svgRender = new SvgRender.SvgRender(_extends({
-        coordinates
-      }, defaultPathStyles, {
-        appendToSvg: this.appendToSvg
-      }, this.pathStyles));
-
-      if (this.circle) {
-        svgRender._setArcNode();
-      } else {
-        svgRender._setPolyNode();
-      }
-
-      let svgElement;
-      svgRender.getNode((_, svg) => {
-        svgElement = svg;
-        this.className && svgElement.classList.add(this.className);
-        const path = svgElement && svgElement.querySelector(this.circle ? 'circle' : 'path');
-
-        if (path) {
-          path.setAttribute('stroke-linecap', lineCap || 'round');
-          path.setAttribute('stroke-linejoin', lineJoin || 'round');
-          path.setAttribute('stroke-miterlimit', (miterLimit || 10).toString());
-          path.setAttribute('stroke-dashoffset', (dashOffset || 0).toString());
-
-          if (this.circle) {
-            path.setAttribute('stroke-dasharray', lineDash && lineDash.length > 0 ? lineDash.join(',') : '');
-          }
-        }
-      });
-      return svgElement;
-    }
-  }, {
-    key: "_setEventListeners",
-    value: function _setEventListeners(dynamicFeature) {
-      var _dynamicFeature$__dyn;
-
-      if (dynamicFeature.eventFlags === EventHandler.MouseEventFlags.None) return;
-      const svgNode = dynamicFeature == null ? void 0 : (_dynamicFeature$__dyn = dynamicFeature.__dynamicSymbolRender) == null ? void 0 : _dynamicFeature$__dyn.node.querySelector(this.circle ? 'circle' : 'path');
-      Object.keys(EventHandler.mouseEvents).forEach(eventName => {
-        if (dynamicFeature.eventFlags & EventHandler.mouseEvents[eventName].flag) {
-          domEvent.listenDomEvent(svgNode, EventHandler.mouseEvents[eventName].type, event => {
-            dynamicFeature.fire(EventHandler.mouseEvents[eventName].type, {
-              node: svgNode,
-              browserEvent: event
-            });
-          });
-        }
-      });
-    }
-  }]);
-
-  return SVGPoly;
-}(_Symbol.Symbol);
-
-function isSGisPointSymbol(symbol) {
-  return symbol instanceof Point.PointSymbol || symbol instanceof StaticImageSymbol.StaticImageSymbol || symbol instanceof Square.SquareSymbol || symbol instanceof MaskedImage.MaskedImage;
-}
-function isSGisImageSymbol(symbol) {
-  return symbol instanceof StaticImageSymbol.StaticImageSymbol || symbol instanceof MaskedImage.MaskedImage;
-}
-function isSGisPolygonSymbol(symbol) {
-  return symbol instanceof Simple.PolygonSymbol || symbol instanceof BrushFill.BrushFill || symbol instanceof ImageFill.ImageFill;
-}
-function isSGisPolylineSymbol(symbol) {
-  return symbol instanceof PolylineSymbol.PolylineSymbol;
-}
-function isSGisH3Symbol(symbol) {
-  return symbol instanceof H3Symbol.H3Symbol;
-}
-function isSGisCombinedPolylineSymbol(symbol) {
-  return symbol instanceof CombinedPolylineSymbol.CombinedPolylineSymbol;
-}
-function isSGisClusterSymbol(symbol) {
-  return !!symbol.singleObjectSymbol;
-}
-
-/**
- * Моки фич для отображения превью символа
- * http://cf.everpoint.ru/pages/viewpage.action?pageId=45024217
- */
-
-const viewBoxSize = 100;
-const pointFeature = /*#__PURE__*/new PointFeature.PointFeature([50, -50], {
-  crs: Crs.plain
-});
-const lineFeature = /*#__PURE__*/new Polyline.Polyline([[0, -57], [26, -57], [40, -35], [60, -65], [74, -43], [100, -43]], {
-  crs: Crs.plain
-});
-const combinedLineFeature = /*#__PURE__*/new CombinedPolyline.CombinedPolyline([[0, -57], [26, -57], [40, -35], [60, -65], [74, -43], [100, -43]], {
-  crs: Crs.plain
-});
-const polygonFeature = /*#__PURE__*/new Polygon.Polygon([[20, -20], [80, -20], [80, -80], [20, -80]], {
-  crs: Crs.plain
-});
-const h3gridFeature = /*#__PURE__*/new H3Feature.H3Feature([[50, -15], [80, -33], [80, -67], [50, -85], [20, -67], [20, -33], [50, -15]], {
-  crs: Crs.plain
-});
-const lineLegendFeature = /*#__PURE__*/new Polyline.Polyline([[0, -50], [100, -50]], {
-  crs: Crs.plain
-});
-const polygonLegendFeature = /*#__PURE__*/new Polygon.Polygon([[20, -20], [80, -20], [80, -80], [20, -80]], {
-  crs: Crs.plain
-});
-const polygonMapLegendFeature = /*#__PURE__*/new Polygon.Polygon([[50, 0], [100, -25], [100, -75], [50, -100], [0, -75], [0, -25]], {
-  crs: Crs.plain
-});
-const MAP_LEGEND_FEATURES = {
-  polygon: polygonMapLegendFeature
-};
-const LEGEND_FEATURES = {
-  point: pointFeature,
-  polyline: lineLegendFeature,
-  combinedPolyline: combinedLineFeature,
-  polygon: polygonLegendFeature,
-  h3grid: h3gridFeature
-};
-const MOCK_FEATURES = {
-  point: pointFeature,
-  polyline: lineFeature,
-  combinedPolyline: combinedLineFeature,
-  polygon: polygonFeature,
-  h3grid: h3gridFeature
-};
-
-function getSymbolRenders(symbol, size, features) {
-  if (size === void 0) {
-    size = viewBoxSize;
-  }
-
-  if (features === void 0) {
-    features = {};
-  }
-
-  const resolution = viewBoxSize / size;
-
-  const featuresToRender = _extends({}, MOCK_FEATURES, features);
-
-  if (isSGisPolygonSymbol(symbol)) {
-    return symbol.renderFunctionAsync(featuresToRender.polygon, resolution, Crs.plain);
-  }
-
-  if (isSGisPolylineSymbol(symbol)) {
-    return symbol.renderFunctionAsync(featuresToRender.polyline, resolution, Crs.plain);
-  }
-
-  if (isSGisH3Symbol(symbol)) {
-    return symbol.renderFunctionAsync(featuresToRender.h3grid, resolution, Crs.plain);
-  }
-
-  if (isSGisCombinedPolylineSymbol(symbol)) {
-    return symbol.renderFunctionAsync(featuresToRender.combinedPolyline, resolution, Crs.plain);
-  }
-
-  return symbol.renderFunctionAsync(featuresToRender.point, resolution, Crs.plain);
-}
-const getMapLegendSymbolRenders = function getMapLegendSymbolRenders(symbol, size) {
-  if (size === void 0) {
-    size = viewBoxSize;
-  }
-
-  return getSymbolRenders(symbol, size, MAP_LEGEND_FEATURES);
-};
-const getLegendSymbolRenders = function getLegendSymbolRenders(symbol, size) {
-  if (size === void 0) {
-    size = viewBoxSize;
-  }
-
-  return getSymbolRenders(symbol, size, LEGEND_FEATURES);
-};
-
-function renderSymbolToCanvas(renders, canvas) {
-  renders.forEach(render => {
-    canvas.draw(render);
-  });
-}
-
-function deserializeSymbol(symbol) {
-  switch (symbol.type) {
-    case "h3grid":
-      return deserializeH3Symbol(symbol);
-
-    case "svgPointSymbol":
-      return deserializeSvgPointSymbol(symbol);
-
-    case 'circlePointSymbol':
-      return deserializePointSymbol(symbol);
-
-    case 'squarePointSymbol':
-      return deserializeSquareSymbol(symbol);
-
-    case 'maskedImagePointSymbol':
-      return deserializeMaskedImageSymbol(symbol);
-
-    case 'imagePointSymbol':
-      return deserializeImagePointSymbol(symbol);
-
-    case 'polygonSymbol':
-      return deserializePolygonSymbol(symbol);
-
-    case 'simplePolylineSymbol':
-      return deserializePolylineSymbol(symbol);
-
-    case "clusterSymbol":
-      return deserializeSymbol(symbol.singleObjectSymbol);
-
-    default:
-      return null;
-  }
-}
-
-function deserializeH3Symbol(symbol) {
-  var _symbol$stroke, _symbol$stroke2, _symbol$fill;
-
-  return new H3Symbol.H3Symbol(_extends({}, symbol, {
-    cellSize: getParameterValue(symbol.cellSize),
-    strokeWidth: getParameterValue(symbol == null ? void 0 : (_symbol$stroke = symbol.stroke) == null ? void 0 : _symbol$stroke.width),
-    strokeColor: getParameterValue(symbol == null ? void 0 : (_symbol$stroke2 = symbol.stroke) == null ? void 0 : _symbol$stroke2.color),
-    fillColor: getParameterValue(symbol == null ? void 0 : (_symbol$fill = symbol.fill) == null ? void 0 : _symbol$fill.color)
-  }));
-}
-
-function deserializePointSymbol(symbol) {
-  // @ts-ignore
-  return new Point.PointSymbol(deserializePointSymbolParams(symbol));
-}
-
-const getOffsetParameterValue = offset => [getParameterValue(offset == null ? void 0 : offset[0]), getParameterValue(offset == null ? void 0 : offset[1])];
-
-function deserializeSvgPointSymbolParams(_ref) {
-  let {
-    type,
-    data,
-    size,
-    offset,
-    angle,
-    background,
-    figure
-  } = _ref;
-  return _extends({
-    type: getParameterValue(type),
-    data: getParameterValue(data),
-    size: getParameterValue(size),
-    offset: getOffsetParameterValue(offset),
-    angle: getParameterValue(angle)
-  }, background ? {
-    background: _extends({}, background, {
-      fillColor: deserializeColor(getParameterValue(background == null ? void 0 : background.fillColor)),
-      strokeColor: deserializeColor(getParameterValue(background == null ? void 0 : background.strokeColor)),
-      strokeWidth: getParameterValue(background == null ? void 0 : background.strokeWidth)
-    })
-  } : {}, figure ? {
-    figure: _extends({}, figure, {
-      strokeColor: deserializeColor(getParameterValue(figure == null ? void 0 : figure.strokeColor)),
-      strokeWidth: getParameterValue(figure == null ? void 0 : figure.strokeWidth),
-      fillColor: deserializeColor(getParameterValue(figure == null ? void 0 : figure.fillColor))
-    })
-  } : {});
-}
-
-function deserializeSvgPointSymbol(symbol) {
-  return new Point.PointSymbol(deserializeSvgPointSymbolParams(symbol));
-}
-
-function deserializeSquareSymbol(symbol) {
-  return new Square.SquareSymbol(_extends({}, deserializePointSymbolParams(symbol), {
-    // @ts-ignore
-    angle: getParameterValue(symbol.angle)
-  }));
-}
-
-function deserializeMaskedImageSymbol(symbol) {
-  return new MaskedImage.MaskedImage(_extends({}, symbol, {
-    // @ts-ignore
-    angle: getParameterValue(symbol.angle),
-    // @ts-ignore
-    width: getParameterValue(symbol.width),
-    // @ts-ignore
-    height: getParameterValue(symbol.height),
-    // @ts-ignore
-    anchorPoint: deserializeAnchor(symbol.offset),
-    // @ts-ignore
-    imageSource: deserializeBase64(symbol.image),
-    // @ts-ignore
-    maskSource: deserializeBase64(symbol.imageMask),
-    // @ts-ignore
-    maskColor: deserializeColor(getParameterValue(symbol.maskedColor))
-  }));
-}
-
-function deserializeImagePointSymbol(symbol) {
-  return new StaticImageSymbol.StaticImageSymbol(_extends({}, symbol, {
-    // @ts-ignore
-    angle: getParameterValue(symbol.angle),
-    // @ts-ignore
-    width: getParameterValue(symbol.width),
-    // @ts-ignore
-    height: getParameterValue(symbol.height),
-    // @ts-ignore
-    anchorPoint: deserializeAnchor(symbol.offset),
-    // @ts-ignore
-    source: deserializeBase64(symbol.image)
-  }));
-}
-
-function deserializePolygonSymbol(symbol) {
-  if (isPolygonHasPatternBrush(symbol)) {
-    return new SGisImageFill(symbol);
-  }
-
-  if (isPolygonHasHatchBrush(symbol)) {
-    return new SGisBrushFill(symbol);
-  }
-
-  return new SGisPolygonSymbol(symbol);
-}
-
-function deserializePolylineSymbol(symbol) {
-  return new SGisPolylineSymbol(symbol);
-}
-
-function deserializePointSymbolParams(_ref2) {
-  let {
-    size,
-    offset,
-    strokeColor,
-    strokeWidth,
-    fillColor
-  } = _ref2;
-  return {
-    size: getParameterValue(size),
-    offset: deserializeAnchor(offset),
-    strokeWidth: getParameterValue(strokeWidth),
-    strokeColor: deserializeColor(getParameterValue(strokeColor)),
-    fillColor: deserializeColor(getParameterValue(fillColor))
-  };
-}
-
-function deserializeBase64(base) {
-  return "data:image/png;base64," + base;
-}
-
-function deserializeAnchor(offset) {
-  // @ts-ignore
-  return offset.map(getParameterValue);
-}
-
-function deserializeColor(color$1) {
-  return color$1 ? new color.Color(color$1).toString() : null;
-}
-
-const clampSymbol = (symbol, min, max) => {
-  if (isSGisImageSymbol(symbol)) {
-    symbol.width = clamp(symbol.width, min, max);
-    symbol.height = clamp(symbol.height, min, max);
-  } else if (isSGisPointSymbol(symbol)) {
-    symbol.size = clamp(symbol.size, min, max);
-  }
-
-  return symbol;
-};
-function centerAlignSymbol(symbol) {
-  if (isSGisImageSymbol(symbol)) {
-    symbol.anchorPoint = [symbol.width / 2, symbol.height / 2];
-  } else if (isSGisPointSymbol(symbol)) {
-    symbol.offset = [0, 0];
-  }
-
-  return symbol;
-}
-const adjustSymbol = (symbol, _ref) => {
-  let {
-    size
-  } = _ref;
-  return centerAlignSymbol(clampSymbol(symbol, 0, size));
-};
-
-const useSvgSymbol = (symbol, skipOffset, isClassified) => {
-  const SVGWrapperRefElement = React.useRef(null);
-  const SVGContainer = React.useMemo(() => svg_js.SVG(), []);
-  const initSvg = React.useCallback(() => {
-    SVGContainer.addTo(SVGWrapperRefElement.current);
-  }, [SVGContainer]);
-  const getSvgData = React.useCallback(() => SVGContainer.svg(), [SVGContainer]);
-  const manipulateSvg = React.useCallback((_ref) => {
-    let {
-      svg,
-      bg,
-      newSymbol,
-      isClassified
-    } = _ref;
-    manipulateSvgSymbol({
-      SVGContainer,
-      symbol: newSymbol || symbol,
-      svg,
-      bg,
-      isClassified
-    });
-  }, [SVGContainer, symbol]);
-  const getUpdatedSvgSymbol = React.useCallback((field, value) => {
-    var _newSymbol$background;
-
-    const {
-      data,
-      offset
-    } = symbol;
-    const newValue = value instanceof Color.Color ? value.toString('rgba') : value;
-
-    const newSymbol = _extends({}, JSON.parse(JSON.stringify(symbol)), {
-      offset: skipOffset ? DEFAULT_SYMBOL_OFFSET : isSizeClassification(field) ? getOffsetParameterValue(offset) : offset
-    });
-
-    if (field.indexOf('.') !== -1) {
-      var _newSymbol$parts$;
-
-      const parts = field.split('.');
-
-      if ((_newSymbol$parts$ = newSymbol[parts[0]]) != null && _newSymbol$parts$[parts[1]]) {
-        newSymbol[parts[0]][parts[1]] = newValue;
-      } else {
-        newSymbol[parts[0]] = _extends({}, newSymbol[parts[0]], {
-          [parts[1]]: newValue
-        }, parts[0] === 'background' ? {
-          type: newSymbol.background.type,
-          id: 'symbol-bg'
-        } : parts[0] === 'figure' ? {
-          id: 'symbol-figure'
-        } : {});
-      }
-    } else {
-      newSymbol[field] = newValue;
-    }
-
-    manipulateSvg({
-      svg: getParameterValue(data),
-      newSymbol,
-      bg: (_newSymbol$background = newSymbol.background) == null ? void 0 : _newSymbol$background.type,
-      isClassified
-    });
-    return _extends({}, newSymbol, {
-      data: SVGContainer.svg()
-    });
-  }, [SVGContainer, manipulateSvg, skipOffset, symbol]);
-  return {
-    svgRef: SVGWrapperRefElement,
-    initSvg,
-    getSvgData,
-    manipulateSvg,
-    getUpdatedSvgSymbol
-  };
-};
-
-var _templateObject$1, _templateObject2$1;
-const SvgSymbolContainer = /*#__PURE__*/styled__default.div(_templateObject$1 || (_templateObject$1 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  position: relative;\n"])));
-const SvgSymbolLabel = /*#__PURE__*/styled__default.div(_templateObject2$1 || (_templateObject2$1 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  position: absolute;\n  top: 0;\n  left: 0;\n  right: 0;\n  bottom: 0;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  color: #fff;\n  ", ";\n  ", ";\n  ", ";\n  ", ";\n  ", ";\n  ", ";\n  line-height: 0;\n"])), (_ref) => {
-  let {
-    fontSettings
-  } = _ref;
-  return !!(fontSettings != null && fontSettings.fontFamily) && "font-family: " + fontSettings.fontFamily;
-}, (_ref2) => {
-  let {
-    fontSettings
-  } = _ref2;
-  return !!(fontSettings != null && fontSettings.fontWeight) && "font-weight: " + fontSettings.fontWeight;
-}, (_ref3) => {
-  let {
-    fontSettings
-  } = _ref3;
-  return !!(fontSettings != null && fontSettings.fontStyle) && "font-style: " + fontSettings.fontStyle;
-}, (_ref4) => {
-  let {
-    fontSettings
-  } = _ref4;
-  return !!(fontSettings != null && fontSettings.fontColor) && "color: " + fontSettings.fontColor;
-}, (_ref5) => {
-  let {
-    fontSettings
-  } = _ref5;
-  return !!(fontSettings != null && fontSettings.fontSize) && "font-size: " + (typeof fontSettings.fontSize === 'string' ? fontSettings.fontSize : fontSettings.fontSize + "px");
-}, (_ref6) => {
-  let {
-    fontSettings
-  } = _ref6;
-  return !!(fontSettings != null && fontSettings.haloColor) && !!(fontSettings != null && fontSettings.haloWidth) && "-webkit-text-stroke: " + fontSettings.haloWidth + "px " + fontSettings.haloColor + ";";
-});
-const SvgSymbol = /*#__PURE__*/React.memo((_ref7) => {
-  let {
-    svg,
-    bg,
-    symbol,
-    title,
-    text,
-    fontSettings,
-    skipOffset,
-    isClassified,
-    onClick
-  } = _ref7;
-  const {
-    svgRef,
-    initSvg,
-    getSvgData,
-    manipulateSvg
-  } = useSvgSymbol(symbol, skipOffset, isClassified);
-  const onSelectSymbol = React.useCallback(() => {
-    onClick == null ? void 0 : onClick(getSvgData(), _extends({}, symbol, bg ? {
-      background: _extends({}, symbol.background, {
-        type: bg
-      })
-    } : {}));
-  }, [bg, getSvgData, onClick, symbol]);
-  const renderSymbol = React.useMemo(() => React__default.createElement(SymbolButton, {
-    ref: svgRef,
-    title: title,
-    onClick: onClick ? onSelectSymbol : undefined
-  }), [svgRef, title, onClick, onSelectSymbol]);
-  React.useEffect(() => {
-    initSvg();
-  }, [initSvg]);
-  React.useEffect(() => {
-    manipulateSvg({
-      svg,
-      bg,
-      newSymbol: symbol,
-      isClassified
-    });
-  }, [svg, symbol, bg, manipulateSvg, isClassified]);
-  return text ? React__default.createElement(SvgSymbolContainer, null, renderSymbol, React__default.createElement(SvgSymbolLabel, {
-    fontSettings: fontSettings
-  }, text), !!(fontSettings != null && fontSettings.haloColor) && !!(fontSettings != null && fontSettings.haloWidth) && React__default.createElement(SvgSymbolLabel, {
-    fontSettings: _extends({}, fontSettings, {
-      haloColor: undefined,
-      haloWidth: undefined
-    })
-  }, text)) : renderSymbol;
-});
-
-const ClusterSymbolPreview = (_ref) => {
-  var _symbol$fillColor$val, _symbol$labelSymbol;
-
-  let {
-    symbol,
-    index,
-    size = 56,
-    fontSize = '1.25rem'
-  } = _ref;
-  const isClassified = isParameterByAttribute(symbol.fillColor);
-  const isClassifiedValue = isClassified && index !== undefined;
-  const fillColor = isClassifiedValue ? ((_symbol$fillColor$val = symbol.fillColor.values[index]) == null ? void 0 : _symbol$fillColor$val.value) || symbol.fillColor.defaultValue : symbol.fillColor;
-  const strokeColor = isClassified ? fillColor : symbol.strokeColor;
-  const svgSymbol = {
-    type: 'svgPointSymbol',
-    size,
-    offset: [0, 0],
-    angle: 0,
-    background: {
-      id: 'symbol-bg',
-      fillColor,
-      strokeColor,
-      strokeWidth: 6,
-      type: 'circle'
-    }
-  };
-  return React__default.createElement(SvgSymbol, {
-    svg: DEFAULT_CLUSTER_SVG,
-    symbol: svgSymbol,
-    isClassified: isClassified,
-    text: '99',
-    fontSettings: _extends({}, symbol.labelSymbol, {
-      fontSize: fontSize || ((_symbol$labelSymbol = symbol.labelSymbol) == null ? void 0 : _symbol$labelSymbol.fontSize)
-    })
-  });
-};
-
-const SymbolByType = (_ref) => {
-  let {
-    type,
-    symbol,
-    size,
-    svg,
-    skipOffset
-  } = _ref;
-  const defaultSymbol = React.useMemo(() => React__default.createElement(Symbol, {
-    symbol: symbol,
-    size: size
-  }), [symbol, size]);
-
-  switch (type) {
-    case 'svgPointSymbol':
-      return svg ? React__default.createElement(SvgSymbol, {
-        svg: svg,
-        size: size,
-        skipOffset: skipOffset,
-        symbol: serializeSvgPointSymbol(symbol)
-      }) : defaultSymbol;
-
-    default:
-      return defaultSymbol;
-  }
-};
-
-const LegendSymbolRenderer = /*#__PURE__*/React.memo((_ref) => {
-  let {
-    symbol,
-    index
-  } = _ref;
-
-  if (isClusterSymbol(symbol)) {
-    return React__default.createElement(ClusterLegendContainer, null, React__default.createElement(ClusterSymbolPreview, {
-      symbol: symbol,
-      index: index
-    }));
-  }
-
-  return React__default.createElement(SymbolByType, {
-    symbol: deserializeSymbol(symbol),
-    size: getLegendSymbolSize(symbol) || DEFAULT_LEGEND_SYMBOL_SIZE,
-    type: symbol.type,
-    svg: getParameterValue(symbol.data),
-    skipOffset: true
-  });
-});
-
-const LegendHeaderButtons = (_ref) => {
-  let {
-    layerName,
-    hasHiddenLegends,
-    isShared,
-    clearHiddenLegends,
-    goToClassification
-  } = _ref;
-  return React__default.createElement(React__default.Fragment, null, !!goToClassification && !isShared && React__default.createElement(LegendHeaderButton, null, React__default.createElement(icons.IconButton, {
-    onClick: goToClassification
-  }, React__default.createElement(icons.EverCloudClassificationIcon, null))), !!clearHiddenLegends && React__default.createElement(LegendHeaderButton, null, React__default.createElement(icons.IconButton, {
-    disabled: !hasHiddenLegends,
-    onClick: () => clearHiddenLegends == null ? void 0 : clearHiddenLegends(layerName)
-  }, React__default.createElement(icons.EverCloudRefreshIcon, null))));
-};
-
-const getConditionAttribute = (attributes, condition) => {
-  if (!condition) return null;
-  const attributeName = getAttributeNameFromCondition(condition);
-  let attribute = attributes.find((_ref) => {
-    let {
-      name
-    } = _ref;
-    return name === attributeName;
-  });
-
-  if (!attribute) {
-    if (attributeName === 'count') {
-      attribute = {
-        name: 'count',
-        alias: 'Количество',
-        type: api.AttributeType.Int32
-      };
-    } else {
-      return null;
-    }
-  }
-
-  return attribute;
-};
-
-const isHiddenLegend = (hiddenCondition, hiddenLegends) => !!(hiddenLegends != null && hiddenLegends.includes(hiddenCondition));
-
-const renderColumn = (column, index) => {
-  const dateTime = column.split(' ');
-  return React__default.createElement(React.Fragment, {
-    key: index
-  }, React__default.createElement(ItemText, {
-    title: column
-  }, dateTime[0], React__default.createElement(MapLegendDescription, null, dateTime[1])), index === 0 && React__default.createElement(ItemSeparator, null));
-};
-
-const getLegendText = (_ref) => {
-  let {
-    title,
-    index,
-    isDate
-  } = _ref;
-
-  if (!title) {
-    return React__default.createElement(ItemText, null, i18n.t("other", {
-      ns: "style"
-    }));
-  }
-
-  const columns = title == null ? void 0 : title.split(' - ');
-  const isSingleColumn = (columns == null ? void 0 : columns.length) === 1;
-
-  if (!isDate || index && isSingleColumn) {
-    return React__default.createElement(ItemText, {
-      title: title
-    }, title);
-  }
-
-  if (!index && isSingleColumn) {
-    return React__default.createElement(React__default.Fragment, null, React__default.createElement(ItemText, {
-      title: "\u221E"
-    }, "\u221E"), React__default.createElement(ItemSeparator, null), renderColumn(title));
-  }
-
-  return React__default.createElement(React__default.Fragment, null, columns.map(renderColumn));
-};
-
-const getLayerAttributes = layerDefinition => {
-  const attributes = layerDefinition && layerDefinition.attributes || {};
-  return Object.entries(attributes).map((_ref) => {
-    let [name, definition] = _ref;
-    return _extends({
-      name
-    }, definition);
-  });
-};
-
-const LegendChildren = (_ref) => {
-  var _layerInfo$style, _layerInfo$style$chil;
-
-  let {
-    layerInfo,
-    hiddenLegends,
-    toggleHiddenLegend,
-    clearHiddenLegends,
-    formatValue
-  } = _ref;
-  if (!(layerInfo != null && (_layerInfo$style = layerInfo.style) != null && (_layerInfo$style$chil = _layerInfo$style.children) != null && _layerInfo$style$chil.length)) return null;
-  const attributes = getLayerAttributes(layerInfo.layerDefinition);
-  return React__default.createElement(MapLegendContainer, null, layerInfo.style.children.map((paramValue, index) => {
-    var _getConditionAttribut;
-
-    const attribute = getConditionAttribute(attributes, paramValue.condition);
-    if (!attribute) return null;
-    const hiddenCondition = createHiddenCondition(attribute.name, attribute.type, getClassificationValue(paramValue.symbol, paramValue.title, new ClassificationCondition(paramValue.condition)));
-    const legendText = getLegendText({
-      title: isRangeCondition(paramValue.condition) ? createValueTitleFromCondition(paramValue, attribute, formatValue, index) : getTitleFromCondition({
-        condition: paramValue.condition,
-        attribute,
-        formatValue
-      }),
-      index,
-      isDate: ((_getConditionAttribut = getConditionAttribute(attributes, paramValue.condition)) == null ? void 0 : _getConditionAttribut.type) === 'DateTime'
-    });
-    return React__default.createElement(ClassifiedItem, {
-      key: index,
-      isHidden: isHiddenLegend(hiddenCondition, hiddenLegends == null ? void 0 : hiddenLegends[layerInfo.name]),
-      onClick: () => toggleHiddenLegend == null ? void 0 : toggleHiddenLegend(layerInfo.name, hiddenCondition)
-    }, React__default.createElement(SymbolContainer, null, React__default.createElement(LegendSymbolRenderer, {
-      symbol: paramValue.symbol
-    })), legendText, React__default.createElement(LegendHeaderButtons, {
-      layerName: layerInfo.name,
-      clearHiddenLegends: clearHiddenLegends
-    }));
-  }));
-};
-
-const LegendParameterDescription = (_ref) => {
-  let {
-    parameter,
-    index
-  } = _ref;
-  const {
-    t
-  } = reactI18next.useTranslation("style");
-  const isSize = isParameterType("size", parameter);
-  const isStrokeWidth = isParameterType(["strokeWidth", "stroke.width"], parameter);
-  const isStrokeColor = isParameterType(["strokeColor", "stroke.color"], parameter);
-  return React__default.createElement(MapLegendDescriptionContainer, null, isStrokeWidth || isStrokeColor ? isStrokeWidth ? t("strokeWidth") : t("strokeColor") : isSize ? t("symbolSize") : t("symbolColor"), !!index && React__default.createElement(MapLegendBadge, null, index));
-};
-
-const getValueFromLegendTitle = (title, minOrMax) => {
-  if (title.includes(" - ")) {
-    const result = title == null ? void 0 : title.split(" - ");
-    return minOrMax === "min" ? result == null ? void 0 : result[0] : result == null ? void 0 : result[1];
-  }
-
-  if (title.includes(",")) {
-    const result = title == null ? void 0 : title.split(",");
-    return result.join(", ");
-  }
-
-  return title.split(" ").find(isNumeric) || title || "";
-};
-
-const MinimizedLegend = (_ref) => {
-  var _currentValues$, _currentValues, _currentValues$2, _currentValues2;
-
-  let {
-    innerRef,
-    isShown,
-    values,
-    title,
-    parameter,
-    hiddenLegends
-  } = _ref;
-  const {
-    t
-  } = reactI18next.useTranslation("style");
-  const currentValues = [...values];
-  const other = currentValues.pop();
-  const isSize = isParameterType("size", parameter);
-  const isStrokeWidth = isParameterType(["strokeWidth", "stroke.width"], parameter);
-  const titleMax = getValueFromLegendTitle((_currentValues$ = currentValues[0]) == null ? void 0 : _currentValues$.title, "max");
-  const titleMin = getValueFromLegendTitle((_currentValues = currentValues[currentValues.length - 1]) == null ? void 0 : _currentValues.title, "min");
-  const checkIsHidden = React.useCallback(hiddenCondition => hiddenCondition ? hiddenLegends == null ? void 0 : hiddenLegends.some(condition => hiddenCondition.includes(condition)) : false, [hiddenLegends]);
-  return React__default.createElement(MinimizedLegendContainer, {
-    ref: innerRef,
-    isShown: isShown
-  }, !!title && React__default.createElement(MapLegendValueDescr, null, title), isSize ? React__default.createElement(React__default.Fragment, null, React__default.createElement(SizeMinimizedLegend, null, React__default.createElement(SizeMinimizedLegendSymbol, null, React__default.createElement(MapLegendItems, {
-    parameter: parameter,
-    isSize: true
-  }, currentValues.map((value, index) => React__default.createElement(MapLegendItem, {
-    key: "" + value.title + index,
-    title: value.title,
-    value: value.parameterValue,
-    parameter: parameter,
-    isHidden: checkIsHidden(value.hiddenCondition)
-  })))), React__default.createElement(SizeMinimizedLegendLabel, null, React__default.createElement(SizeMinimizedLegendDown, null, (_currentValues$2 = currentValues[0]) == null ? void 0 : _currentValues$2.title), React__default.createElement(SizeMinimizedLegendUp, null, (_currentValues2 = currentValues[currentValues.length - 1]) == null ? void 0 : _currentValues2.title))), React__default.createElement(SizeMinimizedLegend, null, React__default.createElement(SizeMinimizedLegendSymbol, null, React__default.createElement(MapLegendItems, {
-    parameter: parameter,
-    isSize: true
-  }, React__default.createElement(MapLegendOther, {
-    title: t("other"),
-    value: other == null ? void 0 : other.parameterValue,
-    parameter: parameter,
-    isHidden: checkIsHidden(other == null ? void 0 : other.hiddenCondition)
-  }))), React__default.createElement(SizeMinimizedLegendLabel, null, React__default.createElement(SizeMinimizedLegendUp, null, t("other"))))) : isStrokeWidth ? React__default.createElement(MapLegendItems, {
-    parameter: parameter,
-    isStrokeWidth: true
-  }, currentValues.map((value, index) => React__default.createElement(MapLegendItem, {
-    key: "" + value.title + index,
-    title: value.title,
-    value: value.parameterValue,
-    parameter: parameter,
-    isHidden: checkIsHidden(value.hiddenCondition)
-  }, (!index || index === currentValues.length - 1) && value.title)), React__default.createElement(MapLegendOther, {
-    title: t("other"),
-    value: other == null ? void 0 : other.parameterValue,
-    parameter: parameter,
-    isHidden: checkIsHidden(other == null ? void 0 : other.hiddenCondition)
-  }, t("other"))) : React__default.createElement(MapLegendItems, {
-    parameter: parameter
-  }, React__default.createElement(MapLegendItemsContainer, null, currentValues.map((value, index) => React__default.createElement(MapLegendItem, {
-    key: "" + value.title + index,
-    title: value.title,
-    value: value.parameterValue,
-    parameter: parameter,
-    isHidden: checkIsHidden(value.hiddenCondition)
-  }))), React__default.createElement(MapLegendOther, {
-    title: t("other"),
-    value: other == null ? void 0 : other.parameterValue,
-    parameter: parameter,
-    isHidden: checkIsHidden(other == null ? void 0 : other.hiddenCondition)
-  })), typeof (other == null ? void 0 : other.parameterValue) === "string" && (titleMax || titleMin) && React__default.createElement(MapLegendValues, null, React__default.createElement(MapLegendValuesRange, null, React__default.createElement("div", null, titleMax), React__default.createElement("div", null, titleMin)), React__default.createElement(MapLegendValuesOther, null, "-")));
-};
-
-const MaximizedLegend = (_ref) => {
-  let {
-    innerRef,
-    isShown,
-    layerName,
-    symbol: sectionSymbol,
-    parameter,
-    values,
-    index: sectionIndex,
-    attributeType,
-    hiddenLegends,
-    toggleHiddenLegend
-  } = _ref;
-  const isDate = attributeType === 'DateTime';
-  const isSize = isParameterType('size', parameter);
-  const isStrokeWidth = isParameterType(['strokeWidth', 'stroke.width'], parameter);
-  const isStrokeColor = isParameterType(['strokeColor', 'stroke.color'], parameter);
-  const parameterValue = React.useMemo(() => get(sectionSymbol, parameter), [sectionSymbol, parameter]);
-  const renderLegend = React.useCallback((_ref2, index) => {
-    var _parameterValue$value;
-
-    let {
-      symbol,
-      title,
-      hiddenCondition
-    } = _ref2;
-    if (!symbol) return null;
-    const isClusterFillColor$1 = isClusterFillColor(symbol, parameter);
-    const value = getParameterValue(parameterValue == null ? void 0 : (_parameterValue$value = parameterValue.values[index]) == null ? void 0 : _parameterValue$value.value) || (parameterValue == null ? void 0 : parameterValue.defaultValue);
-    return React__default.createElement(ClassifiedItem, {
-      key: sectionIndex + title + index,
-      isHidden: isHiddenLegend(hiddenCondition, hiddenLegends),
-      isClusterFillColor: isClusterFillColor$1,
-      onClick: () => toggleHiddenLegend == null ? void 0 : toggleHiddenLegend(layerName, hiddenCondition)
-    }, isSize || isStrokeWidth || isStrokeColor ? React__default.createElement(MapLegendItems, {
-      parameter: parameter,
-      isSize: isSize,
-      isStrokeWidth: isStrokeWidth,
-      isStrokeColor: isStrokeColor,
-      isSingle: true
-    }, React__default.createElement(MapLegendItem, {
-      key: "" + title + index,
-      title: title,
-      value: value,
-      parameter: parameter
-    })) : React__default.createElement(SymbolContainer, null, React__default.createElement(LegendSymbolRenderer, {
-      index: index,
-      symbol: isClusterFillColor$1 ? sectionSymbol : getExtractedSymbol(symbol, true)
-    })), getLegendText({
-      title,
-      index,
-      isDate
-    }));
-  }, [parameter, sectionIndex, hiddenLegends, isSize, isStrokeWidth, isStrokeColor, parameterValue, sectionSymbol, isDate, toggleHiddenLegend, layerName]);
-  return React__default.createElement(MaximizedLegendContainer, {
-    ref: innerRef,
-    isShown: isShown
-  }, values.map(renderLegend));
-};
-
-function useCanvas() {
-  const canvas = React.useRef(null);
-  const ref = React.useCallback(node => {
-    if (node !== null) {
-      canvas.current = new Canvas.Canvas(node);
-    } else {
-      canvas.current = null;
-    }
-  }, []);
-  return {
-    canvas,
-    ref
-  };
-}
-
-function useMount(_ref) {
-  let {
-    onMount,
-    onUnmount
-  } = _ref;
-  React.useEffect(() => {
-    onMount && onMount();
-    return onUnmount; // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-}
-
-function useNode() {
-  const [node, onSetNode] = React.useState(null);
-  const ref = React.useCallback(onSetNode, [onSetNode]);
-  return [ref, node];
-}
-
-const DEFAULT_SYMBOL_SIZE$1 = 26;
-function useSymbol(_ref, canvasRef) {
-  let {
-    symbol,
-    size = DEFAULT_SYMBOL_SIZE$1,
-    render = getSymbolRenders,
-    maxWidth
-  } = _ref;
-  React.useEffect(() => {
-    if (canvasRef.current !== null && symbol !== undefined) {
-      const canvas = canvasRef.current;
-      setCanvasSize(canvas, size, maxWidth);
-      render(symbol, size).then(renders => {
-        renderSymbolToCanvas(renders, canvas);
-      });
-    } // eslint-disable-next-line react-hooks/exhaustive-deps
-
-  }, [symbol, size, maxWidth]);
-}
-
-function setCanvasSize(canvas, size, maxWidth) {
-  canvas.node.height = size;
-  canvas.node.width = maxWidth ? Math.min(size, maxWidth) : size;
-}
-
-const useToggle = initial => {
-  const [state, setState] = React.useState(initial !== undefined ? initial : false);
-  const toggle = React.useCallback(() => setState(!state), [state]);
-  return [state, toggle, setState];
-};
-
-const LegendSection = (_ref) => {
-  var _hiddenLegends$layerN, _hiddenLegends$layerN2;
-
-  let {
-    layerName,
-    symbol,
-    parameter,
-    parameters,
-    classified,
-    hiddenLegends,
-    toggleHiddenLegend,
-    clearHiddenLegends,
-    goToClassification,
-    attribute,
-    formatValue,
-    index,
-    count,
-    isShared
-  } = _ref;
-  const {
-    t
-  } = reactI18next.useTranslation("style");
-  const [isExpanded, toggleExpanded] = useToggle();
-  const [maxRef, maxNode] = useNode();
-  const [minRef, minNode] = useNode();
-  if (!layerName || !attribute) return null;
-  const currentSymbol = isCombinedPolylineSymbol(symbol) ? symbol.values[index] : symbol;
-  return React__default.createElement(MapLegendSectionContainer, {
-    hasHiddenLegends: !!(hiddenLegends != null && (_hiddenLegends$layerN = hiddenLegends[layerName]) != null && _hiddenLegends$layerN.length)
-  }, React__default.createElement(MapLegendHeader, null, attribute.alias || attribute.name, React__default.createElement(LegendHeaderButtons, {
-    layerName: layerName,
-    hasHiddenLegends: !!(hiddenLegends != null && (_hiddenLegends$layerN2 = hiddenLegends[layerName]) != null && _hiddenLegends$layerN2.length),
-    clearHiddenLegends: clearHiddenLegends,
-    goToClassification: goToClassification,
-    isShared: isShared
-  })), React__default.createElement(LegendParameterDescription, {
-    parameter: parameter,
-    index: count && index !== undefined ? count - index : 0
-  }), React__default.createElement(MapLegendSectionItems, {
-    minHeight: minNode == null ? void 0 : minNode.offsetHeight,
-    maxHeight: maxNode == null ? void 0 : maxNode.offsetHeight,
-    isExpanded: isExpanded
-  }, React__default.createElement(MaximizedLegend, {
-    innerRef: maxRef,
-    isShown: isExpanded,
-    layerName: layerName,
-    symbol: currentSymbol,
-    hiddenLegends: hiddenLegends == null ? void 0 : hiddenLegends[layerName],
-    toggleHiddenLegend: toggleHiddenLegend,
-    parameter: parameter,
-    attributeType: attribute.type,
-    index: index,
-    values: getMaximizedLegendValues(attribute, parameter, parameters, classified, currentSymbol, formatValue, index, t("other"))
-  }), React__default.createElement(MinimizedLegend, {
-    innerRef: minRef,
-    isShown: !isExpanded,
-    hiddenLegends: hiddenLegends == null ? void 0 : hiddenLegends[layerName],
-    parameter: parameter,
-    values: getMinimizedLegendValues(attribute, classified, formatValue, index, t("other"))
-  })), React__default.createElement(MapLegendExpandButton, {
-    onClick: toggleExpanded
-  }, isExpanded ? t('hide') : t('show')));
-};
-
-const _excluded$1 = ["layerInfo", "formatValue", "hiddenLegends", "toggleHiddenLegend", "clearHiddenLegends", "goToClassification"];
-const Legend = /*#__PURE__*/React.memo((_ref) => {
-  var _layerInfo$style, _layerInfo$style$chil;
-
-  let {
-    layerInfo,
-    formatValue,
-    hiddenLegends,
-    toggleHiddenLegend,
-    clearHiddenLegends,
-    goToClassification
-  } = _ref,
-      rest = _objectWithoutPropertiesLoose(_ref, _excluded$1);
-
-  if (!layerInfo) return null;
-
-  if ((_layerInfo$style = layerInfo.style) != null && (_layerInfo$style$chil = _layerInfo$style.children) != null && _layerInfo$style$chil.length) {
-    return React__default.createElement(LegendChildren, {
-      layerInfo: layerInfo,
-      formatValue: formatValue,
-      hiddenLegends: hiddenLegends,
-      toggleHiddenLegend: toggleHiddenLegend,
-      clearHiddenLegends: clearHiddenLegends,
-      goToClassification: goToClassification
-    });
-  }
-
-  const attributes = getLayerAttributes(layerInfo.layerDefinition);
-  const renderItems = React.useMemo(() => {
-    var _layerInfo$style2, _layerInfo$style3;
-
-    const parameters = SYMBOL_CLASSIFICATION[layerInfo.geometryType];
-    const props = {
-      layerName: layerInfo.name,
-      symbol: (_layerInfo$style2 = layerInfo.style) == null ? void 0 : _layerInfo$style2.symbol,
-      parameters: parameters,
-      formatValue: formatValue,
-      hiddenLegends: hiddenLegends,
-      toggleHiddenLegend: toggleHiddenLegend,
-      clearHiddenLegends: clearHiddenLegends,
-      goToClassification: goToClassification
-    };
-
-    if ((_layerInfo$style3 = layerInfo.style) != null && _layerInfo$style3.symbol && isCombinedPolylineSymbol(layerInfo.style.symbol)) {
-      var _layerInfo$style4, _layerInfo$style4$sym, _layerInfo$style4$sym2;
-
-      const values = (_layerInfo$style4 = layerInfo.style) == null ? void 0 : (_layerInfo$style4$sym = _layerInfo$style4.symbol) == null ? void 0 : (_layerInfo$style4$sym2 = _layerInfo$style4$sym.values) == null ? void 0 : _layerInfo$style4$sym2.reduce((result, symbol, index) => {
-        return [classifyParamsReduce(symbol, parameters, index), ...result];
-      }, []);
-      return React__default.createElement(React__default.Fragment, null, values == null ? void 0 : values.map((value, index) => Object.keys(value).map((param, keyIndex) => {
-        var _item$values$;
-
-        const item = value[param];
-        return React__default.createElement(LegendSection, Object.assign({
-          key: [keyIndex, index].join("-"),
-          index: item == null ? void 0 : item.index,
-          count: values == null ? void 0 : values.length,
-          attribute: getConditionAttribute(attributes, item == null ? void 0 : (_item$values$ = item.values[0]) == null ? void 0 : _item$values$.condition),
-          parameter: param,
-          classified: item
-        }, props, rest));
-      })));
-    }
-
-    const classified = getClassified(layerInfo);
-    if (!classified) return null;
-    return React__default.createElement(React__default.Fragment, null, Object.keys(classified).map((param, keyIndex) => {
-      var _item$values$2;
-
-      const item = classified[param];
-      return React__default.createElement(LegendSection, Object.assign({
-        key: [keyIndex, item.index].join("-"),
-        index: item.index,
-        attribute: getConditionAttribute(attributes, item == null ? void 0 : (_item$values$2 = item.values[0]) == null ? void 0 : _item$values$2.condition),
-        parameter: param,
-        classified: item
-      }, props, rest));
-    }));
-  }, [layerInfo, formatValue, hiddenLegends, toggleHiddenLegend, clearHiddenLegends, goToClassification]);
-  return React__default.createElement(MapLegendContainer, null, renderItems);
-});
-
-const Symbol = (_ref) => {
-  let {
-    symbol,
-    size,
-    render
-  } = _ref;
-  const {
-    canvas,
-    ref
-  } = useCanvas();
-  useSymbol({
-    symbol,
-    size,
-    render
-  }, canvas);
-  return React__default.createElement("canvas", {
-    ref: ref
-  });
-};
-
-var _templateObject$2, _templateObject2$2;
-const CompoundIcon = /*#__PURE__*/styled__default.div(_templateObject$2 || (_templateObject$2 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  background: ", ";\n  height: 32px;\n  width: 32px;\n"])), (_ref) => {
-  let {
-    geometryType,
-    icons
-  } = _ref;
-  return "url(" + icons[geometryType] + ") center center / " + (geometryType === api.GeometryType.Polyline ? '2rem 1.3rem' : 'auto 1rem') + " no-repeat";
-});
-const ClusterSymbol = /*#__PURE__*/styled__default.div(_templateObject2$2 || (_templateObject2$2 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  position: relative;\n  width: 32px;\n  height: 32px;\n\n  :before {\n    content: \"\";\n    position: absolute;\n    top: 0;\n    left: 0;\n    width: inherit;\n    height: inherit;\n    background-color: ", ";\n    border-radius: 50%;\n    opacity: 0.28;\n  }\n  \n  :after {\n    content: \"99\";\n    position: absolute;\n    top: 4px;\n    left: 4px;\n    display: flex;\n    justify-content: center;\n    align-items: center;\n    width: 24px;\n    height: 24px;\n    background-color: ", ";\n    border-radius: 50%;\n    color: white;\n    font-size: 0.75rem;\n    line-height: 1;\n  }\n"])), (_ref2) => {
-  let {
-    color
-  } = _ref2;
-  return color;
-}, (_ref3) => {
-  let {
-    color
-  } = _ref3;
-  return color;
-});
-
-const MAX_SIZE = 32;
-const StyleSymbol = (_ref) => {
-  let {
-    symbol,
-    size = MAX_SIZE,
-    children
-  } = _ref;
-
-  if (children) {
-    return React__default.createElement(React__default.Fragment, null, children);
-  }
-
-  let sGisSymbol = null;
-
-  try {
-    sGisSymbol = deserializeSymbol(symbol);
-  } catch (e) {// TODO generate Error symbol
-  }
-
-  if (!sGisSymbol) {
-    return null;
-  }
-
-  if (isSGisClusterSymbol(symbol)) {
-    var _sGisSymbol$backgroun, _sGisSymbol$figure;
-
-    const color = getParameterValue((_sGisSymbol$backgroun = sGisSymbol.background) == null ? void 0 : _sGisSymbol$backgroun.fillColor) || getParameterValue((_sGisSymbol$figure = sGisSymbol.figure) == null ? void 0 : _sGisSymbol$figure.fillColor) || "rgb(0, 170, 255)";
-    return React__default.createElement(ClusterSymbol, {
-      color: color
-    });
-  }
-
-  return React__default.createElement(Symbol, {
-    symbol: adjustSymbol(sGisSymbol, {
-      size: size - 1
-    }),
-    size: size
-  });
-};
-
-const LegendContext = /*#__PURE__*/React.createContext(null);
-const LegendProvider = (_ref) => {
-  let {
-    symbol,
-    children
-  } = _ref;
-  return React__default.createElement(LegendContext.Provider, {
-    value: symbol || null
-  }, children);
-};
-const useLegendContext = () => React.useContext(LegendContext);
-
-const polygonCircleFromPoint = (center, diameter) => {
-  const coordinates = [];
-  const radius = diameter / 2;
-  const endAngle = Math.PI * 2;
-  const step = Math.max(Math.PI / 2 / radius, endAngle / 128);
-  let start = 0;
-  let end = endAngle;
-
-  for (let ang = start; ang < end; ang += step) {
-    coordinates.push([Math.cos(ang) * radius + center[0], Math.sin(ang) * radius + center[1]]);
-  }
-
-  return [coordinates];
-};
-
-exports.ArrowLineMiterRender = ArrowLineMiterRender;
-exports.BASE_OPERATORS = BASE_OPERATORS;
-exports.BETWEEN_OPERATORS = BETWEEN_OPERATORS;
-exports.CONTAINS_OPERATORS = CONTAINS_OPERATORS;
-exports.CircleLineMiterRender = CircleLineMiterRender;
-exports.ClassificationCondition = ClassificationCondition;
-exports.ClassificationManager = ClassificationManager;
-exports.ClassifiedItem = ClassifiedItem;
-exports.ClusterLegendContainer = ClusterLegendContainer;
-exports.ClusterSymbol = ClusterSymbol;
-exports.ClusterSymbolPreview = ClusterSymbolPreview;
-exports.CompoundIcon = CompoundIcon;
-exports.DEFAULT_CLUSTER_SVG = DEFAULT_CLUSTER_SVG;
-exports.DEFAULT_ID_ATTRIBUTE_NAME = DEFAULT_ID_ATTRIBUTE_NAME;
-exports.DEFAULT_LEGEND_SIZES = DEFAULT_LEGEND_SIZES;
-exports.DEFAULT_LEGEND_STYLES = DEFAULT_LEGEND_STYLES;
-exports.DEFAULT_LEGEND_SYMBOL_SIZE = DEFAULT_LEGEND_SYMBOL_SIZE;
-exports.DEFAULT_PARAMETER_INFO = DEFAULT_PARAMETER_INFO;
-exports.DEFAULT_SYMBOL_FILL_COLOR = DEFAULT_SYMBOL_FILL_COLOR;
-exports.DEFAULT_SYMBOL_OFFSET = DEFAULT_SYMBOL_OFFSET;
-exports.DEFAULT_SYMBOL_SIZE = DEFAULT_SYMBOL_SIZE;
-exports.DEFAULT_SYMBOL_STROKE_COLOR = DEFAULT_SYMBOL_STROKE_COLOR;
-exports.DEFAULT_SYMBOL_WITH_BG_SIZE = DEFAULT_SYMBOL_WITH_BG_SIZE;
-exports.ENDS_WITH_OPERATORS = ENDS_WITH_OPERATORS;
-exports.EXTRA_BORDER_SIZE = EXTRA_BORDER_SIZE;
-exports.EvergisStyle = EvergisStyle;
-exports.FILLED_OPERATORS = FILLED_OPERATORS;
-exports.GEOMETRY_ATTRIBUTE = GEOMETRY_ATTRIBUTE;
-exports.ItemSeparator = ItemSeparator;
-exports.ItemText = ItemText;
-exports.Legend = Legend;
-exports.LegendChildren = LegendChildren;
-exports.LegendHeaderButton = LegendHeaderButton;
-exports.LegendParameterDescription = LegendParameterDescription;
-exports.LegendProvider = LegendProvider;
-exports.LegendSection = LegendSection;
-exports.LegendSymbolRenderer = LegendSymbolRenderer;
-exports.LineMiterRender = LineMiterRender;
-exports.MapLegendBadge = MapLegendBadge;
-exports.MapLegendContainer = MapLegendContainer;
-exports.MapLegendDescription = MapLegendDescription;
-exports.MapLegendDescriptionContainer = MapLegendDescriptionContainer;
-exports.MapLegendExpandButton = MapLegendExpandButton;
-exports.MapLegendHeader = MapLegendHeader;
-exports.MapLegendItem = MapLegendItem;
-exports.MapLegendItems = MapLegendItems;
-exports.MapLegendItemsContainer = MapLegendItemsContainer;
-exports.MapLegendOther = MapLegendOther;
-exports.MapLegendSectionContainer = MapLegendSectionContainer;
-exports.MapLegendSectionItems = MapLegendSectionItems;
-exports.MapLegendValueDescr = MapLegendValueDescr;
-exports.MapLegendValues = MapLegendValues;
-exports.MapLegendValuesOther = MapLegendValuesOther;
-exports.MapLegendValuesRange = MapLegendValuesRange;
-exports.MaximizedLegend = MaximizedLegend;
-exports.MaximizedLegendContainer = MaximizedLegendContainer;
-exports.MinimizedLegend = MinimizedLegend;
-exports.MinimizedLegendContainer = MinimizedLegendContainer;
 exports.NO_CONTENT_VALUE = NO_CONTENT_VALUE;
-exports.OPERATOR_CONDITION_REMAP = OPERATOR_CONDITION_REMAP;
-exports.PARAMETER_INFOS = PARAMETER_INFOS;
-exports.PREVIEW_LIMITS = PREVIEW_LIMITS;
-exports.RANGE_OPERATORS = RANGE_OPERATORS;
-exports.SGisBrushFill = SGisBrushFill;
-exports.SGisImageFill = SGisImageFill;
-exports.SGisPolygonSymbol = SGisPolygonSymbol;
-exports.SGisPolylineSymbol = SGisPolylineSymbol;
-exports.SOLID_INTERVALS = SOLID_INTERVALS;
-exports.STARTS_WITH_OPERATORS = STARTS_WITH_OPERATORS;
-exports.SVGPoly = SVGPoly;
-exports.SYMBOL_CLASSIFICATION = SYMBOL_CLASSIFICATION;
-exports.SYMBOL_LIMITS = SYMBOL_LIMITS;
-exports.SYMBOL_SIZE_PARAMETERS = SYMBOL_SIZE_PARAMETERS;
-exports.SelectedPointSymbol = SelectedPointSymbol;
-exports.SelectedPolySymbol = SelectedPolySymbol;
-exports.ShadowedPointSymbol = ShadowedPointSymbol;
-exports.ShadowedPolySymbol = ShadowedPolySymbol;
-exports.SizeMinimizedLegend = SizeMinimizedLegend;
-exports.SizeMinimizedLegendDown = SizeMinimizedLegendDown;
-exports.SizeMinimizedLegendLabel = SizeMinimizedLegendLabel;
-exports.SizeMinimizedLegendSymbol = SizeMinimizedLegendSymbol;
-exports.SizeMinimizedLegendUp = SizeMinimizedLegendUp;
-exports.SquareLineMiterRender = SquareLineMiterRender;
-exports.StyleSymbol = StyleSymbol;
-exports.SvgSymbol = SvgSymbol;
-exports.Symbol = Symbol;
-exports.SymbolButton = SymbolButton;
-exports.SymbolByType = SymbolByType;
-exports.SymbolContainer = SymbolContainer;
-exports.adjustSymbol = adjustSymbol;
-exports.applyParameterValue = applyParameterValue;
-exports.checkLayerHasLegend = checkLayerHasLegend;
-exports.clamp = clamp;
-exports.classifyParamsReduce = classifyParamsReduce;
-exports.convertSvgToBase64 = convertSvgToBase64;
-exports.copyRings = copyRings;
-exports.createCompositeSymbol = createCompositeSymbol;
-exports.createHiddenCondition = createHiddenCondition;
-exports.createLegendSymbol = createLegendSymbol;
-exports.createOtherHiddenCondition = createOtherHiddenCondition;
-exports.createPointRender = createPointRender;
-exports.createShadowRender = createShadowRender;
-exports.createSvgGradient = createSvgGradient;
-exports.createValueTitle = createValueTitle;
-exports.createValueTitleFromCondition = createValueTitleFromCondition;
-exports.dateComparisonOperators = dateComparisonOperators;
-exports.defineStrokeStylePreset = defineStrokeStylePreset;
-exports.deserializeSymbol = deserializeSymbol;
-exports.extractStyle = extractStyle;
-exports.extractSymbol = extractSymbol;
-exports.findChildFeatureStyle = findChildFeatureStyle;
-exports.findChildFeatureSymbol = findChildFeatureSymbol;
-exports.formatAttributeValue = formatAttributeValue;
 exports.formatDate = formatDate;
-exports.formatRangeClassValue = formatRangeClassValue;
-exports.formatUniqueClassValue = formatUniqueClassValue;
-exports.getAttributeFromCondition = getAttributeFromCondition;
-exports.getAttributeNameFromClassified = getAttributeNameFromClassified;
-exports.getAttributeNameFromCondition = getAttributeNameFromCondition;
-exports.getChildSymbols = getChildSymbols;
-exports.getClassificationValue = getClassificationValue;
-exports.getClassified = getClassified;
-exports.getDashStylePreset = getDashStylePreset;
 exports.getDate = getDate;
-exports.getDimensions = getDimensions;
-exports.getExprFromCondition = getExprFromCondition;
-exports.getExtractedSymbol = getExtractedSymbol;
-exports.getFeatureSymbol = getFeatureSymbol;
-exports.getHexColor = getHexColor;
-exports.getLegendSymbolRenders = getLegendSymbolRenders;
-exports.getLegendSymbolSize = getLegendSymbolSize;
-exports.getLineDash = getLineDash;
-exports.getMapLegendSymbolRenders = getMapLegendSymbolRenders;
-exports.getMaximizedLegendValues = getMaximizedLegendValues;
-exports.getMinimizedLegendValues = getMinimizedLegendValues;
-exports.getOffsetParameterValue = getOffsetParameterValue;
-exports.getParameterFromSymbol = getParameterFromSymbol;
-exports.getParameterValue = getParameterValue;
-exports.getRangeValues = getRangeValues$1;
-exports.getServiceConfiguration = getServiceConfiguration;
-exports.getSignFromConditionPart = getSignFromConditionPart;
-exports.getSimplifiedPolygonCoordinates = getSimplifiedPolygonCoordinates;
-exports.getSymbolParameterInfo = getSymbolParameterInfo;
-exports.getSymbolRenders = getSymbolRenders;
-exports.getSymbolStrokeWidth = getSymbolStrokeWidth;
-exports.getTitleFromCondition = getTitleFromCondition;
-exports.getValueFromConditionPart = getValueFromConditionPart;
-exports.isArrowLineMiter = isArrowLineMiter;
-exports.isCalculatedParameter = isCalculatedParameter;
-exports.isCircleLineMiter = isCircleLineMiter;
-exports.isClusterFillColor = isClusterFillColor;
-exports.isClusterSymbol = isClusterSymbol;
-exports.isCombinedPolylineSymbol = isCombinedPolylineSymbol;
-exports.isCompositeSymbol = isCompositeSymbol;
-exports.isDashedBrush = isDashedBrush;
-exports.isFilledLineMitter = isFilledLineMitter;
-exports.isH3GridSymbol = isH3GridSymbol;
-exports.isHatchBrush = isHatchBrush;
-exports.isImageSymbol = isImageSymbol;
-exports.isLabelSymbol = isLabelSymbol;
-exports.isLayerService = isLayerService;
-exports.isMaskedImageSymbol = isMaskedImageSymbol;
-exports.isMiterExist = isMiterExist;
 exports.isNumeric = isNumeric;
 exports.isObject = isObject;
-exports.isParameterByAttribute = isParameterByAttribute;
-exports.isParameterType = isParameterType;
-exports.isParameterValueSimple = isParameterValueSimple;
-exports.isParameterValueSymbol = isParameterValueSymbol;
-exports.isPatternBrush = isPatternBrush;
-exports.isPointLabelSymbol = isPointLabelSymbol;
-exports.isPointSymbol = isPointSymbol;
-exports.isPolygonHasHatchBrush = isPolygonHasHatchBrush;
-exports.isPolygonHasPatternBrush = isPolygonHasPatternBrush;
-exports.isPolygonLabelSymbol = isPolygonLabelSymbol;
-exports.isPolygonSymbol = isPolygonSymbol;
-exports.isPolylineLabelSymbol = isPolylineLabelSymbol;
-exports.isPolylineSymbols = isPolylineSymbols;
-exports.isRangeClass = isRangeClass;
-exports.isRangeCondition = isRangeCondition;
-exports.isRasterSymbol = isRasterSymbol;
-exports.isRequisiteNumbers = isRequisiteNumbers;
-exports.isSGisClusterSymbol = isSGisClusterSymbol;
-exports.isSGisCombinedPolylineSymbol = isSGisCombinedPolylineSymbol;
-exports.isSGisH3Symbol = isSGisH3Symbol;
-exports.isSGisImageSymbol = isSGisImageSymbol;
-exports.isSGisPointSymbol = isSGisPointSymbol;
-exports.isSGisPolygonSymbol = isSGisPolygonSymbol;
-exports.isSGisPolylineSymbol = isSGisPolylineSymbol;
-exports.isScalablePolylineSymbol = isScalablePolylineSymbol;
-exports.isSimpleOffset = isSimpleOffset;
-exports.isSimplePolylineSymbol = isSimplePolylineSymbol;
-exports.isSimpleSymbol = isSimpleSymbol;
-exports.isSizableSymbol = isSizableSymbol;
-exports.isSizeClassification = isSizeClassification;
-exports.isSolidBrush = isSolidBrush;
-exports.isSquareLineMiter = isSquareLineMiter;
-exports.isSquareSymbol = isSquareSymbol;
-exports.isStaticImageSymbol = isStaticImageSymbol;
-exports.isStringAsInn = isStringAsInn;
-exports.isStringAsKpp = isStringAsKpp;
-exports.isStringAsMail = isStringAsMail;
-exports.isStringAsOgrn = isStringAsOgrn;
-exports.isStringAsPhone = isStringAsPhone;
-exports.isStringAsUrl = isStringAsUrl;
-exports.isStringContainsDate = isStringContainsDate;
-exports.isStringParameterValue = isStringParameterValue;
-exports.isStrokeStyledSymbol = isStrokeStyledSymbol;
-exports.isStyle = isStyle;
-exports.isSvgPointSymbol = isSvgPointSymbol;
-exports.isSymbolWithOffset = isSymbolWithOffset;
-exports.isTwoDimensionalSymbol = isTwoDimensionalSymbol;
-exports.isUniqueClass = isUniqueClass;
-exports.isValidParameter = isValidParameter;
-exports.isValidUrl = isValidUrl;
-exports.mailHref = mailHref;
-exports.manipulateSvgSymbol = manipulateSvgSymbol;
-exports.matchPhone = matchPhone;
-exports.measureAreaSymbol = measureAreaSymbol;
-exports.measureLengthSymbol = measureLengthSymbol;
-exports.measurePolygonSnapSymbol = measurePolygonSnapSymbol;
-exports.metersToPixels = metersToPixels;
-exports.numberComparisonOperators = numberComparisonOperators;
-exports.numberWithSpaces = numberWithSpaces;
-exports.packStyle = packStyle;
-exports.phoneHref = phoneHref;
-exports.polygonCircleFromPoint = polygonCircleFromPoint;
-exports.printRangeClass = printRangeClass;
-exports.renderSymbolToCanvas = renderSymbolToCanvas;
-exports.selectedPoint = selectedPoint;
-exports.selectedPolygon = selectedPolygon;
-exports.selectedPolyline = selectedPolyline;
-exports.serializeSvgPointSymbol = serializeSvgPointSymbol;
-exports.setDefaultParameterValue = setDefaultParameterValue;
-exports.setParameterValue = setParameterValue;
-exports.solidStrokeStylePreset = solidStrokeStylePreset;
-exports.strokeStylePresets = strokeStylePresets;
-exports.symbolParameterWalker = symbolParameterWalker;
-exports.symbolTypeGuard = symbolTypeGuard;
-exports.textComparisonOperators = textComparisonOperators;
-exports.toIntervals = toIntervals;
-exports.toLineDash = toLineDash;
-exports.unClassify = unClassify;
-exports.updateSymbolParameter = updateSymbolParameter;
-exports.urlHref = urlHref;
-exports.useCanvas = useCanvas;
-exports.useLegendContext = useLegendContext;
-exports.useMount = useMount;
-exports.useNode = useNode;
-exports.useSvgSymbol = useSvgSymbol;
-exports.useSymbol = useSymbol;
-exports.useToggle = useToggle;
 //# sourceMappingURL=react.cjs.development.js.map