ts-maps 0.0.0

package/dist/index.js

@@ -0,0 +1,2027 @@
+// src/util/deep-merge.ts
+var deepmerge = function deepmerge2(target, source, options = {}) {
+  options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+  options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+  options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+  const sourceIsArray = Array.isArray(source);
+  const targetIsArray = Array.isArray(target);
+  const sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+  if (!sourceAndTargetTypesMatch) {
+    return cloneUnlessOtherwiseSpecified(source, options);
+  }
+  if (sourceIsArray) {
+    return options.arrayMerge(target, source, options);
+  }
+  return mergeObject(target, source, options);
+};
+function isMergeableObject(value) {
+  return isNonNullObject(value) && !isSpecial(value);
+}
+function isNonNullObject(value) {
+  return !!value && typeof value === "object";
+}
+function isSpecial(value) {
+  const stringValue = Object.prototype.toString.call(value);
+  return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isNode(value) || isReactElement(value);
+}
+var canUseSymbol = typeof Symbol === "function" && Symbol.for;
+var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
+function isReactElement(value) {
+  return value.$$typeof === REACT_ELEMENT_TYPE;
+}
+function isNode(value) {
+  return value instanceof Node;
+}
+function emptyTarget(val) {
+  return Array.isArray(val) ? [] : {};
+}
+function cloneUnlessOtherwiseSpecified(value, options) {
+  const mergeable = (options.isMergeableObject || isMergeableObject)(value);
+  return options.clone !== false && mergeable ? deepmerge(emptyTarget(value), value, options) : value;
+}
+function defaultArrayMerge(target, source, options) {
+  return target.concat(source).map((element) => {
+    return cloneUnlessOtherwiseSpecified(element, options);
+  });
+}
+function getMergeFunction(key, options) {
+  if (!options.customMerge) {
+    return deepmerge;
+  }
+  const customMerge = options.customMerge(key);
+  return typeof customMerge === "function" ? customMerge : deepmerge;
+}
+function getEnumerableOwnPropertySymbols(target) {
+  return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter((symbol) => {
+    return Object.prototype.propertyIsEnumerable.call(target, symbol);
+  }) : [];
+}
+function getKeys(target) {
+  const symbols = getEnumerableOwnPropertySymbols(target);
+  const keys = Object.keys(target);
+  return [...keys, ...symbols];
+}
+function propertyIsOnObject(object, property) {
+  try {
+    return property in object;
+  } catch {
+    return false;
+  }
+}
+function propertyIsUnsafe(target, key) {
+  return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
+}
+function mergeObject(target, source, options) {
+  const destination = {};
+  const mergeableObject = options.isMergeableObject || isMergeableObject;
+  if (mergeableObject(target)) {
+    getKeys(target).forEach((key) => {
+      destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+    });
+  }
+  getKeys(source).forEach((key) => {
+    if (propertyIsUnsafe(target, key)) {
+      return;
+    }
+    if (propertyIsOnObject(target, key) && mergeableObject(source[key])) {
+      destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+    } else {
+      destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+    }
+  });
+  return destination;
+}
+var deep_merge_default = deepmerge;
+
+// src/util/index.ts
+function getElement(selector) {
+  if (typeof selector === "object" && typeof selector.nodeType !== "undefined") {
+    return selector;
+  }
+  if (typeof selector === "string") {
+    return document.querySelector(selector);
+  }
+  return null;
+}
+function createElement(type, classes, content, html = false) {
+  const el = document.createElement(type);
+  if (content) {
+    el[!html ? "textContent" : "innerHTML"] = content;
+  }
+  if (classes) {
+    el.className = classes;
+  }
+  return el;
+}
+function removeElement(target) {
+  target.parentNode?.removeChild(target);
+}
+function isImageUrl(url) {
+  return /\.[jpe?g|ifn]$/i.test(url);
+}
+function hyphenate(str) {
+  return str.replace(/\w([A-Z])/g, (m) => `${m[0]}-${m[1]}`).toLowerCase();
+}
+function merge(target, source, deep = false) {
+  if (deep) {
+    return deep_merge_default(target, source);
+  }
+  return Object.assign({}, target, source);
+}
+function getLineUid(from, to) {
+  return `${from.toLowerCase()}:to:${to.toLowerCase()}`;
+}
+function inherit(target, source) {
+  Object.assign(target.prototype, source);
+}
+
+// src/components/base.ts
+class BaseComponent {
+  _tooltip;
+  shape;
+  dispose() {
+    if (this._tooltip) {
+      removeElement(this._tooltip);
+    } else if (this.shape) {
+      this.shape.remove();
+    }
+    for (const propertyName of Object.getOwnPropertyNames(this)) {
+      this[propertyName] = null;
+    }
+  }
+}
+var base_default = BaseComponent;
+
+// src/components/tooltip.ts
+class Tooltip extends base_default {
+  _map;
+  _tooltip;
+  _hoveredRegion = null;
+  _hoveredMarker = null;
+  _customPositioning = true;
+  constructor(map) {
+    super();
+    this._map = map;
+    this._tooltip = createElement("div", "jvm-tooltip", "");
+    this._tooltip.style.display = "none";
+    this._map.container.appendChild(this._tooltip);
+    return this;
+  }
+  getElement() {
+    return this._tooltip;
+  }
+  show(text) {
+    this._tooltip.style.display = "block";
+    this._tooltip.innerHTML = text;
+    this._tooltip.classList.add("active");
+  }
+  hide() {
+    this._tooltip.style.display = "none";
+    this._tooltip.classList.remove("active");
+    this._hoveredRegion = null;
+    this._hoveredMarker = null;
+  }
+  text(text) {
+    if (this._tooltip) {
+      this._tooltip.innerHTML = text;
+    }
+  }
+  html(html) {
+    if (this._tooltip) {
+      this._tooltip.innerHTML = html;
+    }
+  }
+  css(css) {
+    if (this._customPositioning && (css.top || css.left)) {
+      return this;
+    }
+    for (const style in css) {
+      this._tooltip.style[style] = css[style];
+    }
+    return this;
+  }
+  setHoveredRegion(code) {
+    this._hoveredRegion = code;
+  }
+  getHoveredRegion() {
+    return this._hoveredRegion;
+  }
+  setHoveredMarker(index) {
+    this._hoveredMarker = index;
+  }
+  getHoveredMarker() {
+    return this._hoveredMarker;
+  }
+}
+var tooltip_default = Tooltip;
+
+// src/core/apply-transform.ts
+function applyTransform() {
+  let maxTransX, maxTransY, minTransX, minTransY;
+  if (this._defaultWidth * this.scale <= this._width) {
+    maxTransX = (this._width - this._defaultWidth * this.scale) / (2 * this.scale);
+    minTransX = (this._width - this._defaultWidth * this.scale) / (2 * this.scale);
+  } else {
+    maxTransX = 0;
+    minTransX = (this._width - this._defaultWidth * this.scale) / this.scale;
+  }
+  if (this._defaultHeight * this.scale <= this._height) {
+    maxTransY = (this._height - this._defaultHeight * this.scale) / (2 * this.scale);
+    minTransY = (this._height - this._defaultHeight * this.scale) / (2 * this.scale);
+  } else {
+    maxTransY = 0;
+    minTransY = (this._height - this._defaultHeight * this.scale) / this.scale;
+  }
+  if (this.transY > maxTransY) {
+    this.transY = maxTransY;
+  } else if (this.transY < minTransY) {
+    this.transY = minTransY;
+  }
+  if (this.transX > maxTransX) {
+    this.transX = maxTransX;
+  } else if (this.transX < minTransX) {
+    this.transX = minTransX;
+  }
+  this.canvas.applyTransformParams(this.scale, this.transX, this.transY);
+  if (this._markers) {
+    this._repositionMarkers();
+  }
+  if (this._lines) {
+    this._repositionLines();
+  }
+  this._repositionLabels();
+}
+
+// src/core/coords-to-point.ts
+function coordsToPoint(lat, lng) {
+  const projection = this.params.map?.projection || "mercator";
+  const coords = projection === "mercator" ? this.mercator.convert(lat, lng) : this.miller.convert(lat, lng);
+  if (coords === false) {
+    return false;
+  }
+  const inset = this.getInsetForPoint(coords.x, coords.y);
+  if (!inset) {
+    return false;
+  }
+  const x = inset.leftLng + (coords.x - inset.leftLng) / (inset.rightLng - inset.leftLng) * inset.width;
+  const y = inset.topLat + (coords.y - inset.topLat) / (inset.bottomLat - inset.topLat) * inset.height;
+  return {
+    x,
+    y
+  };
+}
+
+// src/components/line.ts
+var LINE_CLASS = "jvm-line";
+
+class Line extends base_default {
+  _options;
+  _style;
+  constructor(options, style) {
+    super();
+    this._options = options;
+    this._style = style;
+    this._draw();
+  }
+  setStyle(property, value) {
+    this.shape?.setStyle(property, value);
+  }
+  getConfig() {
+    return this._options.config;
+  }
+  _draw() {
+    const { index, group, map, animate } = this._options;
+    const config = {
+      d: this._getDAttribute(),
+      fill: "none",
+      dataIndex: index
+    };
+    this.shape = map.canvas.createPath(config, this._style, group);
+    this.shape?.addClass(LINE_CLASS);
+    if (animate) {
+      this.shape?.setStyle({ animation: true });
+    }
+  }
+  _getDAttribute() {
+    const { x1, y1, x2, y2 } = this._options;
+    return `M${x1},${y1}${this._getQCommand(x1, y1, x2, y2)}${x2},${y2}`;
+  }
+  _getQCommand(x1, y1, x2, y2) {
+    if (!this._options.curvature) {
+      return " ";
+    }
+    const curvature = this._options.curvature || 0.6;
+    const curveX = (x1 + x2) / 2 + curvature * (y2 - y1);
+    const curveY = (y1 + y2) / 2 - curvature * (x2 - x1);
+    return ` Q${curveX},${curveY} `;
+  }
+}
+var line_default = Line;
+
+// src/core/create-lines.ts
+function createLines(lines) {
+  const markers = this._markers || {};
+  const { style, elements: _, ...rest } = this.params.lines || {};
+  let point1 = false;
+  let point2 = false;
+  for (const index in lines) {
+    const lineConfig = lines[index];
+    for (const { config: markerConfig } of Object.values(markers)) {
+      if (markerConfig.name === lineConfig.from) {
+        point1 = this.getMarkerPosition(markerConfig);
+      }
+      if (markerConfig.name === lineConfig.to) {
+        point2 = this.getMarkerPosition(markerConfig);
+      }
+    }
+    if (point1 !== false && point2 !== false) {
+      this._lines = this._lines || {};
+      this._lines[getLineUid(lineConfig.from, lineConfig.to)] = new line_default({
+        index,
+        map: this,
+        group: this._linesGroup,
+        config: lineConfig,
+        x1: point1.x,
+        y1: point1.y,
+        x2: point2.x,
+        y2: point2.y,
+        ...rest
+      }, merge({ initial: style }, { initial: lineConfig.style || {} }, true));
+    }
+  }
+}
+
+// src/components/concerns/interactable.ts
+var Interactable = {
+  getLabelText(key, label) {
+    if (!label) {
+      return;
+    }
+    if (typeof label.render === "function") {
+      const params = [];
+      if (this.constructor.Name === "marker") {
+        params.push(this.getConfig());
+      }
+      params.push(key);
+      return label.render.apply(this, params);
+    }
+    return key;
+  },
+  getLabelOffsets(key, label) {
+    if (label && typeof label.offsets === "function") {
+      return label.offsets(key);
+    }
+    if (label && Array.isArray(label.offsets)) {
+      return label.offsets[key] || [0, 0];
+    }
+    return [0, 0];
+  },
+  setStyle(property, value) {
+    this.shape.setStyle(property, value);
+  },
+  remove() {
+    this.shape.remove();
+    if (this.label) {
+      this.label.remove();
+    }
+  },
+  hover(state) {
+    this._setStatus("isHovered", state);
+  },
+  select(state) {
+    this._setStatus("isSelected", state);
+  },
+  _setStatus(property, state) {
+    this.shape[property] = state;
+    this.shape.updateStyle();
+    this[property] = state;
+    if (this.label) {
+      this.label[property] = state;
+      this.label.updateStyle();
+    }
+  }
+};
+var interactable_default = Interactable;
+
+// src/components/marker.ts
+var NAME = "marker";
+var JVM_PREFIX = "jvm-";
+var MARKER_CLASS = `${JVM_PREFIX}element ${JVM_PREFIX}marker`;
+var MARKER_LABEL_CLASS = `${JVM_PREFIX}element ${JVM_PREFIX}label`;
+
+class Marker extends base_default {
+  _options;
+  _style;
+  _labelX = null;
+  _labelY = null;
+  _offsets = null;
+  _isImage;
+  label;
+  isHovered;
+  isSelected = false;
+  static get Name() {
+    return NAME;
+  }
+  constructor(options, style) {
+    super();
+    this._options = options;
+    this._style = style;
+    this._isImage = !!style.initial.image;
+    this._draw();
+    if (this._options.label) {
+      this._drawLabel();
+    }
+    if (this._isImage) {
+      this.updateLabelPosition();
+    }
+  }
+  getConfig() {
+    return this._options.config;
+  }
+  updateLabelPosition() {
+    const map = this._options.map;
+    if (this.label && this._labelX !== null && this._labelY !== null && this._offsets) {
+      this.label.set({
+        x: this._labelX * map.scale + this._offsets[0] + map.transX * map.scale + 5 + (this._isImage ? (this.shape?.width || 0) / 2 : this.shape?.node?.r?.baseVal?.value || 0),
+        y: this._labelY * map.scale + map.transY * this._options.map.scale + this._offsets[1]
+      });
+    }
+  }
+  _draw() {
+    const { index, map, group, cx, cy } = this._options;
+    const shapeType = this._isImage ? "createImage" : "createCircle";
+    this.shape = map.canvas[shapeType]({ dataIndex: index, cx, cy }, this._style, group);
+    this.shape?.addClass(MARKER_CLASS);
+  }
+  _drawLabel() {
+    const {
+      index,
+      map,
+      label,
+      labelsGroup,
+      cx,
+      cy,
+      config,
+      isRecentlyCreated
+    } = this._options;
+    const labelText = this.getLabelText(index, label);
+    this._labelX = cx / map.scale - map.transX;
+    this._labelY = cy / map.scale - map.transY;
+    this._offsets = isRecentlyCreated && config?.offsets ? config.offsets : this.getLabelOffsets(index, label);
+    this.label = map.canvas.createText({
+      text: labelText,
+      dataIndex: index,
+      x: this._labelX,
+      y: this._labelY,
+      dy: "0.6ex"
+    }, map.params.markerLabelStyle, labelsGroup);
+    this.label.addClass(MARKER_LABEL_CLASS);
+    if (isRecentlyCreated) {
+      this.updateLabelPosition();
+    }
+  }
+  getLabelText(key, label) {
+    if (!label) {
+      return;
+    }
+    if (typeof label.render === "function") {
+      return label.render(this.getConfig(), key);
+    }
+    return key;
+  }
+  getLabelOffsets(key, label) {
+    if (label && typeof label.offsets === "function") {
+      return label.offsets(key);
+    }
+    if (label && Array.isArray(label.offsets)) {
+      return label.offsets[key] || [0, 0];
+    }
+    return [0, 0];
+  }
+  setStyle;
+  remove;
+  hover;
+  select;
+  _setStatus;
+}
+inherit(Marker, interactable_default);
+var marker_default = Marker;
+
+// src/core/create-markers.ts
+function createMarkers(markers = {}, isRecentlyCreated = false) {
+  for (let index in markers) {
+    const config = markers[index];
+    const point = this.getMarkerPosition(config);
+    const uid = config.coords.join(":");
+    if (!point) {
+      continue;
+    }
+    if (isRecentlyCreated) {
+      if (Object.keys(this._markers || {}).filter((i) => this._markers?.[i]._uid === uid).length) {
+        continue;
+      }
+      index = String(Object.keys(this._markers || {}).length);
+    }
+    const marker = new marker_default({
+      index,
+      map: this,
+      label: this.params.labels?.markers ? {} : undefined,
+      labelsGroup: this._markerLabelsGroup,
+      cx: point.x,
+      cy: point.y,
+      group: this._markersGroup,
+      config,
+      isRecentlyCreated
+    }, merge(this.params.markerStyle || {}, { ...config.style || {} }, true));
+    if (this._markers?.[index]) {
+      this.removeMarkers([index]);
+    }
+    this._markers = this._markers || {};
+    this._markers[index] = {
+      _uid: uid,
+      config,
+      element: marker
+    };
+  }
+}
+
+// src/components/region.ts
+class Region extends base_default {
+  _map;
+  labelX = 0;
+  labelY = 0;
+  label;
+  isHovered;
+  isSelected = false;
+  shape;
+  constructor({ map, code, path, style, label, labelStyle, labelsGroup }) {
+    super();
+    this._map = map;
+    this.shape = this._createRegion(path, code, style);
+    const text = this.getLabelText(code, label);
+    if (label && text) {
+      const bbox = this.shape?.getBBox();
+      const offsets = this.getLabelOffsets(code, label);
+      this.labelX = (bbox?.x ?? 0) + (bbox?.width ?? 0) / 2 + offsets[0];
+      this.labelY = (bbox?.y ?? 0) + (bbox?.height ?? 0) / 2 + offsets[1];
+      this.label = this._map.canvas.createText({
+        text,
+        textAnchor: "middle",
+        alignmentBaseline: "central",
+        dataCode: code,
+        x: this.labelX,
+        y: this.labelY
+      }, labelStyle, labelsGroup);
+      this.label.addClass("jvm-region jvm-element");
+    }
+  }
+  _createRegion(path, code, style) {
+    const regionPath = this._map.canvas.createPath({ d: path, dataCode: code }, style);
+    regionPath.addClass("jvm-region jvm-element");
+    return regionPath;
+  }
+  updateLabelPosition() {
+    if (this.label) {
+      this.label.set({
+        x: this.labelX * this._map.scale + this._map.transX * this._map.scale,
+        y: this.labelY * this._map.scale + this._map.transY * this._map.scale
+      });
+    }
+  }
+  getLabelText(key, label) {
+    if (!label) {
+      return;
+    }
+    if (typeof label.render === "function") {
+      return label.render(key);
+    }
+    return key;
+  }
+  getLabelOffsets(key, label) {
+    if (label && typeof label.offsets === "function") {
+      return label.offsets(key);
+    }
+    if (label && Array.isArray(label.offsets)) {
+      return label.offsets[key] || [0, 0];
+    }
+    return [0, 0];
+  }
+  setStyle;
+  remove;
+  hover;
+  select;
+  _setStatus;
+}
+inherit(Region, interactable_default);
+var region_default = Region;
+
+// src/core/create-regions.ts
+function createRegions() {
+  this._regionLabelsGroup = this._regionLabelsGroup || this.canvas.createGroup("jvm-regions-labels-group");
+  for (const code in this._mapData.paths) {
+    const region = new region_default({
+      map: this,
+      code,
+      path: this._mapData.paths[code].path,
+      style: merge({}, this.params.regionStyle || {}),
+      labelStyle: this.params.regionLabelStyle,
+      labelsGroup: this._regionLabelsGroup,
+      label: this.params.labels?.regions ? {} : undefined
+    });
+    this.regions[code] = {
+      element: region
+    };
+  }
+}
+
+// src/legend.ts
+class Legend {
+  _options;
+  _map;
+  _series;
+  _body;
+  constructor(options) {
+    this._options = options;
+    this._map = this._options.map;
+    this._series = this._options.series;
+    this._body = createElement("div", "jvm-legend");
+    if (this._options.cssClass) {
+      this._body.setAttribute("class", this._options.cssClass);
+    }
+    if (options.vertical) {
+      this._map.legendVertical.appendChild(this._body);
+    } else {
+      this._map.legendHorizontal.appendChild(this._body);
+    }
+    this.render();
+  }
+  render() {
+    const ticks = this._series.scale.getTicks();
+    const inner = createElement("div", "jvm-legend-inner");
+    this._body.innerHTML = "";
+    if (this._options.title) {
+      const legendTitle = createElement("div", "jvm-legend-title", this._options.title);
+      this._body.appendChild(legendTitle);
+    }
+    this._body.appendChild(inner);
+    for (let i = 0;i < ticks.length; i++) {
+      const tick = createElement("div", "jvm-legend-tick");
+      const sample = createElement("div", "jvm-legend-tick-sample");
+      switch (this._series.config.attribute) {
+        case "fill":
+          if (isImageUrl(ticks[i].value)) {
+            sample.style.background = `url(${ticks[i].value})`;
+          } else {
+            sample.style.background = ticks[i].value;
+          }
+          break;
+        case "stroke":
+          sample.style.background = ticks[i].value;
+          break;
+        case "image":
+          sample.style.background = `url(${ticks[i].value}) no-repeat center center`;
+          sample.style.backgroundSize = "cover";
+          break;
+      }
+      tick.appendChild(sample);
+      let label = ticks[i].label;
+      if (this._options.labelRender) {
+        label = this._options.labelRender(label);
+      }
+      const tickText = createElement("div", "jvm-legend-tick-text", label);
+      tick.appendChild(tickText);
+      inner.appendChild(tick);
+    }
+  }
+}
+var legend_default = Legend;
+
+// src/scales/ordinal-scale.ts
+class OrdinalScale {
+  _scale;
+  constructor(options) {
+    this._scale = options.scale;
+  }
+  getValue(value) {
+    return this._scale[String(value)];
+  }
+  getTicks() {
+    const ticks = [];
+    for (const key in this._scale) {
+      ticks.push({
+        value: this._scale[key],
+        label: key
+      });
+    }
+    return ticks;
+  }
+}
+var ordinal_scale_default = OrdinalScale;
+
+// src/series.ts
+class Series {
+  _map;
+  _elements;
+  _values;
+  config;
+  scale;
+  legend;
+  constructor(config, elements, map) {
+    this._map = map;
+    this._elements = elements;
+    this._values = config.values || {};
+    this.config = config;
+    this.config.attribute = config.attribute || "fill";
+    if (config.attributes) {
+      this.setAttributes(config.attributes);
+    }
+    if (typeof config.scale === "object") {
+      this.scale = new ordinal_scale_default(config.scale);
+    }
+    if (this.config.legend) {
+      this.legend = new legend_default(merge({ map: this._map, series: this }, this.config.legend));
+    }
+    this.setValues(this._values);
+  }
+  setValues(values) {
+    const attrs = {};
+    for (const key in values) {
+      if (values[key]) {
+        attrs[key] = this.scale.getValue(values[key]);
+      }
+    }
+    this.setAttributes(attrs);
+  }
+  setAttributes(attrs) {
+    for (const code in attrs) {
+      if (this._elements[code]) {
+        this._elements[code].element.setStyle(this.config.attribute || "fill", attrs[code]);
+      }
+    }
+  }
+  clear() {
+    const attrs = {};
+    for (const key in this._values) {
+      if (this._elements[key]) {
+        attrs[key] = this._elements[key].element.shape.style.initial[this.config.attribute || "fill"];
+      }
+    }
+    this.setAttributes(attrs);
+    this._values = {};
+  }
+}
+var series_default = Series;
+
+// src/core/create-series.ts
+function createSeries() {
+  this.series = { markers: [], regions: [] };
+  for (const key in this.params.series) {
+    const seriesKey = key;
+    if (this.params.series[seriesKey]) {
+      for (let i = 0;i < this.params.series[seriesKey].length; i++) {
+        this.series[seriesKey][i] = new series_default(this.params.series[seriesKey][i], seriesKey === "markers" ? this._markers || {} : this.regions, this);
+      }
+    }
+  }
+}
+
+// src/core/get-inset-for-point.ts
+function getInsetForPoint(x, y) {
+  const insets = map_default.maps[this.params.map.name].insets;
+  for (let index = 0;index < insets.length; index++) {
+    const [start, end] = insets[index].bbox;
+    if (x > start.x && x < end.x && y > start.y && y < end.y) {
+      return insets[index];
+    }
+  }
+}
+
+// src/core/get-marker-position.ts
+function getMarkerPosition({ coords }) {
+  if (map_default.maps[this.params.map.name].projection) {
+    return this.coordsToPoint(...coords);
+  }
+  return {
+    x: coords[0] * this.scale + this.transX * this.scale,
+    y: coords[1] * this.scale + this.transY * this.scale
+  };
+}
+
+// src/core/reposition-labels.ts
+function repositionLabels() {
+  const labels = this.params.labels || {};
+  if (labels.regions) {
+    for (const code in this.regions) {
+      const region = this.regions[code];
+      if (region.label) {
+        const x = region.labelX * this.scale + this.transX * this.scale;
+        const y = region.labelY * this.scale + this.transY * this.scale;
+        region.label.set({
+          x: Number.isNaN(x) ? 0 : x,
+          y: Number.isNaN(y) ? 0 : y
+        });
+      }
+    }
+  }
+  if (labels.markers) {
+    for (const index in this._markers) {
+      const marker = this._markers[index];
+      if (marker && typeof marker.updateLabelPosition === "function") {
+        marker.updateLabelPosition();
+      }
+    }
+  }
+}
+
+// src/core/reposition-lines.ts
+function repositionLines() {
+  const curvature = this.params.lines?.curvature || 0.5;
+  Object.values(this._lines || {}).forEach((line) => {
+    const startMarker = Object.values(this._markers || {}).find(({ config }) => config.name === line.getConfig().from);
+    const endMarker = Object.values(this._markers || {}).find(({ config }) => config.name === line.getConfig().to);
+    if (startMarker && endMarker) {
+      const point1 = this.getMarkerPosition(startMarker.config);
+      const point2 = this.getMarkerPosition(endMarker.config);
+      if (point1 && point2) {
+        const { x: x1, y: y1 } = point1;
+        const { x: x2, y: y2 } = point2;
+        const midX = (x1 + x2) / 2;
+        const midY = (y1 + y2) / 2;
+        const curveX = midX + curvature * (y2 - y1);
+        const curveY = midY - curvature * (x2 - x1);
+        line.setStyle({
+          d: `M${x1},${y1} Q${curveX},${curveY} ${x2},${y2}`
+        });
+      }
+    }
+  });
+}
+
+// src/core/reposition-markers.ts
+function repositionMarkers() {
+  if (!this._markers)
+    return;
+  for (const index in this._markers) {
+    const marker = this._markers[index];
+    if (!marker || !marker.shape)
+      continue;
+    const point = this.getMarkerPosition(marker.config);
+    if (point !== false) {
+      const cx = Number.isNaN(point.x) ? 0 : point.x;
+      const cy = Number.isNaN(point.y) ? 0 : point.y;
+      marker.shape.set({
+        cx,
+        cy
+      });
+      if (marker.label) {
+        marker.updateLabelPosition();
+      }
+    }
+  }
+}
+
+// src/core/resize.ts
+function resize() {
+  const curBaseScale = this._baseScale;
+  if (this._width / this._height > this._defaultWidth / this._defaultHeight) {
+    this._baseScale = this._height / this._defaultHeight;
+    this._baseTransX = Math.abs(this._width - this._defaultWidth * this._baseScale) / (2 * this._baseScale);
+  } else {
+    this._baseScale = this._width / this._defaultWidth;
+    this._baseTransY = Math.abs(this._height - this._defaultHeight * this._baseScale) / (2 * this._baseScale);
+  }
+  this.scale *= this._baseScale / curBaseScale;
+  this.transX *= this._baseScale / curBaseScale;
+  this.transY *= this._baseScale / curBaseScale;
+}
+var resize_default = resize;
+
+// src/core/set-focus.ts
+function setFocus(config = {}) {
+  let bbox;
+  let codes = [];
+  if (config.region) {
+    codes.push(config.region);
+  } else if (config.regions) {
+    codes = config.regions;
+  }
+  if (codes.length) {
+    codes.forEach((code) => {
+      if (this.regions[code]) {
+        const itemBbox = this.regions[code].element.shape.getBBox();
+        if (itemBbox) {
+          if (typeof bbox === "undefined") {
+            bbox = itemBbox;
+          } else {
+            bbox = {
+              x: Math.min(bbox.x, itemBbox.x),
+              y: Math.min(bbox.y, itemBbox.y),
+              width: Math.max(bbox.x + bbox.width, itemBbox.x + itemBbox.width) - Math.min(bbox.x, itemBbox.x),
+              height: Math.max(bbox.y + bbox.height, itemBbox.y + itemBbox.height) - Math.min(bbox.y, itemBbox.y)
+            };
+          }
+        }
+      }
+    });
+    if (bbox) {
+      return this._setScale(Math.min(this._width / bbox.width, this._height / bbox.height), -(bbox.x + bbox.width / 2), -(bbox.y + bbox.height / 2), true, config.animate);
+    }
+  } else if (config.coords) {
+    const point = this.coordsToPoint(config.coords[0], config.coords[1]);
+    if (point) {
+      const x = this.transX - point.x / this.scale;
+      const y = this.transY - point.y / this.scale;
+      return this._setScale(config.scale ? config.scale * this._baseScale : this._baseScale, x, y, true, config.animate);
+    }
+  }
+}
+
+// src/defaults/events.ts
+var events = {
+  onLoaded: "map:loaded",
+  onViewportChange: "viewport:changed",
+  onRegionClick: "region:clicked",
+  onMarkerClick: "marker:clicked",
+  onRegionSelected: "region:selected",
+  onMarkerSelected: "marker:selected",
+  onRegionTooltipShow: "region.tooltip:show",
+  onMarkerTooltipShow: "marker.tooltip:show",
+  onDestroyed: "map:destroyed"
+};
+var events_default = events;
+
+// src/core/set-scale.ts
+function setScale(scale, anchorX, anchorY, isCentered, animate) {
+  let zoomStep;
+  let interval;
+  let i = 0;
+  const count = Math.abs(Math.round((scale - this.scale) * 60 / Math.max(scale, this.scale)));
+  let scaleStart;
+  let scaleDiff;
+  let transXStart;
+  let transXDiff;
+  let transYStart;
+  let transYDiff;
+  let transX = this.transX;
+  let transY = this.transY;
+  const zoomMax = this.params.zoomMax ?? 8;
+  const zoomMin = this.params.zoomMin ?? 1;
+  if (scale > zoomMax * this._baseScale) {
+    scale = zoomMax * this._baseScale;
+  } else if (scale < zoomMin * this._baseScale) {
+    scale = zoomMin * this._baseScale;
+  }
+  if (typeof anchorX !== "undefined" && typeof anchorY !== "undefined") {
+    zoomStep = scale / this.scale;
+    if (isCentered) {
+      transX = anchorX + this._defaultWidth * (this._width / (this._defaultWidth * scale)) / 2;
+      transY = anchorY + this._defaultHeight * (this._height / (this._defaultHeight * scale)) / 2;
+    } else {
+      transX = this.transX - (zoomStep - 1) / scale * anchorX;
+      transY = this.transY - (zoomStep - 1) / scale * anchorY;
+    }
+  }
+  if (animate && count > 0) {
+    scaleStart = this.scale;
+    scaleDiff = (scale - scaleStart) / count;
+    transXStart = this.transX * this.scale;
+    transYStart = this.transY * this.scale;
+    transXDiff = (transX * scale - transXStart) / count;
+    transYDiff = (transY * scale - transYStart) / count;
+    interval = setInterval(() => {
+      i += 1;
+      this.scale = scaleStart + scaleDiff * i;
+      this.transX = (transXStart + transXDiff * i) / this.scale;
+      this.transY = (transYStart + transYDiff * i) / this.scale;
+      this._applyTransform();
+      if (i === count) {
+        clearInterval(interval);
+        this._emit(events_default.onViewportChange, [
+          this.scale,
+          this.transX,
+          this.transY
+        ]);
+      }
+    }, 10);
+  } else {
+    this.transX = transX;
+    this.transY = transY;
+    this.scale = scale;
+    this._applyTransform();
+    this._emit(events_default.onViewportChange, [
+      this.scale,
+      this.transX,
+      this.transY
+    ]);
+  }
+}
+
+// src/event-handler.ts
+var eventRegistry = {};
+var eventUid = 1;
+var EventHandler = {
+  on(element, event, handler, options = {}) {
+    const uid = `jvm:${event}::${eventUid++}`;
+    eventRegistry[uid] = {
+      selector: element,
+      handler
+    };
+    if (typeof handler === "function") {
+      handler._uid = uid;
+    } else {
+      handler._uid = uid;
+    }
+    element.addEventListener(event, handler, options);
+  },
+  delegate(element, event, selector, handler) {
+    const events2 = event.split(" ");
+    events2.forEach((eventName) => {
+      EventHandler.on(element, eventName, (e) => {
+        const target = e.target;
+        if (target && target.matches && target.matches(selector)) {
+          handler.call(target, e);
+        }
+      });
+    });
+  },
+  off(element, event, handler) {
+    const eventType = event.split(":")[1];
+    element.removeEventListener(eventType, handler);
+    delete eventRegistry[handler._uid];
+  },
+  flush() {
+    Object.keys(eventRegistry).forEach((event) => {
+      EventHandler.off(eventRegistry[event].selector, event, eventRegistry[event].handler);
+    });
+  },
+  getEventRegistry() {
+    return eventRegistry;
+  }
+};
+var event_handler_default = EventHandler;
+
+// src/core/setup-container-events.ts
+function setupContainerEvents() {
+  let mouseDown = false;
+  let oldPageX;
+  let oldPageY;
+  if (this.params.draggable) {
+    event_handler_default.on(this.container, "mousemove", (e) => {
+      if (!mouseDown) {
+        return false;
+      }
+      const mouseEvent = e;
+      if (oldPageX !== undefined && oldPageY !== undefined) {
+        this.transX -= (oldPageX - mouseEvent.pageX) / this.scale;
+        this.transY -= (oldPageY - mouseEvent.pageY) / this.scale;
+        this.canvas.applyTransformParams(this.scale, this.transX, this.transY);
+      }
+      oldPageX = mouseEvent.pageX;
+      oldPageY = mouseEvent.pageY;
+    });
+    event_handler_default.on(this.container, "mousedown", (e) => {
+      mouseDown = true;
+      const mouseEvent = e;
+      oldPageX = mouseEvent.pageX;
+      oldPageY = mouseEvent.pageY;
+      return false;
+    });
+    event_handler_default.on(document.body, "mouseup", () => {
+      mouseDown = false;
+    });
+  }
+  if (this.params.zoomOnScroll) {
+    event_handler_default.on(this.container, "wheel", (e) => {
+      const wheelEvent = e;
+      const deltaY = ((wheelEvent.deltaY || 0) >> 10 || 1) * 75;
+      const rect = this.container.getBoundingClientRect();
+      const offsetX = wheelEvent.pageX - rect.left - window.scrollX;
+      const offsetY = wheelEvent.pageY - rect.top - window.scrollY;
+      const zoomStep = (1 + (this.params.zoomOnScrollSpeed || 3) / 1000) ** (-1.5 * deltaY);
+      setScale.call(this, this.scale * zoomStep, offsetX, offsetY);
+      e.preventDefault();
+    });
+  }
+}
+
+// src/core/setup-container-touch-events.ts
+function setupContainerTouchEvents() {
+  let touchStartScale = 1;
+  let touchStartDistance = 0;
+  let centerTouchX = 0;
+  let centerTouchY = 0;
+  let lastTouchesLength = 0;
+  let touchStartX = 0;
+  let touchStartY = 0;
+  let offset = { top: 0, left: 0 };
+  const handleTouchEvent = (e) => {
+    const touches = e.touches;
+    let currentScale = this.scale;
+    if (touches.length === 1) {
+      if (lastTouchesLength === 1) {
+        const touch = touches[0];
+        if (touchStartScale === currentScale) {
+          this.transX -= (touchStartX - touch.pageX) / currentScale;
+          this.transY -= (touchStartY - touch.pageY) / currentScale;
+          this.canvas.applyTransformParams(currentScale, this.transX, this.transY);
+        }
+        touchStartX = touch.pageX;
+        touchStartY = touch.pageY;
+      }
+    } else if (touches.length === 2) {
+      if (lastTouchesLength === 2) {
+        currentScale = Math.sqrt((touches[0].pageX - touches[1].pageX) ** 2 + (touches[0].pageY - touches[1].pageY) ** 2) / touchStartDistance;
+        setScale.call(this, touchStartScale * currentScale, centerTouchX, centerTouchY, false, false);
+        e.preventDefault();
+      } else {
+        const rect = this.container.getBoundingClientRect();
+        offset = {
+          top: rect.top + window.scrollY,
+          left: rect.left + window.scrollX
+        };
+        centerTouchX = touches[0].pageX > touches[1].pageX ? touches[1].pageX + (touches[0].pageX - touches[1].pageX) / 2 : touches[0].pageX + (touches[1].pageX - touches[0].pageX) / 2;
+        centerTouchY = touches[0].pageY > touches[1].pageY ? touches[1].pageY + (touches[0].pageY - touches[1].pageY) / 2 : touches[0].pageY + (touches[1].pageY - touches[0].pageY) / 2;
+        centerTouchX -= offset.left;
+        centerTouchY -= offset.top;
+        touchStartScale = this.scale;
+        touchStartDistance = Math.sqrt((touches[0].pageX - touches[1].pageX) ** 2 + (touches[0].pageY - touches[1].pageY) ** 2);
+      }
+    }
+    lastTouchesLength = touches.length;
+  };
+  event_handler_default.on(this.container, "touchstart", handleTouchEvent);
+  event_handler_default.on(this.container, "touchmove", handleTouchEvent);
+}
+
+// src/core/setup-element-events.ts
+function parseEvent(map, selector, isTooltip) {
+  const element = getElement(selector);
+  const type = !element?.getAttribute("class")?.includes("jvm-region") ? "marker" : "region";
+  const isRegion = type === "region";
+  const code = isRegion ? element?.getAttribute("data-code") : element?.getAttribute("data-index");
+  if (!code) {
+    throw new Error("Element does not have required data attribute");
+  }
+  let event = isRegion ? events_default.onRegionSelected : events_default.onMarkerSelected;
+  if (isTooltip) {
+    event = isRegion ? events_default.onRegionTooltipShow : events_default.onMarkerTooltipShow;
+  }
+  const elementObj = isRegion ? map.regions[code] : map._markers?.[code];
+  if (!elementObj) {
+    throw new Error(`Element with code ${code} not found`);
+  }
+  return {
+    type,
+    code,
+    event,
+    element: elementObj,
+    tooltipText: isRegion ? map._mapData.paths[code].name || "" : map._markers?.[code]?.config.name || ""
+  };
+}
+function setupElementEvents() {
+  const container = this.container;
+  let pageX;
+  let pageY;
+  let mouseMoved = false;
+  event_handler_default.on(container, "mousemove", (e) => {
+    const mouseEvent = e;
+    if (Math.abs((pageX || 0) - mouseEvent.pageX) + Math.abs((pageY || 0) - mouseEvent.pageY) > 2) {
+      mouseMoved = true;
+    }
+  });
+  event_handler_default.delegate(container, "mousedown", ".jvm-element", (e) => {
+    const mouseEvent = e;
+    pageX = mouseEvent.pageX;
+    pageY = mouseEvent.pageY;
+    mouseMoved = false;
+  });
+  event_handler_default.delegate(container, "mouseover mouseout", ".jvm-element", (e) => {
+    try {
+      const data = parseEvent(this, e.target, true);
+      const { showTooltip } = this.params;
+      const tooltip = this._tooltip;
+      if (e.type === "mouseover") {
+        if (typeof data.element.hover === "function") {
+          data.element.hover(true);
+        }
+        if (showTooltip && tooltip) {
+          tooltip.text(data.tooltipText);
+          tooltip.show(data.tooltipText);
+          this._emit(data.event, [e, tooltip.getElement(), data.code]);
+        }
+      } else {
+        if (typeof data.element.hover === "function") {
+          data.element.hover(false);
+        }
+        if (showTooltip && tooltip) {
+          tooltip.hide();
+        }
+      }
+    } catch (error) {
+      console.error("Error in mouseover/mouseout handler:", error);
+    }
+  });
+  event_handler_default.delegate(container, "mouseup", ".jvm-element", (e) => {
+    try {
+      const data = parseEvent(this, e.target, false);
+      if (mouseMoved) {
+        return;
+      }
+      if (data.type === "region" && this.params.regionsSelectable || data.type === "marker" && this.params.markersSelectable) {
+        const element = data.element;
+        if (this.params[`${data.type}sSelectableOne`]) {
+          data.type === "region" ? this.clearSelectedRegions() : this.clearSelectedMarkers();
+        }
+        if (typeof element.select === "function") {
+          if (element.isSelected) {
+            element.select(false);
+          } else {
+            element.select(true);
+          }
+          this._emit(data.event, [
+            data.code,
+            element.isSelected,
+            data.type === "region" ? this.getSelectedRegions() : this.getSelectedMarkers()
+          ]);
+        }
+      }
+    } catch (error) {
+      console.error("Error in mouseup handler:", error);
+    }
+  });
+  event_handler_default.delegate(container, "click", ".jvm-element", (e) => {
+    try {
+      const { type, code } = parseEvent(this, e.target, false);
+      this._emit(type === "region" ? events_default.onRegionClick : events_default.onMarkerClick, [e, code]);
+    } catch (error) {
+      console.error("Error in click handler:", error);
+    }
+  });
+}
+
+// src/core/setup-zoom-buttons.ts
+function setupZoomButtons() {
+  const zoomin = createElement("div", "jvm-zoom-btn jvm-zoomin", "&#43;", true);
+  const zoomout = createElement("div", "jvm-zoom-btn jvm-zoomout", "&#x2212", true);
+  this.container.appendChild(zoomin);
+  this.container.appendChild(zoomout);
+  const handler = (zoomin2 = true) => {
+    return () => setScale.call(this, zoomin2 ? this.scale * (this.params.zoomStep || 1.5) : this.scale / (this.params.zoomStep || 1.5), this._width / 2, this._height / 2, false, this.params.zoomAnimate);
+  };
+  event_handler_default.on(zoomin, "click", handler());
+  event_handler_default.on(zoomout, "click", handler(false));
+}
+
+// src/core/update-size.ts
+function updateSize() {
+  this._width = this.container.offsetWidth;
+  this._height = this.container.offsetHeight;
+  resize_default.call(this);
+  this.canvas.applyTransformParams(this.scale, this.transX, this.transY);
+}
+
+// src/core/index.ts
+var core = {
+  _setupContainerEvents: setupContainerEvents,
+  _setupElementEvents: setupElementEvents,
+  _setupZoomButtons: setupZoomButtons,
+  _setupContainerTouchEvents: setupContainerTouchEvents,
+  _createRegions: createRegions,
+  _createLines: createLines,
+  _createMarkers: createMarkers,
+  _createSeries: createSeries,
+  _applyTransform: applyTransform,
+  _resize: resize_default,
+  _setScale: setScale,
+  setFocus,
+  updateSize,
+  coordsToPoint,
+  getInsetForPoint,
+  getMarkerPosition,
+  _repositionLines: repositionLines,
+  _repositionMarkers: repositionMarkers,
+  _repositionLabels: repositionLabels
+};
+var core_default = core;
+
+// src/data-visualization.ts
+class DataVisualization {
+  _scale;
+  _values;
+  _fromColor;
+  _toColor;
+  _map;
+  min = Number.MAX_VALUE;
+  max = 0;
+  constructor({ scale, values }, map) {
+    this._scale = scale;
+    this._values = values;
+    this._fromColor = this.hexToRgb(scale[0]);
+    this._toColor = this.hexToRgb(scale[1]);
+    this._map = map;
+    this.setMinMaxValues(values);
+    this.visualize();
+  }
+  setMinMaxValues(values) {
+    for (const key in values) {
+      const value = Number.parseFloat(String(values[key]));
+      if (value > this.max) {
+        this.max = value;
+      }
+      if (value < this.min) {
+        this.min = value;
+      }
+    }
+  }
+  visualize() {
+    const attrs = {};
+    let value;
+    for (const regionCode in this._values) {
+      value = Number.parseFloat(String(this._values[regionCode]));
+      if (!Number.isNaN(value)) {
+        attrs[regionCode] = this.getValue(value);
+      }
+    }
+    this.setAttributes(attrs);
+  }
+  setAttributes(attrs) {
+    for (const code in attrs) {
+      if (this._map.regions[code]) {
+        this._map.regions[code].element.setStyle("fill", attrs[code]);
+      }
+    }
+  }
+  getValue(value) {
+    if (this.min === this.max) {
+      return `#${this._toColor.join("")}`;
+    }
+    let hex;
+    let color = "#";
+    for (let i = 0;i < 3; i++) {
+      hex = Math.round(this._fromColor[i] + (this._toColor[i] - this._fromColor[i]) * ((value - this.min) / (this.max - this.min))).toString(16);
+      color += (hex.length === 1 ? "0" : "") + hex;
+    }
+    return color;
+  }
+  hexToRgb(h) {
+    let r = "0";
+    let g = "0";
+    let b = "0";
+    if (h.length === 4) {
+      r = `0x${h[1]}${h[1]}`;
+      g = `0x${h[2]}${h[2]}`;
+      b = `0x${h[3]}${h[3]}`;
+    } else if (h.length === 7) {
+      r = `0x${h[1]}${h[2]}`;
+      g = `0x${h[3]}${h[4]}`;
+      b = `0x${h[5]}${h[6]}`;
+    }
+    return [Number.parseInt(r, 16), Number.parseInt(g, 16), Number.parseInt(b, 16)];
+  }
+}
+var data_visualization_default = DataVisualization;
+
+// src/defaults/options.ts
+var defaultOptions = {
+  map: {
+    name: "world",
+    projection: "mercator"
+  },
+  backgroundColor: "transparent",
+  draggable: true,
+  zoomButtons: true,
+  zoomOnScroll: true,
+  zoomOnScrollSpeed: 3,
+  zoomMax: 12,
+  zoomMin: 1,
+  zoomAnimate: true,
+  showTooltip: true,
+  zoomStep: 1.5,
+  bindTouchEvents: true,
+  selector: "",
+  lines: {
+    style: {
+      stroke: "#808080",
+      strokeWidth: 1,
+      strokeLinecap: "round"
+    },
+    elements: []
+  },
+  markersSelectable: false,
+  markersSelectableOne: false,
+  markerStyle: {
+    initial: {
+      r: 7,
+      fill: "#374151",
+      fillOpacity: 1,
+      stroke: "#FFF",
+      strokeWidth: 5,
+      strokeOpacity: 0.5
+    },
+    hover: {
+      fill: "#3cc0ff",
+      cursor: "pointer"
+    },
+    selected: {
+      fill: "blue"
+    },
+    selectedHover: {}
+  },
+  markerLabelStyle: {
+    initial: {
+      fontFamily: "Verdana",
+      fontSize: 12,
+      fontWeight: 500,
+      cursor: "default",
+      fill: "#374151"
+    },
+    hover: {
+      cursor: "pointer"
+    },
+    selected: {},
+    selectedHover: {}
+  },
+  regionsSelectable: false,
+  regionsSelectableOne: false,
+  regionStyle: {
+    initial: {
+      fill: "#dee2e8",
+      fillOpacity: 1,
+      stroke: "none",
+      strokeWidth: 0
+    },
+    hover: {
+      fillOpacity: 0.7,
+      cursor: "pointer"
+    },
+    selected: {
+      fill: "#9ca3af"
+    },
+    selectedHover: {}
+  },
+  regionLabelStyle: {
+    initial: {
+      fontFamily: "Verdana",
+      fontSize: "12",
+      fontWeight: "bold",
+      cursor: "default",
+      fill: "#35373e"
+    },
+    hover: {
+      cursor: "pointer"
+    }
+  }
+};
+var options_default = defaultOptions;
+
+// src/svg/base-element.ts
+class SVGElement {
+  node;
+  style;
+  constructor(name, config) {
+    this.node = this._createElement(name);
+    this.style = { initial: {} };
+    if (config) {
+      this.set(config);
+    }
+  }
+  _createElement(tagName) {
+    return document.createElementNS("http://www.w3.org/2000/svg", tagName);
+  }
+  addClass(className) {
+    this.node.setAttribute("class", className);
+  }
+  getBBox() {
+    return this.node.getBBox();
+  }
+  set(property, value) {
+    if (typeof property === "object") {
+      for (const attr in property) {
+        this.applyAttr(attr, property[attr]);
+      }
+    } else if (value !== undefined) {
+      this.applyAttr(property, value);
+    }
+  }
+  get(property) {
+    return this.style.initial[property];
+  }
+  applyAttr(property, value) {
+    this.node.setAttribute(hyphenate(property), String(value));
+  }
+  remove() {
+    removeElement(this.node);
+  }
+}
+var base_element_default = SVGElement;
+
+// src/svg/shape-element.ts
+class SVGShapeElement extends base_element_default {
+  isHovered;
+  isSelected;
+  style;
+  constructor(name, config, style = { initial: {} }) {
+    super(name, config);
+    this.isHovered = false;
+    this.isSelected = false;
+    this.style = style;
+    this.style.current = {};
+    this.updateStyle();
+  }
+  hover(state) {
+    this.isHovered = state;
+    this.updateStyle();
+  }
+  select(state) {
+    this.isSelected = state;
+    this.updateStyle();
+  }
+  setStyle(property, value) {
+    if (typeof property === "object") {
+      merge(this.style.current, property);
+    } else {
+      merge(this.style.current, { [property]: value });
+    }
+    this.updateStyle();
+  }
+  updateStyle() {
+    const attrs = {};
+    merge(attrs, this.style.initial);
+    merge(attrs, this.style.current || {});
+    if (this.isHovered) {
+      merge(attrs, this.style.hover || {});
+    }
+    if (this.isSelected) {
+      merge(attrs, this.style.selected || {});
+      if (this.isHovered) {
+        merge(attrs, this.style.selectedHover || {});
+      }
+    }
+    this.set(attrs);
+  }
+}
+var shape_element_default = SVGShapeElement;
+
+// src/svg/image-element.ts
+class SVGImageElement extends shape_element_default {
+  width = 0;
+  height = 0;
+  cx = 0;
+  cy = 0;
+  offset = [0, 0];
+  constructor(config, style) {
+    super("image", config, style);
+  }
+  applyAttr(attr, value) {
+    let imageUrl;
+    if (attr === "image") {
+      if (typeof value === "object") {
+        const config = value;
+        imageUrl = config.url || "";
+        this.offset = config.offset || [0, 0];
+      } else {
+        imageUrl = String(value);
+        this.offset = [0, 0];
+      }
+      this.node.setAttributeNS("http://www.w3.org/1999/xlink", "href", imageUrl);
+      this.width = 23;
+      this.height = 23;
+      this.applyAttr("width", this.width);
+      this.applyAttr("height", this.height);
+      this.applyAttr("x", this.cx - this.width / 2 + this.offset[0]);
+      this.applyAttr("y", this.cy - this.height / 2 + this.offset[1]);
+    } else if (attr === "cx") {
+      this.cx = Number(value);
+      if (this.width) {
+        this.applyAttr("x", this.cx - this.width / 2 + this.offset[0]);
+      }
+    } else if (attr === "cy") {
+      this.cy = Number(value);
+      if (this.height) {
+        this.applyAttr("y", this.cy - this.height / 2 + this.offset[1]);
+      }
+    } else {
+      super.applyAttr(attr, value);
+    }
+  }
+}
+var image_element_default = SVGImageElement;
+
+// src/svg/text-element.ts
+class SVGTextElement extends shape_element_default {
+  constructor(config, style) {
+    super("text", config, style);
+  }
+  applyAttr(attr, value) {
+    if (attr === "text") {
+      this.node.textContent = String(value);
+    } else if (attr === "x" || attr === "y" || attr === "cx" || attr === "cy") {
+      this.node.setAttribute(attr, `${value}`);
+    } else {
+      super.applyAttr(attr, value);
+    }
+  }
+}
+var text_element_default = SVGTextElement;
+
+// src/svg/canvas-element.ts
+class SVGCanvasElement extends base_element_default {
+  _container;
+  _defsElement;
+  _rootElement;
+  constructor(container) {
+    super("svg");
+    this._container = container;
+    this._defsElement = new base_element_default("defs");
+    this._rootElement = new base_element_default("g", { id: "jvm-regions-group" });
+    this.node.appendChild(this._defsElement.node);
+    this.node.appendChild(this._rootElement.node);
+    this._container.appendChild(this.node);
+  }
+  setSize(width, height) {
+    this.node.setAttribute("width", String(width));
+    this.node.setAttribute("height", String(height));
+  }
+  applyTransformParams(scale, transX, transY) {
+    this._rootElement.node.setAttribute("transform", `scale(${scale}) translate(${transX}, ${transY})`);
+  }
+  createPath(config, style, group) {
+    const path = new shape_element_default("path", config, style);
+    path.node.setAttribute("fill-rule", "evenodd");
+    return this._add(path, group);
+  }
+  createCircle(config, style, group) {
+    const circle = new shape_element_default("circle", config, style);
+    return this._add(circle, group);
+  }
+  createLine(config, style, group) {
+    const line = new shape_element_default("line", config, style);
+    return this._add(line, group);
+  }
+  createText(config, style, group) {
+    const text = new text_element_default(config, style);
+    return this._add(text, group);
+  }
+  createImage(config, style, group) {
+    const image = new image_element_default(config, style);
+    return this._add(image, group);
+  }
+  createGroup(id) {
+    const group = new base_element_default("g");
+    this.node.appendChild(group.node);
+    if (id) {
+      group.node.id = id;
+    }
+    group.canvas = this;
+    return group;
+  }
+  _add(element, group) {
+    group = group || this._rootElement;
+    if (group && group.node) {
+      group.node.appendChild(element.node);
+    } else {
+      this._rootElement.node.appendChild(element.node);
+    }
+    return element;
+  }
+}
+var canvas_element_default = SVGCanvasElement;
+
+// src/map.ts
+var JVM_PREFIX2 = "jvm-";
+var CONTAINER_CLASS = `${JVM_PREFIX2}container`;
+var MARKERS_GROUP_ID = `${JVM_PREFIX2}markers-group`;
+var MARKERS_LABELS_GROUP_ID = `${JVM_PREFIX2}markers-labels-group`;
+var LINES_GROUP_ID = `${JVM_PREFIX2}lines-group`;
+var SERIES_CONTAINER_CLASS = `${JVM_PREFIX2}series-container`;
+var SERIES_CONTAINER_H_CLASS = `${SERIES_CONTAINER_CLASS} ${JVM_PREFIX2}series-h`;
+var SERIES_CONTAINER_V_CLASS = `${SERIES_CONTAINER_CLASS} ${JVM_PREFIX2}series-v`;
+
+class Map {
+  static maps = {};
+  static defaults = options_default;
+  params;
+  regions = {};
+  scale = 1;
+  transX = 0;
+  transY = 0;
+  container;
+  canvas;
+  dataVisualization;
+  legendHorizontal;
+  legendVertical;
+  series = { markers: [], regions: [] };
+  _mapData;
+  _markers = {};
+  _lines = {};
+  _defaultWidth;
+  _defaultHeight;
+  _height = 0;
+  _width = 0;
+  _baseScale = 1;
+  _baseTransX = 0;
+  _baseTransY = 0;
+  _tooltip;
+  _linesGroup;
+  _markersGroup;
+  _markerLabelsGroup;
+  _canvasImpl;
+  constructor(options = {}) {
+    this.params = merge(Map.defaults, options, true);
+    const mapParam = this.params.map;
+    const mapName = typeof mapParam === "string" ? mapParam : mapParam.name;
+    const mapData = Map.maps[mapName];
+    if (!mapData) {
+      throw new Error(`Attempt to use map which was not loaded: ${mapName}`);
+    }
+    this._mapData = mapData;
+    this._defaultWidth = this._mapData.width;
+    this._defaultHeight = this._mapData.height;
+    if (document.readyState !== "loading") {
+      this._init();
+    } else {
+      window.addEventListener("DOMContentLoaded", () => this._init());
+    }
+  }
+  _init() {
+    const options = this.params;
+    const element = getElement(options.selector);
+    if (!element) {
+      throw new Error(`Element not found: ${options.selector}`);
+    }
+    this.container = element;
+    this.container.classList.add(CONTAINER_CLASS);
+    this._canvasImpl = new canvas_element_default(this.container);
+    this.canvas = this._canvasImpl;
+    this.setBackgroundColor(options.backgroundColor || "");
+    this._createRegions();
+    this.updateSize();
+    if (options.lines?.elements) {
+      const group = this._canvasImpl.createGroup(LINES_GROUP_ID);
+      if (!group) {
+        throw new TypeError("Failed to create lines group");
+      }
+      this._linesGroup = group.node;
+    }
+    if (options.markers) {
+      const markersGroup = this._canvasImpl.createGroup(MARKERS_GROUP_ID);
+      const labelsGroup = this._canvasImpl.createGroup(MARKERS_LABELS_GROUP_ID);
+      if (!markersGroup || !labelsGroup) {
+        throw new TypeError("Failed to create markers groups");
+      }
+      this._markersGroup = markersGroup.node;
+      this._markerLabelsGroup = labelsGroup.node;
+    }
+    this._createMarkers(options.markers || []);
+    this._createLines(options.lines?.elements || []);
+    this._repositionLabels();
+    this._setupContainerEvents();
+    this._setupElementEvents();
+    if (options.zoomButtons) {
+      this._setupZoomButtons();
+    }
+    if (options.showTooltip) {
+      this._tooltip = new tooltip_default(this);
+    }
+    if (options.selectedRegions) {
+      this._setSelected("regions", options.selectedRegions);
+    }
+    if (options.selectedMarkers) {
+      this._setSelected("_markers", options.selectedMarkers);
+    }
+    if (options.focusOn) {
+      this.setFocus(options.focusOn);
+    }
+    if (options.visualizeData) {
+      this.dataVisualization = new data_visualization_default(options.visualizeData, this);
+    }
+    if (options.bindTouchEvents) {
+      if ("ontouchstart" in window) {
+        this._setupContainerTouchEvents();
+      }
+    }
+    if (options.series) {
+      this.container.appendChild(this.legendHorizontal = createElement("div", SERIES_CONTAINER_H_CLASS));
+      this.container.appendChild(this.legendVertical = createElement("div", SERIES_CONTAINER_V_CLASS));
+      this._createSeries();
+    }
+    this._emit(events_default.onLoaded, [this]);
+  }
+  setBackgroundColor(color) {
+    this.container.style.backgroundColor = color;
+  }
+  getSelectedRegions() {
+    return this._getSelected("regions");
+  }
+  clearSelectedRegions(regions) {
+    const regionsToProcess = this._normalizeRegions(regions) || this._getSelected("regions");
+    regionsToProcess.forEach((key) => {
+      this.regions[key].element.select(false);
+    });
+  }
+  setSelectedRegions(regions) {
+    this.clearSelectedRegions();
+    const normalizedRegions = this._normalizeRegions(regions);
+    if (normalizedRegions) {
+      this._setSelected("regions", normalizedRegions);
+    }
+  }
+  getSelectedMarkers() {
+    return this._getSelected("_markers");
+  }
+  clearSelectedMarkers() {
+    this._clearSelected("_markers");
+  }
+  setSelectedMarkers(markers) {
+    const normalizedMarkers = this._normalizeRegions(markers);
+    if (normalizedMarkers) {
+      this._setSelected("_markers", normalizedMarkers);
+    }
+  }
+  addMarkers(config) {
+    const configs = Array.isArray(config) ? config : [config];
+    this._createMarkers(configs);
+  }
+  removeMarkers(markers) {
+    const toRemove = markers || Object.keys(this._markers);
+    toRemove.forEach((index) => {
+      const marker = this._markers[index];
+      if (marker) {
+        if (typeof marker.remove === "function") {
+          marker.remove();
+        } else if (marker.shape) {
+          marker.shape.remove();
+          if (marker.label) {
+            marker.label.remove();
+          }
+        }
+        delete this._markers[index];
+      }
+    });
+  }
+  addLine(from, to, style = {}) {
+    console.warn("`addLine` method is deprecated, please use `addLines` instead.");
+    this._createLines([{ from, to, style }]);
+  }
+  addLines(config) {
+    const uids = this._getLinesAsUids();
+    const configs = Array.isArray(config) ? config : [config];
+    this._createLines(configs.filter((line) => {
+      return !uids.includes(getLineUid(line.from, line.to));
+    }));
+  }
+  removeLines(lines) {
+    if (Array.isArray(lines) && typeof lines[0] !== "string") {
+      lines = lines.map((line) => getLineUid(line.from, line.to));
+    } else if (!Array.isArray(lines)) {
+      lines = this._getLinesAsUids();
+    }
+    lines.forEach((uid) => {
+      this._lines[uid].dispose();
+      delete this._lines[uid];
+    });
+  }
+  removeLine(from, to) {
+    console.warn("`removeLine` method is deprecated, please use `removeLines` instead.");
+    const uid = getLineUid(from, to);
+    if (Object.prototype.hasOwnProperty.call(this._lines, uid)) {
+      this._lines[uid].element.remove();
+      delete this._lines[uid];
+    }
+  }
+  reset() {
+    for (const key in this.series || {}) {
+      for (let i = 0;i < (this.series?.[key]?.length || 0); i++) {
+        this.series?.[key][i]?.clear();
+      }
+    }
+    if (this.legendHorizontal) {
+      removeElement(this.legendHorizontal);
+      this.legendHorizontal = undefined;
+    }
+    if (this.legendVertical) {
+      removeElement(this.legendVertical);
+      this.legendVertical = undefined;
+    }
+    this.scale = this._baseScale;
+    this.transX = this._baseTransX;
+    this.transY = this._baseTransY;
+    this._applyTransform();
+    this.clearSelectedMarkers();
+    this.clearSelectedRegions();
+    this.removeMarkers();
+  }
+  destroy(destroyInstance = true) {
+    event_handler_default.flush();
+    this._tooltip?.dispose();
+    this._emit(events_default.onDestroyed, []);
+    if (destroyInstance) {
+      Object.keys(this).forEach((key) => {
+        try {
+          delete this[key];
+        } catch {}
+      });
+    }
+  }
+  extend(name, callback) {
+    if (typeof this[name] === "function") {
+      throw new TypeError(`The method [${name}] does already exist, please use another name.`);
+    }
+    Map.prototype[name] = callback;
+  }
+  mercator = {
+    convert: (lat, lng) => {
+      return { x: lng, y: lat };
+    }
+  };
+  miller = {
+    convert: (lat, lng) => {
+      return { x: lng, y: lat };
+    }
+  };
+  getInsetForPoint(_x, _y) {
+    return false;
+  }
+  getMarkerPosition(_config) {
+    return { x: 0, y: 0 };
+  }
+  coordsToPoint(_lat, _lng) {
+    return { x: 0, y: 0 };
+  }
+  _repositionMarkers() {}
+  _repositionLines() {}
+  _setScale(_scale) {}
+  _emit(eventName, args) {
+    for (const event in events_default) {
+      if (events_default[event] === eventName && typeof this.params[event] === "function") {
+        this.params[event]?.apply(this, args);
+      }
+    }
+  }
+  _getSelected(type) {
+    const selected = [];
+    for (const key in this[type]) {
+      if (this[type][key].element.isSelected) {
+        selected.push(key);
+      }
+    }
+    return selected;
+  }
+  _setSelected(type, keys) {
+    keys.forEach((key) => {
+      if (this[type][key]) {
+        this[type][key].element.select(true);
+      }
+    });
+  }
+  _clearSelected(type) {
+    this._getSelected(type).forEach((key) => {
+      this[type][key].element.select(false);
+    });
+  }
+  _getLinesAsUids() {
+    return Object.keys(this._lines);
+  }
+  _normalizeRegions(regions) {
+    if (!regions)
+      return;
+    return typeof regions === "string" ? [regions] : regions;
+  }
+  _createRegions() {}
+  _createMarkers(_markers) {}
+  _createLines(_lines) {}
+  _createSeries() {}
+  _repositionLabels() {}
+  _setupContainerEvents() {}
+  _setupElementEvents() {}
+  _setupZoomButtons() {}
+  _setupContainerTouchEvents() {}
+  _applyTransform() {}
+  updateSize() {}
+  setFocus(_config) {}
+}
+Object.assign(Map.prototype, core_default);
+var map_default = Map;
+
+// src/vector-map.ts
+class VectorMap {
+  constructor(options = {}) {
+    if (!options.selector) {
+      throw new Error("Selector is not given.");
+    }
+    return new map_default(options);
+  }
+  static addMap(name, map) {
+    map_default.maps[name] = map;
+  }
+}
+
+// src/index.ts
+if (typeof window !== "undefined") {
+  window.VectorMap = VectorMap;
+}
+var src_default = VectorMap;
+export {
+  src_default as default,
+  VectorMap
+};