@powsybl/network-map-layers 2.0.0

package/dist/powsybl-network-map-layers.js

@@ -0,0 +1,4034 @@
+import { Layer, project32, picking, CompositeLayer } from "@deck.gl/core";
+import GL from "@luma.gl/constants";
+import { hasFeatures, FEATURES, isWebGL2, Texture2D, Model, Geometry } from "@luma.gl/core";
+import { PathStyleExtension } from "@deck.gl/extensions";
+import { LineLayer as LineLayer$1, PathLayer, TextLayer, IconLayer, ScatterplotLayer } from "@deck.gl/layers";
+var EQUIPMENT_TYPES = /* @__PURE__ */ ((EQUIPMENT_TYPES2) => {
+  EQUIPMENT_TYPES2["SUBSTATION"] = "SUBSTATION";
+  EQUIPMENT_TYPES2["VOLTAGE_LEVEL"] = "VOLTAGE_LEVEL";
+  EQUIPMENT_TYPES2["LINE"] = "LINE";
+  EQUIPMENT_TYPES2["TWO_WINDINGS_TRANSFORMER"] = "TWO_WINDINGS_TRANSFORMER";
+  EQUIPMENT_TYPES2["THREE_WINDINGS_TRANSFORMER"] = "THREE_WINDINGS_TRANSFORMER";
+  EQUIPMENT_TYPES2["HVDC_LINE"] = "HVDC_LINE";
+  EQUIPMENT_TYPES2["GENERATOR"] = "GENERATOR";
+  EQUIPMENT_TYPES2["BATTERY"] = "BATTERY";
+  EQUIPMENT_TYPES2["LOAD"] = "LOAD";
+  EQUIPMENT_TYPES2["SHUNT_COMPENSATOR"] = "SHUNT_COMPENSATOR";
+  EQUIPMENT_TYPES2["TIE_LINE"] = "TIE_LINE";
+  EQUIPMENT_TYPES2["DANGLING_LINE"] = "DANGLING_LINE";
+  EQUIPMENT_TYPES2["STATIC_VAR_COMPENSATOR"] = "STATIC_VAR_COMPENSATOR";
+  EQUIPMENT_TYPES2["HVDC_CONVERTER_STATION"] = "HVDC_CONVERTER_STATION";
+  EQUIPMENT_TYPES2["VSC_CONVERTER_STATION"] = "VSC_CONVERTER_STATION";
+  EQUIPMENT_TYPES2["LCC_CONVERTER_STATION"] = "LCC_CONVERTER_STATION";
+  EQUIPMENT_TYPES2["SWITCH"] = "SWITCH";
+  return EQUIPMENT_TYPES2;
+})(EQUIPMENT_TYPES || {});
+const factors = {
+  kilometers: 1,
+  miles: 1e3 / 1609.344,
+  nauticalmiles: 1e3 / 1852,
+  meters: 1e3,
+  metres: 1e3,
+  yards: 1e3 / 0.9144,
+  feet: 1e3 / 0.3048,
+  inches: 1e3 / 0.0254
+};
+const RE = 6378.137;
+const FE = 1 / 298.257223563;
+const E2 = FE * (2 - FE);
+const RAD = Math.PI / 180;
+class CheapRuler {
+  /**
+   * Creates a ruler object from tile coordinates (y and z).
+   *
+   * @param {number} y
+   * @param {number} z
+   * @param {keyof typeof factors} [units='kilometers']
+   * @returns {CheapRuler}
+   * @example
+   * const ruler = cheapRuler.fromTile(1567, 12);
+   * //=ruler
+   */
+  static fromTile(y, z, units) {
+    const n = Math.PI * (1 - 2 * (y + 0.5) / Math.pow(2, z));
+    const lat = Math.atan(0.5 * (Math.exp(n) - Math.exp(-n))) / RAD;
+    return new CheapRuler(lat, units);
+  }
+  /**
+   * Multipliers for converting between units.
+   *
+   * @example
+   * // convert 50 meters to yards
+   * 50 * CheapRuler.units.yards / CheapRuler.units.meters;
+   */
+  static get units() {
+    return factors;
+  }
+  /**
+   * Creates a ruler instance for very fast approximations to common geodesic measurements around a certain latitude.
+   *
+   * @param {number} lat latitude
+   * @param {keyof typeof factors} [units='kilometers']
+   * @example
+   * const ruler = cheapRuler(35.05, 'miles');
+   * //=ruler
+   */
+  constructor(lat, units) {
+    if (lat === void 0) throw new Error("No latitude given.");
+    if (units && !factors[units]) throw new Error(`Unknown unit ${units}. Use one of: ${Object.keys(factors).join(", ")}`);
+    const m = RAD * RE * (units ? factors[units] : 1);
+    const coslat = Math.cos(lat * RAD);
+    const w2 = 1 / (1 - E2 * (1 - coslat * coslat));
+    const w = Math.sqrt(w2);
+    this.kx = m * w * coslat;
+    this.ky = m * w * w2 * (1 - E2);
+  }
+  /**
+   * Given two points of the form [longitude, latitude], returns the distance.
+   *
+   * @param {[number, number]} a point [longitude, latitude]
+   * @param {[number, number]} b point [longitude, latitude]
+   * @returns {number} distance
+   * @example
+   * const distance = ruler.distance([30.5, 50.5], [30.51, 50.49]);
+   * //=distance
+   */
+  distance(a, b) {
+    const dx = wrap(a[0] - b[0]) * this.kx;
+    const dy = (a[1] - b[1]) * this.ky;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+  /**
+   * Returns the bearing between two points in angles.
+   *
+   * @param {[number, number]} a point [longitude, latitude]
+   * @param {[number, number]} b point [longitude, latitude]
+   * @returns {number} bearing
+   * @example
+   * const bearing = ruler.bearing([30.5, 50.5], [30.51, 50.49]);
+   * //=bearing
+   */
+  bearing(a, b) {
+    const dx = wrap(b[0] - a[0]) * this.kx;
+    const dy = (b[1] - a[1]) * this.ky;
+    return Math.atan2(dx, dy) / RAD;
+  }
+  /**
+   * Returns a new point given distance and bearing from the starting point.
+   *
+   * @param {[number, number]} p point [longitude, latitude]
+   * @param {number} dist distance
+   * @param {number} bearing
+   * @returns {[number, number]} point [longitude, latitude]
+   * @example
+   * const point = ruler.destination([30.5, 50.5], 0.1, 90);
+   * //=point
+   */
+  destination(p, dist, bearing) {
+    const a = bearing * RAD;
+    return this.offset(
+      p,
+      Math.sin(a) * dist,
+      Math.cos(a) * dist
+    );
+  }
+  /**
+   * Returns a new point given easting and northing offsets (in ruler units) from the starting point.
+   *
+   * @param {[number, number]} p point [longitude, latitude]
+   * @param {number} dx easting
+   * @param {number} dy northing
+   * @returns {[number, number]} point [longitude, latitude]
+   * @example
+   * const point = ruler.offset([30.5, 50.5], 10, 10);
+   * //=point
+   */
+  offset(p, dx, dy) {
+    return [
+      p[0] + dx / this.kx,
+      p[1] + dy / this.ky
+    ];
+  }
+  /**
+   * Given a line (an array of points), returns the total line distance.
+   *
+   * @param {[number, number][]} points [longitude, latitude]
+   * @returns {number} total line distance
+   * @example
+   * const length = ruler.lineDistance([
+   *     [-67.031, 50.458], [-67.031, 50.534],
+   *     [-66.929, 50.534], [-66.929, 50.458]
+   * ]);
+   * //=length
+   */
+  lineDistance(points) {
+    let total = 0;
+    for (let i = 0; i < points.length - 1; i++) {
+      total += this.distance(points[i], points[i + 1]);
+    }
+    return total;
+  }
+  /**
+   * Given a polygon (an array of rings, where each ring is an array of points), returns the area.
+   *
+   * @param {[number, number][][]} polygon
+   * @returns {number} area value in the specified units (square kilometers by default)
+   * @example
+   * const area = ruler.area([[
+   *     [-67.031, 50.458], [-67.031, 50.534], [-66.929, 50.534],
+   *     [-66.929, 50.458], [-67.031, 50.458]
+   * ]]);
+   * //=area
+   */
+  area(polygon) {
+    let sum = 0;
+    for (let i = 0; i < polygon.length; i++) {
+      const ring = polygon[i];
+      for (let j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
+        sum += wrap(ring[j][0] - ring[k][0]) * (ring[j][1] + ring[k][1]) * (i ? -1 : 1);
+      }
+    }
+    return Math.abs(sum) / 2 * this.kx * this.ky;
+  }
+  /**
+   * Returns the point at a specified distance along the line.
+   *
+   * @param {[number, number][]} line
+   * @param {number} dist distance
+   * @returns {[number, number]} point [longitude, latitude]
+   * @example
+   * const point = ruler.along(line, 2.5);
+   * //=point
+   */
+  along(line, dist) {
+    let sum = 0;
+    if (dist <= 0) return line[0];
+    for (let i = 0; i < line.length - 1; i++) {
+      const p0 = line[i];
+      const p1 = line[i + 1];
+      const d = this.distance(p0, p1);
+      sum += d;
+      if (sum > dist) return interpolate(p0, p1, (dist - (sum - d)) / d);
+    }
+    return line[line.length - 1];
+  }
+  /**
+   * Returns the distance from a point `p` to a line segment `a` to `b`.
+   *
+   * @pointToSegmentDistance
+   * @param {[number, number]} p point [longitude, latitude]
+   * @param {[number, number]} a segment point 1 [longitude, latitude]
+   * @param {[number, number]} b segment point 2 [longitude, latitude]
+   * @returns {number} distance
+   * @example
+   * const distance = ruler.pointToSegmentDistance([-67.04, 50.5], [-67.05, 50.57], [-67.03, 50.54]);
+   * //=distance
+   */
+  pointToSegmentDistance(p, a, b) {
+    let [x, y] = a;
+    let dx = wrap(b[0] - x) * this.kx;
+    let dy = (b[1] - y) * this.ky;
+    if (dx !== 0 || dy !== 0) {
+      const t = (wrap(p[0] - x) * this.kx * dx + (p[1] - y) * this.ky * dy) / (dx * dx + dy * dy);
+      if (t > 1) {
+        x = b[0];
+        y = b[1];
+      } else if (t > 0) {
+        x += dx / this.kx * t;
+        y += dy / this.ky * t;
+      }
+    }
+    dx = wrap(p[0] - x) * this.kx;
+    dy = (p[1] - y) * this.ky;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+  /**
+   * Returns an object of the form {point, index, t}, where point is closest point on the line
+   * from the given point, index is the start index of the segment with the closest point,
+   * and t is a parameter from 0 to 1 that indicates where the closest point is on that segment.
+   *
+   * @param {[number, number][]} line
+   * @param {[number, number]} p point [longitude, latitude]
+   * @returns {{point: [number, number], index: number, t: number}} {point, index, t}
+   * @example
+   * const point = ruler.pointOnLine(line, [-67.04, 50.5]).point;
+   * //=point
+   */
+  pointOnLine(line, p) {
+    let minDist = Infinity;
+    let minX = line[0][0];
+    let minY = line[0][1];
+    let minI = 0;
+    let minT = 0;
+    for (let i = 0; i < line.length - 1; i++) {
+      let x = line[i][0];
+      let y = line[i][1];
+      let dx = wrap(line[i + 1][0] - x) * this.kx;
+      let dy = (line[i + 1][1] - y) * this.ky;
+      let t = 0;
+      if (dx !== 0 || dy !== 0) {
+        t = (wrap(p[0] - x) * this.kx * dx + (p[1] - y) * this.ky * dy) / (dx * dx + dy * dy);
+        if (t > 1) {
+          x = line[i + 1][0];
+          y = line[i + 1][1];
+        } else if (t > 0) {
+          x += dx / this.kx * t;
+          y += dy / this.ky * t;
+        }
+      }
+      dx = wrap(p[0] - x) * this.kx;
+      dy = (p[1] - y) * this.ky;
+      const sqDist = dx * dx + dy * dy;
+      if (sqDist < minDist) {
+        minDist = sqDist;
+        minX = x;
+        minY = y;
+        minI = i;
+        minT = t;
+      }
+    }
+    return {
+      point: [minX, minY],
+      index: minI,
+      t: Math.max(0, Math.min(1, minT))
+    };
+  }
+  /**
+   * Returns a part of the given line between the start and the stop points (or their closest points on the line).
+   *
+   * @param {[number, number]} start point [longitude, latitude]
+   * @param {[number, number]} stop point [longitude, latitude]
+   * @param {[number, number][]} line
+   * @returns {[number, number][]} line part of a line
+   * @example
+   * const line2 = ruler.lineSlice([-67.04, 50.5], [-67.05, 50.56], line1);
+   * //=line2
+   */
+  lineSlice(start, stop, line) {
+    let p1 = this.pointOnLine(line, start);
+    let p2 = this.pointOnLine(line, stop);
+    if (p1.index > p2.index || p1.index === p2.index && p1.t > p2.t) {
+      const tmp = p1;
+      p1 = p2;
+      p2 = tmp;
+    }
+    const slice = [p1.point];
+    const l = p1.index + 1;
+    const r = p2.index;
+    if (!equals(line[l], slice[0]) && l <= r)
+      slice.push(line[l]);
+    for (let i = l + 1; i <= r; i++) {
+      slice.push(line[i]);
+    }
+    if (!equals(line[r], p2.point))
+      slice.push(p2.point);
+    return slice;
+  }
+  /**
+   * Returns a part of the given line between the start and the stop points indicated by distance along the line.
+   *
+   * @param {number} start start distance
+   * @param {number} stop stop distance
+   * @param {[number, number][]} line
+   * @returns {[number, number][]} part of a line
+   * @example
+   * const line2 = ruler.lineSliceAlong(10, 20, line1);
+   * //=line2
+   */
+  lineSliceAlong(start, stop, line) {
+    let sum = 0;
+    const slice = [];
+    for (let i = 0; i < line.length - 1; i++) {
+      const p0 = line[i];
+      const p1 = line[i + 1];
+      const d = this.distance(p0, p1);
+      sum += d;
+      if (sum > start && slice.length === 0) {
+        slice.push(interpolate(p0, p1, (start - (sum - d)) / d));
+      }
+      if (sum >= stop) {
+        slice.push(interpolate(p0, p1, (stop - (sum - d)) / d));
+        return slice;
+      }
+      if (sum > start) slice.push(p1);
+    }
+    return slice;
+  }
+  /**
+   * Given a point, returns a bounding box object ([w, s, e, n]) created from the given point buffered by a given distance.
+   *
+   * @param {[number, number]} p point [longitude, latitude]
+   * @param {number} buffer
+   * @returns {[number, number, number, number]} bbox ([w, s, e, n])
+   * @example
+   * const bbox = ruler.bufferPoint([30.5, 50.5], 0.01);
+   * //=bbox
+   */
+  bufferPoint(p, buffer) {
+    const v = buffer / this.ky;
+    const h = buffer / this.kx;
+    return [
+      p[0] - h,
+      p[1] - v,
+      p[0] + h,
+      p[1] + v
+    ];
+  }
+  /**
+   * Given a bounding box, returns the box buffered by a given distance.
+   *
+   * @param {[number, number, number, number]} bbox ([w, s, e, n])
+   * @param {number} buffer
+   * @returns {[number, number, number, number]} bbox ([w, s, e, n])
+   * @example
+   * const bbox = ruler.bufferBBox([30.5, 50.5, 31, 51], 0.2);
+   * //=bbox
+   */
+  bufferBBox(bbox, buffer) {
+    const v = buffer / this.ky;
+    const h = buffer / this.kx;
+    return [
+      bbox[0] - h,
+      bbox[1] - v,
+      bbox[2] + h,
+      bbox[3] + v
+    ];
+  }
+  /**
+   * Returns true if the given point is inside in the given bounding box, otherwise false.
+   *
+   * @param {[number, number]} p point [longitude, latitude]
+   * @param {[number, number, number, number]} bbox ([w, s, e, n])
+   * @returns {boolean}
+   * @example
+   * const inside = ruler.insideBBox([30.5, 50.5], [30, 50, 31, 51]);
+   * //=inside
+   */
+  insideBBox(p, bbox) {
+    return wrap(p[0] - bbox[0]) >= 0 && wrap(p[0] - bbox[2]) <= 0 && p[1] >= bbox[1] && p[1] <= bbox[3];
+  }
+}
+function equals(a, b) {
+  return a[0] === b[0] && a[1] === b[1];
+}
+function interpolate(a, b, t) {
+  const dx = wrap(b[0] - a[0]);
+  const dy = b[1] - a[1];
+  return [
+    a[0] + dx * t,
+    a[1] + dy * t
+  ];
+}
+function wrap(deg) {
+  while (deg < -180) deg += 360;
+  while (deg > 180) deg -= 360;
+  return deg;
+}
+var es = {};
+var computeDestinationPoint$1 = {};
+var getLatitude$1 = {};
+var constants = {};
+Object.defineProperty(constants, "__esModule", { value: true });
+constants.areaConversion = constants.timeConversion = constants.distanceConversion = constants.altitudeKeys = constants.latitudeKeys = constants.longitudeKeys = constants.MAXLON = constants.MINLON = constants.MAXLAT = constants.MINLAT = constants.earthRadius = constants.sexagesimalPattern = void 0;
+var sexagesimalPattern = /^([0-9]{1,3})°\s*([0-9]{1,3}(?:\.(?:[0-9]{1,}))?)['′]\s*(([0-9]{1,3}(\.([0-9]{1,}))?)["″]\s*)?([NEOSW]?)$/;
+constants.sexagesimalPattern = sexagesimalPattern;
+var earthRadius = 6378137;
+constants.earthRadius = earthRadius;
+var MINLAT = -90;
+constants.MINLAT = MINLAT;
+var MAXLAT = 90;
+constants.MAXLAT = MAXLAT;
+var MINLON = -180;
+constants.MINLON = MINLON;
+var MAXLON = 180;
+constants.MAXLON = MAXLON;
+var longitudeKeys = ["lng", "lon", "longitude", 0];
+constants.longitudeKeys = longitudeKeys;
+var latitudeKeys = ["lat", "latitude", 1];
+constants.latitudeKeys = latitudeKeys;
+var altitudeKeys = ["alt", "altitude", "elevation", "elev", 2];
+constants.altitudeKeys = altitudeKeys;
+var distanceConversion = { m: 1, km: 1e-3, cm: 100, mm: 1e3, mi: 1 / 1609.344, sm: 1 / 1852.216, ft: 100 / 30.48, in: 100 / 2.54, yd: 1 / 0.9144 };
+constants.distanceConversion = distanceConversion;
+var timeConversion = { m: 60, h: 3600, d: 86400 };
+constants.timeConversion = timeConversion;
+var areaConversion = { m2: 1, km2: 1e-6, ha: 1e-4, a: 0.01, ft2: 10.763911, yd2: 1.19599, in2: 1550.0031 };
+constants.areaConversion = areaConversion;
+areaConversion.sqm = areaConversion.m2;
+areaConversion.sqkm = areaConversion.km2;
+areaConversion.sqft = areaConversion.ft2;
+areaConversion.sqyd = areaConversion.yd2;
+areaConversion.sqin = areaConversion.in2;
+var getCoordinateKey$1 = {};
+Object.defineProperty(getCoordinateKey$1, "__esModule", { value: true });
+getCoordinateKey$1.default = void 0;
+var getCoordinateKey = function getCoordinateKey2(point, keysToLookup) {
+  return keysToLookup.reduce(function(foundKey, key) {
+    if (typeof point === "undefined" || point === null) {
+      throw new Error("'".concat(point, "' is no valid coordinate."));
+    }
+    if (Object.prototype.hasOwnProperty.call(point, key) && typeof key !== "undefined" && typeof foundKey === "undefined") {
+      foundKey = key;
+      return key;
+    }
+    return foundKey;
+  }, void 0);
+};
+var _default$D = getCoordinateKey;
+getCoordinateKey$1.default = _default$D;
+var toDecimal$1 = {};
+var isDecimal$1 = {};
+Object.defineProperty(isDecimal$1, "__esModule", { value: true });
+isDecimal$1.default = void 0;
+var isDecimal = function isDecimal2(value) {
+  var checkedValue = value.toString().trim();
+  if (isNaN(parseFloat(checkedValue))) {
+    return false;
+  }
+  return parseFloat(checkedValue) === Number(checkedValue);
+};
+var _default$C = isDecimal;
+isDecimal$1.default = _default$C;
+var isSexagesimal$1 = {};
+Object.defineProperty(isSexagesimal$1, "__esModule", { value: true });
+isSexagesimal$1.default = void 0;
+var _constants$e = constants;
+var isSexagesimal = function isSexagesimal2(value) {
+  return _constants$e.sexagesimalPattern.test(value.toString().trim());
+};
+var _default$B = isSexagesimal;
+isSexagesimal$1.default = _default$B;
+var sexagesimalToDecimal$1 = {};
+Object.defineProperty(sexagesimalToDecimal$1, "__esModule", { value: true });
+sexagesimalToDecimal$1.default = void 0;
+var _constants$d = constants;
+var sexagesimalToDecimal = function sexagesimalToDecimal2(sexagesimal) {
+  var data = new RegExp(_constants$d.sexagesimalPattern).exec(sexagesimal.toString().trim());
+  if (typeof data === "undefined" || data === null) {
+    throw new Error("Given value is not in sexagesimal format");
+  }
+  var min = Number(data[2]) / 60 || 0;
+  var sec = Number(data[4]) / 3600 || 0;
+  var decimal = parseFloat(data[1]) + min + sec;
+  return ["S", "W"].includes(data[7]) ? -decimal : decimal;
+};
+var _default$A = sexagesimalToDecimal;
+sexagesimalToDecimal$1.default = _default$A;
+var isValidCoordinate$1 = {};
+var getCoordinateKeys$1 = {};
+Object.defineProperty(getCoordinateKeys$1, "__esModule", { value: true });
+getCoordinateKeys$1.default = void 0;
+var _constants$c = constants;
+var _getCoordinateKey$2 = _interopRequireDefault$q(getCoordinateKey$1);
+function _interopRequireDefault$q(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+function ownKeys$1(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    });
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread$1(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    if (i % 2) {
+      ownKeys$1(Object(source), true).forEach(function(key) {
+        _defineProperty$1(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys$1(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+function _defineProperty$1(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var getCoordinateKeys = function getCoordinateKeys2(point) {
+  var keysToLookup = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : { longitude: _constants$c.longitudeKeys, latitude: _constants$c.latitudeKeys, altitude: _constants$c.altitudeKeys };
+  var longitude = (0, _getCoordinateKey$2.default)(point, keysToLookup.longitude);
+  var latitude = (0, _getCoordinateKey$2.default)(point, keysToLookup.latitude);
+  var altitude = (0, _getCoordinateKey$2.default)(point, keysToLookup.altitude);
+  return _objectSpread$1({ latitude, longitude }, altitude ? { altitude } : {});
+};
+var _default$z = getCoordinateKeys;
+getCoordinateKeys$1.default = _default$z;
+var isValidLatitude$1 = {};
+Object.defineProperty(isValidLatitude$1, "__esModule", { value: true });
+isValidLatitude$1.default = void 0;
+var _isDecimal$2 = _interopRequireDefault$p(isDecimal$1);
+var _isSexagesimal$2 = _interopRequireDefault$p(isSexagesimal$1);
+var _sexagesimalToDecimal$2 = _interopRequireDefault$p(sexagesimalToDecimal$1);
+var _constants$b = constants;
+function _interopRequireDefault$p(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var isValidLatitude = function isValidLatitude2(value) {
+  if ((0, _isDecimal$2.default)(value)) {
+    if (parseFloat(value) > _constants$b.MAXLAT || value < _constants$b.MINLAT) {
+      return false;
+    }
+    return true;
+  }
+  if ((0, _isSexagesimal$2.default)(value)) {
+    return isValidLatitude2((0, _sexagesimalToDecimal$2.default)(value));
+  }
+  return false;
+};
+var _default$y = isValidLatitude;
+isValidLatitude$1.default = _default$y;
+var isValidLongitude$1 = {};
+Object.defineProperty(isValidLongitude$1, "__esModule", { value: true });
+isValidLongitude$1.default = void 0;
+var _isDecimal$1 = _interopRequireDefault$o(isDecimal$1);
+var _isSexagesimal$1 = _interopRequireDefault$o(isSexagesimal$1);
+var _sexagesimalToDecimal$1 = _interopRequireDefault$o(sexagesimalToDecimal$1);
+var _constants$a = constants;
+function _interopRequireDefault$o(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var isValidLongitude = function isValidLongitude2(value) {
+  if ((0, _isDecimal$1.default)(value)) {
+    if (parseFloat(value) > _constants$a.MAXLON || value < _constants$a.MINLON) {
+      return false;
+    }
+    return true;
+  }
+  if ((0, _isSexagesimal$1.default)(value)) {
+    return isValidLongitude2((0, _sexagesimalToDecimal$1.default)(value));
+  }
+  return false;
+};
+var _default$x = isValidLongitude;
+isValidLongitude$1.default = _default$x;
+Object.defineProperty(isValidCoordinate$1, "__esModule", { value: true });
+isValidCoordinate$1.default = void 0;
+var _getCoordinateKeys2 = _interopRequireDefault$n(getCoordinateKeys$1);
+var _isValidLatitude = _interopRequireDefault$n(isValidLatitude$1);
+var _isValidLongitude = _interopRequireDefault$n(isValidLongitude$1);
+function _interopRequireDefault$n(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var isValidCoordinate = function isValidCoordinate2(point) {
+  var _getCoordinateKeys3 = (0, _getCoordinateKeys2.default)(point), latitude = _getCoordinateKeys3.latitude, longitude = _getCoordinateKeys3.longitude;
+  if (Array.isArray(point) && point.length >= 2) {
+    return (0, _isValidLongitude.default)(point[0]) && (0, _isValidLatitude.default)(point[1]);
+  }
+  if (typeof latitude === "undefined" || typeof longitude === "undefined") {
+    return false;
+  }
+  var lon = point[longitude];
+  var lat = point[latitude];
+  if (typeof lat === "undefined" || typeof lon === "undefined") {
+    return false;
+  }
+  if ((0, _isValidLatitude.default)(lat) === false || (0, _isValidLongitude.default)(lon) === false) {
+    return false;
+  }
+  return true;
+};
+var _default$w = isValidCoordinate;
+isValidCoordinate$1.default = _default$w;
+Object.defineProperty(toDecimal$1, "__esModule", { value: true });
+toDecimal$1.default = void 0;
+var _isDecimal = _interopRequireDefault$m(isDecimal$1);
+var _isSexagesimal = _interopRequireDefault$m(isSexagesimal$1);
+var _sexagesimalToDecimal = _interopRequireDefault$m(sexagesimalToDecimal$1);
+var _isValidCoordinate = _interopRequireDefault$m(isValidCoordinate$1);
+var _getCoordinateKeys = _interopRequireDefault$m(getCoordinateKeys$1);
+function _interopRequireDefault$m(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    });
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function(key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var toDecimal = function toDecimal2(value) {
+  if ((0, _isDecimal.default)(value)) {
+    return Number(value);
+  }
+  if ((0, _isSexagesimal.default)(value)) {
+    return (0, _sexagesimalToDecimal.default)(value);
+  }
+  if ((0, _isValidCoordinate.default)(value)) {
+    var keys = (0, _getCoordinateKeys.default)(value);
+    if (Array.isArray(value)) {
+      return value.map(function(v, index) {
+        return [0, 1].includes(index) ? toDecimal2(v) : v;
+      });
+    }
+    return _objectSpread(_objectSpread(_objectSpread({}, value), keys.latitude && _defineProperty({}, keys.latitude, toDecimal2(value[keys.latitude]))), keys.longitude && _defineProperty({}, keys.longitude, toDecimal2(value[keys.longitude])));
+  }
+  if (Array.isArray(value)) {
+    return value.map(function(point) {
+      return (0, _isValidCoordinate.default)(point) ? toDecimal2(point) : point;
+    });
+  }
+  return value;
+};
+var _default$v = toDecimal;
+toDecimal$1.default = _default$v;
+Object.defineProperty(getLatitude$1, "__esModule", { value: true });
+getLatitude$1.default = void 0;
+var _constants$9 = constants;
+var _getCoordinateKey$1 = _interopRequireDefault$l(getCoordinateKey$1);
+var _toDecimal$1 = _interopRequireDefault$l(toDecimal$1);
+function _interopRequireDefault$l(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getLatitude = function getLatitude2(point, raw) {
+  var latKey = (0, _getCoordinateKey$1.default)(point, _constants$9.latitudeKeys);
+  if (typeof latKey === "undefined" || latKey === null) {
+    return;
+  }
+  var value = point[latKey];
+  return raw === true ? value : (0, _toDecimal$1.default)(value);
+};
+var _default$u = getLatitude;
+getLatitude$1.default = _default$u;
+var getLongitude$1 = {};
+Object.defineProperty(getLongitude$1, "__esModule", { value: true });
+getLongitude$1.default = void 0;
+var _constants$8 = constants;
+var _getCoordinateKey = _interopRequireDefault$k(getCoordinateKey$1);
+var _toDecimal = _interopRequireDefault$k(toDecimal$1);
+function _interopRequireDefault$k(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getLongitude = function getLongitude2(point, raw) {
+  var latKey = (0, _getCoordinateKey.default)(point, _constants$8.longitudeKeys);
+  if (typeof latKey === "undefined" || latKey === null) {
+    return;
+  }
+  var value = point[latKey];
+  return raw === true ? value : (0, _toDecimal.default)(value);
+};
+var _default$t = getLongitude;
+getLongitude$1.default = _default$t;
+var toRad$1 = {};
+Object.defineProperty(toRad$1, "__esModule", { value: true });
+toRad$1.default = void 0;
+var toRad = function toRad2(value) {
+  return value * Math.PI / 180;
+};
+var _default$s = toRad;
+toRad$1.default = _default$s;
+var toDeg$1 = {};
+Object.defineProperty(toDeg$1, "__esModule", { value: true });
+toDeg$1.default = void 0;
+var toDeg = function toDeg2(value) {
+  return value * 180 / Math.PI;
+};
+var _default$r = toDeg;
+toDeg$1.default = _default$r;
+Object.defineProperty(computeDestinationPoint$1, "__esModule", { value: true });
+computeDestinationPoint$1.default = void 0;
+var _getLatitude$9 = _interopRequireDefault$j(getLatitude$1);
+var _getLongitude$9 = _interopRequireDefault$j(getLongitude$1);
+var _toRad$7 = _interopRequireDefault$j(toRad$1);
+var _toDeg$4 = _interopRequireDefault$j(toDeg$1);
+var _constants$7 = constants;
+function _interopRequireDefault$j(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var computeDestinationPoint = function computeDestinationPoint2(start, distance, bearing) {
+  var radius = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 6371e3;
+  var lat = (0, _getLatitude$9.default)(start);
+  var lng = (0, _getLongitude$9.default)(start);
+  var delta = distance / radius;
+  var theta = (0, _toRad$7.default)(bearing);
+  var phi1 = (0, _toRad$7.default)(lat);
+  var lambda1 = (0, _toRad$7.default)(lng);
+  var phi2 = Math.asin(Math.sin(phi1) * Math.cos(delta) + Math.cos(phi1) * Math.sin(delta) * Math.cos(theta));
+  var lambda2 = lambda1 + Math.atan2(Math.sin(theta) * Math.sin(delta) * Math.cos(phi1), Math.cos(delta) - Math.sin(phi1) * Math.sin(phi2));
+  var longitude = (0, _toDeg$4.default)(lambda2);
+  if (longitude < _constants$7.MINLON || longitude > _constants$7.MAXLON) {
+    lambda2 = (lambda2 + 3 * Math.PI) % (2 * Math.PI) - Math.PI;
+    longitude = (0, _toDeg$4.default)(lambda2);
+  }
+  return { latitude: (0, _toDeg$4.default)(phi2), longitude };
+};
+var _default$q = computeDestinationPoint;
+computeDestinationPoint$1.default = _default$q;
+var convertArea$1 = {};
+Object.defineProperty(convertArea$1, "__esModule", { value: true });
+convertArea$1.default = void 0;
+var _constants$6 = constants;
+var convertArea = function convertArea2(squareMeters) {
+  var targetUnit = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "m";
+  var factor = _constants$6.areaConversion[targetUnit];
+  if (factor) {
+    return squareMeters * factor;
+  }
+  throw new Error("Invalid unit used for area conversion.");
+};
+var _default$p = convertArea;
+convertArea$1.default = _default$p;
+var convertDistance$1 = {};
+Object.defineProperty(convertDistance$1, "__esModule", { value: true });
+convertDistance$1.default = void 0;
+var _constants$5 = constants;
+var convertDistance = function convertDistance2(meters) {
+  var targetUnit = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "m";
+  var factor = _constants$5.distanceConversion[targetUnit];
+  if (factor) {
+    return meters * factor;
+  }
+  throw new Error("Invalid unit used for distance conversion.");
+};
+var _default$o = convertDistance;
+convertDistance$1.default = _default$o;
+var convertSpeed$1 = {};
+Object.defineProperty(convertSpeed$1, "__esModule", { value: true });
+convertSpeed$1.default = void 0;
+var _constants$4 = constants;
+var convertSpeed = function convertSpeed2(metersPerSecond) {
+  var targetUnit = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "kmh";
+  switch (targetUnit) {
+    case "kmh":
+      return metersPerSecond * _constants$4.timeConversion.h * _constants$4.distanceConversion.km;
+    case "mph":
+      return metersPerSecond * _constants$4.timeConversion.h * _constants$4.distanceConversion.mi;
+    default:
+      return metersPerSecond;
+  }
+};
+var _default$n = convertSpeed;
+convertSpeed$1.default = _default$n;
+var decimalToSexagesimal = {};
+Object.defineProperty(decimalToSexagesimal, "__esModule", { value: true });
+decimalToSexagesimal.default = void 0;
+function _slicedToArray$1(arr, i) {
+  return _arrayWithHoles$1(arr) || _iterableToArrayLimit$1(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest$1();
+}
+function _nonIterableRest$1() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _unsupportedIterableToArray$1(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray$1(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen);
+}
+function _arrayLikeToArray$1(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+  return arr2;
+}
+function _iterableToArrayLimit$1(arr, i) {
+  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = void 0;
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+  return _arr;
+}
+function _arrayWithHoles$1(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+var imprecise = function imprecise2(number) {
+  var decimals = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 4;
+  var factor = Math.pow(10, decimals);
+  return Math.round(number * factor) / factor;
+};
+var decimal2sexagesimalNext = function decimal2sexagesimalNext2(decimal) {
+  var _decimal$toString$spl = decimal.toString().split("."), _decimal$toString$spl2 = _slicedToArray$1(_decimal$toString$spl, 2), pre = _decimal$toString$spl2[0], post = _decimal$toString$spl2[1];
+  var deg = Math.abs(Number(pre));
+  var min0 = Number("0." + (post || 0)) * 60;
+  var sec0 = min0.toString().split(".");
+  var min = Math.floor(min0);
+  var sec = imprecise(Number("0." + (sec0[1] || 0)) * 60).toString();
+  var _sec$split = sec.split("."), _sec$split2 = _slicedToArray$1(_sec$split, 2), secPreDec = _sec$split2[0], _sec$split2$ = _sec$split2[1], secDec = _sec$split2$ === void 0 ? "0" : _sec$split2$;
+  return deg + "° " + min.toString().padStart(2, "0") + "' " + secPreDec.padStart(2, "0") + "." + secDec.padEnd(1, "0") + '"';
+};
+var _default$m = decimal2sexagesimalNext;
+decimalToSexagesimal.default = _default$m;
+var findNearest$1 = {};
+var orderByDistance$1 = {};
+var getDistance$2 = {};
+var robustAcos$1 = {};
+Object.defineProperty(robustAcos$1, "__esModule", { value: true });
+robustAcos$1.default = void 0;
+var robustAcos = function robustAcos2(value) {
+  if (value > 1) {
+    return 1;
+  }
+  if (value < -1) {
+    return -1;
+  }
+  return value;
+};
+var _default$l = robustAcos;
+robustAcos$1.default = _default$l;
+Object.defineProperty(getDistance$2, "__esModule", { value: true });
+getDistance$2.default = void 0;
+var _getLatitude$8 = _interopRequireDefault$i(getLatitude$1);
+var _getLongitude$8 = _interopRequireDefault$i(getLongitude$1);
+var _toRad$6 = _interopRequireDefault$i(toRad$1);
+var _robustAcos$1 = _interopRequireDefault$i(robustAcos$1);
+var _constants$3 = constants;
+function _interopRequireDefault$i(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getDistance$1 = function getDistance(from, to) {
+  var accuracy = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1;
+  accuracy = typeof accuracy !== "undefined" && !isNaN(accuracy) ? accuracy : 1;
+  var fromLat = (0, _getLatitude$8.default)(from);
+  var fromLon = (0, _getLongitude$8.default)(from);
+  var toLat = (0, _getLatitude$8.default)(to);
+  var toLon = (0, _getLongitude$8.default)(to);
+  var distance = Math.acos((0, _robustAcos$1.default)(Math.sin((0, _toRad$6.default)(toLat)) * Math.sin((0, _toRad$6.default)(fromLat)) + Math.cos((0, _toRad$6.default)(toLat)) * Math.cos((0, _toRad$6.default)(fromLat)) * Math.cos((0, _toRad$6.default)(fromLon) - (0, _toRad$6.default)(toLon)))) * _constants$3.earthRadius;
+  return Math.round(distance / accuracy) * accuracy;
+};
+var _default$k = getDistance$1;
+getDistance$2.default = _default$k;
+Object.defineProperty(orderByDistance$1, "__esModule", { value: true });
+orderByDistance$1.default = void 0;
+var _getDistance$5 = _interopRequireDefault$h(getDistance$2);
+function _interopRequireDefault$h(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var orderByDistance = function orderByDistance2(point, coords) {
+  var distanceFn = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : _getDistance$5.default;
+  distanceFn = typeof distanceFn === "function" ? distanceFn : _getDistance$5.default;
+  return coords.slice().sort(function(a, b) {
+    return distanceFn(point, a) - distanceFn(point, b);
+  });
+};
+var _default$j = orderByDistance;
+orderByDistance$1.default = _default$j;
+Object.defineProperty(findNearest$1, "__esModule", { value: true });
+findNearest$1.default = void 0;
+var _orderByDistance = _interopRequireDefault$g(orderByDistance$1);
+function _interopRequireDefault$g(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var findNearest = function findNearest2(point, coords) {
+  return (0, _orderByDistance.default)(point, coords)[0];
+};
+var _default$i = findNearest;
+findNearest$1.default = _default$i;
+var getAreaOfPolygon$1 = {};
+Object.defineProperty(getAreaOfPolygon$1, "__esModule", { value: true });
+getAreaOfPolygon$1.default = void 0;
+var _toRad$5 = _interopRequireDefault$f(toRad$1);
+var _getLatitude$7 = _interopRequireDefault$f(getLatitude$1);
+var _getLongitude$7 = _interopRequireDefault$f(getLongitude$1);
+var _constants$2 = constants;
+function _interopRequireDefault$f(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getAreaOfPolygon = function getAreaOfPolygon2(points) {
+  var area = 0;
+  if (points.length > 2) {
+    var lowerIndex;
+    var middleIndex;
+    var upperIndex;
+    for (var i = 0; i < points.length; i++) {
+      if (i === points.length - 2) {
+        lowerIndex = points.length - 2;
+        middleIndex = points.length - 1;
+        upperIndex = 0;
+      } else if (i === points.length - 1) {
+        lowerIndex = points.length - 1;
+        middleIndex = 0;
+        upperIndex = 1;
+      } else {
+        lowerIndex = i;
+        middleIndex = i + 1;
+        upperIndex = i + 2;
+      }
+      var p1lon = (0, _getLongitude$7.default)(points[lowerIndex]);
+      var p2lat = (0, _getLatitude$7.default)(points[middleIndex]);
+      var p3lon = (0, _getLongitude$7.default)(points[upperIndex]);
+      area += ((0, _toRad$5.default)(p3lon) - (0, _toRad$5.default)(p1lon)) * Math.sin((0, _toRad$5.default)(p2lat));
+    }
+    area = area * _constants$2.earthRadius * _constants$2.earthRadius / 2;
+  }
+  return Math.abs(area);
+};
+var _default$h = getAreaOfPolygon;
+getAreaOfPolygon$1.default = _default$h;
+var getBounds$1 = {};
+Object.defineProperty(getBounds$1, "__esModule", { value: true });
+getBounds$1.default = void 0;
+var _getLatitude$6 = _interopRequireDefault$e(getLatitude$1);
+var _getLongitude$6 = _interopRequireDefault$e(getLongitude$1);
+function _interopRequireDefault$e(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getBounds = function getBounds2(points) {
+  if (Array.isArray(points) === false || points.length === 0) {
+    throw new Error("No points were given.");
+  }
+  return points.reduce(function(stats, point) {
+    var latitude = (0, _getLatitude$6.default)(point);
+    var longitude = (0, _getLongitude$6.default)(point);
+    return { maxLat: Math.max(latitude, stats.maxLat), minLat: Math.min(latitude, stats.minLat), maxLng: Math.max(longitude, stats.maxLng), minLng: Math.min(longitude, stats.minLng) };
+  }, { maxLat: -Infinity, minLat: Infinity, maxLng: -Infinity, minLng: Infinity });
+};
+var _default$g = getBounds;
+getBounds$1.default = _default$g;
+var getBoundsOfDistance$1 = {};
+Object.defineProperty(getBoundsOfDistance$1, "__esModule", { value: true });
+getBoundsOfDistance$1.default = void 0;
+var _getLatitude$5 = _interopRequireDefault$d(getLatitude$1);
+var _getLongitude$5 = _interopRequireDefault$d(getLongitude$1);
+var _toRad$4 = _interopRequireDefault$d(toRad$1);
+var _toDeg$3 = _interopRequireDefault$d(toDeg$1);
+var _constants$1 = constants;
+function _interopRequireDefault$d(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getBoundsOfDistance = function getBoundsOfDistance2(point, distance) {
+  var latitude = (0, _getLatitude$5.default)(point);
+  var longitude = (0, _getLongitude$5.default)(point);
+  var radLat = (0, _toRad$4.default)(latitude);
+  var radLon = (0, _toRad$4.default)(longitude);
+  var radDist = distance / _constants$1.earthRadius;
+  var minLat = radLat - radDist;
+  var maxLat = radLat + radDist;
+  var MAX_LAT_RAD = (0, _toRad$4.default)(_constants$1.MAXLAT);
+  var MIN_LAT_RAD = (0, _toRad$4.default)(_constants$1.MINLAT);
+  var MAX_LON_RAD = (0, _toRad$4.default)(_constants$1.MAXLON);
+  var MIN_LON_RAD = (0, _toRad$4.default)(_constants$1.MINLON);
+  var minLon;
+  var maxLon;
+  if (minLat > MIN_LAT_RAD && maxLat < MAX_LAT_RAD) {
+    var deltaLon = Math.asin(Math.sin(radDist) / Math.cos(radLat));
+    minLon = radLon - deltaLon;
+    if (minLon < MIN_LON_RAD) {
+      minLon += Math.PI * 2;
+    }
+    maxLon = radLon + deltaLon;
+    if (maxLon > MAX_LON_RAD) {
+      maxLon -= Math.PI * 2;
+    }
+  } else {
+    minLat = Math.max(minLat, MIN_LAT_RAD);
+    maxLat = Math.min(maxLat, MAX_LAT_RAD);
+    minLon = MIN_LON_RAD;
+    maxLon = MAX_LON_RAD;
+  }
+  return [{ latitude: (0, _toDeg$3.default)(minLat), longitude: (0, _toDeg$3.default)(minLon) }, { latitude: (0, _toDeg$3.default)(maxLat), longitude: (0, _toDeg$3.default)(maxLon) }];
+};
+var _default$f = getBoundsOfDistance;
+getBoundsOfDistance$1.default = _default$f;
+var getCenter$1 = {};
+Object.defineProperty(getCenter$1, "__esModule", { value: true });
+getCenter$1.default = void 0;
+var _getLatitude$4 = _interopRequireDefault$c(getLatitude$1);
+var _getLongitude$4 = _interopRequireDefault$c(getLongitude$1);
+var _toRad$3 = _interopRequireDefault$c(toRad$1);
+var _toDeg$2 = _interopRequireDefault$c(toDeg$1);
+function _interopRequireDefault$c(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getCenter = function getCenter2(points) {
+  if (Array.isArray(points) === false || points.length === 0) {
+    return false;
+  }
+  var numberOfPoints = points.length;
+  var sum = points.reduce(function(acc, point) {
+    var pointLat = (0, _toRad$3.default)((0, _getLatitude$4.default)(point));
+    var pointLon = (0, _toRad$3.default)((0, _getLongitude$4.default)(point));
+    return { X: acc.X + Math.cos(pointLat) * Math.cos(pointLon), Y: acc.Y + Math.cos(pointLat) * Math.sin(pointLon), Z: acc.Z + Math.sin(pointLat) };
+  }, { X: 0, Y: 0, Z: 0 });
+  var X = sum.X / numberOfPoints;
+  var Y = sum.Y / numberOfPoints;
+  var Z = sum.Z / numberOfPoints;
+  return { longitude: (0, _toDeg$2.default)(Math.atan2(Y, X)), latitude: (0, _toDeg$2.default)(Math.atan2(Z, Math.sqrt(X * X + Y * Y))) };
+};
+var _default$e = getCenter;
+getCenter$1.default = _default$e;
+var getCenterOfBounds$1 = {};
+Object.defineProperty(getCenterOfBounds$1, "__esModule", { value: true });
+getCenterOfBounds$1.default = void 0;
+var _getBounds = _interopRequireDefault$b(getBounds$1);
+function _interopRequireDefault$b(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getCenterOfBounds = function getCenterOfBounds2(coords) {
+  var bounds = (0, _getBounds.default)(coords);
+  var latitude = bounds.minLat + (bounds.maxLat - bounds.minLat) / 2;
+  var longitude = bounds.minLng + (bounds.maxLng - bounds.minLng) / 2;
+  return { latitude: parseFloat(latitude.toFixed(6)), longitude: parseFloat(longitude.toFixed(6)) };
+};
+var _default$d = getCenterOfBounds;
+getCenterOfBounds$1.default = _default$d;
+var getCompassDirection$1 = {};
+var getRhumbLineBearing$1 = {};
+Object.defineProperty(getRhumbLineBearing$1, "__esModule", { value: true });
+getRhumbLineBearing$1.default = void 0;
+var _getLatitude$3 = _interopRequireDefault$a(getLatitude$1);
+var _getLongitude$3 = _interopRequireDefault$a(getLongitude$1);
+var _toRad$2 = _interopRequireDefault$a(toRad$1);
+var _toDeg$1 = _interopRequireDefault$a(toDeg$1);
+function _interopRequireDefault$a(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getRhumbLineBearing = function getRhumbLineBearing2(origin, dest) {
+  var diffLon = (0, _toRad$2.default)((0, _getLongitude$3.default)(dest)) - (0, _toRad$2.default)((0, _getLongitude$3.default)(origin));
+  var diffPhi = Math.log(Math.tan((0, _toRad$2.default)((0, _getLatitude$3.default)(dest)) / 2 + Math.PI / 4) / Math.tan((0, _toRad$2.default)((0, _getLatitude$3.default)(origin)) / 2 + Math.PI / 4));
+  if (Math.abs(diffLon) > Math.PI) {
+    if (diffLon > 0) {
+      diffLon = (Math.PI * 2 - diffLon) * -1;
+    } else {
+      diffLon = Math.PI * 2 + diffLon;
+    }
+  }
+  return ((0, _toDeg$1.default)(Math.atan2(diffLon, diffPhi)) + 360) % 360;
+};
+var _default$c = getRhumbLineBearing;
+getRhumbLineBearing$1.default = _default$c;
+Object.defineProperty(getCompassDirection$1, "__esModule", { value: true });
+getCompassDirection$1.default = void 0;
+var _getRhumbLineBearing = _interopRequireDefault$9(getRhumbLineBearing$1);
+function _interopRequireDefault$9(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getCompassDirection = function getCompassDirection2(origin, dest) {
+  var bearingFn = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : _getRhumbLineBearing.default;
+  var bearing = typeof bearingFn === "function" ? bearingFn(origin, dest) : (0, _getRhumbLineBearing.default)(origin, dest);
+  if (isNaN(bearing)) {
+    throw new Error("Could not calculate bearing for given points. Check your bearing function");
+  }
+  switch (Math.round(bearing / 22.5)) {
+    case 1:
+      return "NNE";
+    case 2:
+      return "NE";
+    case 3:
+      return "ENE";
+    case 4:
+      return "E";
+    case 5:
+      return "ESE";
+    case 6:
+      return "SE";
+    case 7:
+      return "SSE";
+    case 8:
+      return "S";
+    case 9:
+      return "SSW";
+    case 10:
+      return "SW";
+    case 11:
+      return "WSW";
+    case 12:
+      return "W";
+    case 13:
+      return "WNW";
+    case 14:
+      return "NW";
+    case 15:
+      return "NNW";
+    default:
+      return "N";
+  }
+};
+var _default$b = getCompassDirection;
+getCompassDirection$1.default = _default$b;
+var getDistanceFromLine$1 = {};
+Object.defineProperty(getDistanceFromLine$1, "__esModule", { value: true });
+getDistanceFromLine$1.default = void 0;
+var _getDistance$4 = _interopRequireDefault$8(getDistance$2);
+var _robustAcos = _interopRequireDefault$8(robustAcos$1);
+function _interopRequireDefault$8(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getDistanceFromLine = function getDistanceFromLine2(point, lineStart, lineEnd) {
+  var accuracy = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 1;
+  var d1 = (0, _getDistance$4.default)(lineStart, point, accuracy);
+  var d2 = (0, _getDistance$4.default)(point, lineEnd, accuracy);
+  var d3 = (0, _getDistance$4.default)(lineStart, lineEnd, accuracy);
+  var alpha = Math.acos((0, _robustAcos.default)((d1 * d1 + d3 * d3 - d2 * d2) / (2 * d1 * d3)));
+  var beta = Math.acos((0, _robustAcos.default)((d2 * d2 + d3 * d3 - d1 * d1) / (2 * d2 * d3)));
+  if (alpha > Math.PI / 2) {
+    return d1;
+  }
+  if (beta > Math.PI / 2) {
+    return d2;
+  }
+  return Math.sin(alpha) * d1;
+};
+var _default$a = getDistanceFromLine;
+getDistanceFromLine$1.default = _default$a;
+var getGreatCircleBearing$1 = {};
+Object.defineProperty(getGreatCircleBearing$1, "__esModule", { value: true });
+getGreatCircleBearing$1.default = void 0;
+var _getLatitude$2 = _interopRequireDefault$7(getLatitude$1);
+var _getLongitude$2 = _interopRequireDefault$7(getLongitude$1);
+var _toRad$1 = _interopRequireDefault$7(toRad$1);
+var _toDeg = _interopRequireDefault$7(toDeg$1);
+function _interopRequireDefault$7(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getGreatCircleBearing = function getGreatCircleBearing2(origin, dest) {
+  var destLat = (0, _getLatitude$2.default)(dest);
+  var detLon = (0, _getLongitude$2.default)(dest);
+  var originLat = (0, _getLatitude$2.default)(origin);
+  var originLon = (0, _getLongitude$2.default)(origin);
+  var bearing = ((0, _toDeg.default)(Math.atan2(Math.sin((0, _toRad$1.default)(detLon) - (0, _toRad$1.default)(originLon)) * Math.cos((0, _toRad$1.default)(destLat)), Math.cos((0, _toRad$1.default)(originLat)) * Math.sin((0, _toRad$1.default)(destLat)) - Math.sin((0, _toRad$1.default)(originLat)) * Math.cos((0, _toRad$1.default)(destLat)) * Math.cos((0, _toRad$1.default)(detLon) - (0, _toRad$1.default)(originLon)))) + 360) % 360;
+  return bearing;
+};
+var _default$9 = getGreatCircleBearing;
+getGreatCircleBearing$1.default = _default$9;
+var getPathLength$1 = {};
+Object.defineProperty(getPathLength$1, "__esModule", { value: true });
+getPathLength$1.default = void 0;
+var _getDistance$3 = _interopRequireDefault$6(getDistance$2);
+function _interopRequireDefault$6(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof2(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof = function _typeof2(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof(obj);
+}
+var getPathLength = function getPathLength2(points) {
+  var distanceFn = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _getDistance$3.default;
+  return points.reduce(function(acc, point) {
+    if (_typeof(acc) === "object" && acc.last !== null) {
+      acc.distance += distanceFn(point, acc.last);
+    }
+    acc.last = point;
+    return acc;
+  }, { last: null, distance: 0 }).distance;
+};
+var _default$8 = getPathLength;
+getPathLength$1.default = _default$8;
+var getPreciseDistance = {};
+Object.defineProperty(getPreciseDistance, "__esModule", { value: true });
+getPreciseDistance.default = void 0;
+var _getLatitude$1 = _interopRequireDefault$5(getLatitude$1);
+var _getLongitude$1 = _interopRequireDefault$5(getLongitude$1);
+var _toRad = _interopRequireDefault$5(toRad$1);
+var _constants = constants;
+function _interopRequireDefault$5(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getDistance2 = function getDistance3(start, end) {
+  var accuracy = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1;
+  accuracy = typeof accuracy !== "undefined" && !isNaN(accuracy) ? accuracy : 1;
+  var startLat = (0, _getLatitude$1.default)(start);
+  var startLon = (0, _getLongitude$1.default)(start);
+  var endLat = (0, _getLatitude$1.default)(end);
+  var endLon = (0, _getLongitude$1.default)(end);
+  var b = 6356752314245e-6;
+  var ellipsoidParams = 1 / 298.257223563;
+  var L = (0, _toRad.default)(endLon - startLon);
+  var cosSigma;
+  var sigma;
+  var sinAlpha;
+  var cosSqAlpha;
+  var cos2SigmaM;
+  var sinSigma;
+  var U1 = Math.atan((1 - ellipsoidParams) * Math.tan((0, _toRad.default)(parseFloat(startLat))));
+  var U2 = Math.atan((1 - ellipsoidParams) * Math.tan((0, _toRad.default)(parseFloat(endLat))));
+  var sinU1 = Math.sin(U1);
+  var cosU1 = Math.cos(U1);
+  var sinU2 = Math.sin(U2);
+  var cosU2 = Math.cos(U2);
+  var lambda = L;
+  var lambdaP;
+  var iterLimit = 100;
+  do {
+    var sinLambda = Math.sin(lambda);
+    var cosLambda = Math.cos(lambda);
+    sinSigma = Math.sqrt(cosU2 * sinLambda * (cosU2 * sinLambda) + (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) * (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda));
+    if (sinSigma === 0) {
+      return 0;
+    }
+    cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda;
+    sigma = Math.atan2(sinSigma, cosSigma);
+    sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma;
+    cosSqAlpha = 1 - sinAlpha * sinAlpha;
+    cos2SigmaM = cosSigma - 2 * sinU1 * sinU2 / cosSqAlpha;
+    if (isNaN(cos2SigmaM)) {
+      cos2SigmaM = 0;
+    }
+    var C = ellipsoidParams / 16 * cosSqAlpha * (4 + ellipsoidParams * (4 - 3 * cosSqAlpha));
+    lambdaP = lambda;
+    lambda = L + (1 - C) * ellipsoidParams * sinAlpha * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));
+  } while (Math.abs(lambda - lambdaP) > 1e-12 && --iterLimit > 0);
+  if (iterLimit === 0) {
+    return NaN;
+  }
+  var uSq = cosSqAlpha * (_constants.earthRadius * _constants.earthRadius - b * b) / (b * b);
+  var A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+  var B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+  var deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2SigmaM * cos2SigmaM)));
+  var distance = b * A * (sigma - deltaSigma);
+  return Math.round(distance / accuracy) * accuracy;
+};
+var _default$7 = getDistance2;
+getPreciseDistance.default = _default$7;
+var getRoughCompassDirection$1 = {};
+Object.defineProperty(getRoughCompassDirection$1, "__esModule", { value: true });
+getRoughCompassDirection$1.default = void 0;
+var getRoughCompassDirection = function getRoughCompassDirection2(exact) {
+  if (/^(NNE|NE|NNW|N)$/.test(exact)) {
+    return "N";
+  }
+  if (/^(ENE|E|ESE|SE)$/.test(exact)) {
+    return "E";
+  }
+  if (/^(SSE|S|SSW|SW)$/.test(exact)) {
+    return "S";
+  }
+  if (/^(WSW|W|WNW|NW)$/.test(exact)) {
+    return "W";
+  }
+};
+var _default$6 = getRoughCompassDirection;
+getRoughCompassDirection$1.default = _default$6;
+var getSpeed$1 = {};
+Object.defineProperty(getSpeed$1, "__esModule", { value: true });
+getSpeed$1.default = void 0;
+var _getDistance$2 = _interopRequireDefault$4(getDistance$2);
+function _interopRequireDefault$4(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var getSpeed = function getSpeed2(start, end) {
+  var distanceFn = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : _getDistance$2.default;
+  var distance = distanceFn(start, end);
+  var time = Number(end.time) - Number(start.time);
+  var metersPerSecond = distance / time * 1e3;
+  return metersPerSecond;
+};
+var _default$5 = getSpeed;
+getSpeed$1.default = _default$5;
+var isPointInLine$1 = {};
+Object.defineProperty(isPointInLine$1, "__esModule", { value: true });
+isPointInLine$1.default = void 0;
+var _getDistance$1 = _interopRequireDefault$3(getDistance$2);
+function _interopRequireDefault$3(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var isPointInLine = function isPointInLine2(point, lineStart, lineEnd) {
+  return (0, _getDistance$1.default)(lineStart, point) + (0, _getDistance$1.default)(point, lineEnd) === (0, _getDistance$1.default)(lineStart, lineEnd);
+};
+var _default$4 = isPointInLine;
+isPointInLine$1.default = _default$4;
+var isPointInPolygon$1 = {};
+Object.defineProperty(isPointInPolygon$1, "__esModule", { value: true });
+isPointInPolygon$1.default = void 0;
+var _getLatitude = _interopRequireDefault$2(getLatitude$1);
+var _getLongitude = _interopRequireDefault$2(getLongitude$1);
+function _interopRequireDefault$2(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var isPointInPolygon = function isPointInPolygon2(point, polygon) {
+  var isInside = false;
+  var totalPolys = polygon.length;
+  for (var i = -1, j = totalPolys - 1; ++i < totalPolys; j = i) {
+    if (((0, _getLongitude.default)(polygon[i]) <= (0, _getLongitude.default)(point) && (0, _getLongitude.default)(point) < (0, _getLongitude.default)(polygon[j]) || (0, _getLongitude.default)(polygon[j]) <= (0, _getLongitude.default)(point) && (0, _getLongitude.default)(point) < (0, _getLongitude.default)(polygon[i])) && (0, _getLatitude.default)(point) < ((0, _getLatitude.default)(polygon[j]) - (0, _getLatitude.default)(polygon[i])) * ((0, _getLongitude.default)(point) - (0, _getLongitude.default)(polygon[i])) / ((0, _getLongitude.default)(polygon[j]) - (0, _getLongitude.default)(polygon[i])) + (0, _getLatitude.default)(polygon[i])) {
+      isInside = !isInside;
+    }
+  }
+  return isInside;
+};
+var _default$3 = isPointInPolygon;
+isPointInPolygon$1.default = _default$3;
+var isPointNearLine$1 = {};
+Object.defineProperty(isPointNearLine$1, "__esModule", { value: true });
+isPointNearLine$1.default = void 0;
+var _getDistanceFromLine = _interopRequireDefault$1(getDistanceFromLine$1);
+function _interopRequireDefault$1(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var isPointNearLine = function isPointNearLine2(point, start, end, distance) {
+  return (0, _getDistanceFromLine.default)(point, start, end) < distance;
+};
+var _default$2 = isPointNearLine;
+isPointNearLine$1.default = _default$2;
+var isPointWithinRadius$1 = {};
+Object.defineProperty(isPointWithinRadius$1, "__esModule", { value: true });
+isPointWithinRadius$1.default = void 0;
+var _getDistance = _interopRequireDefault(getDistance$2);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+var isPointWithinRadius = function isPointWithinRadius2(point, center, radius) {
+  var accuracy = 0.01;
+  return (0, _getDistance.default)(point, center, accuracy) < radius;
+};
+var _default$1 = isPointWithinRadius;
+isPointWithinRadius$1.default = _default$1;
+var wktToPolygon$1 = {};
+Object.defineProperty(wktToPolygon$1, "__esModule", { value: true });
+wktToPolygon$1.default = void 0;
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+  return arr2;
+}
+function _iterableToArrayLimit(arr, i) {
+  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = void 0;
+  try {
+    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+  return _arr;
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+var wktToPolygon = function wktToPolygon2(wkt) {
+  if (!wkt.startsWith("POLYGON")) {
+    throw new Error("Invalid wkt.");
+  }
+  var coordsText = wkt.slice(wkt.indexOf("(") + 2, wkt.indexOf(")")).split(", ");
+  var polygon = coordsText.map(function(coordText) {
+    var _coordText$split = coordText.split(" "), _coordText$split2 = _slicedToArray(_coordText$split, 2), longitude = _coordText$split2[0], latitude = _coordText$split2[1];
+    return { longitude: parseFloat(longitude), latitude: parseFloat(latitude) };
+  });
+  return polygon;
+};
+var _default = wktToPolygon;
+wktToPolygon$1.default = _default;
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var _exportNames = { computeDestinationPoint: true, convertArea: true, convertDistance: true, convertSpeed: true, decimalToSexagesimal: true, findNearest: true, getAreaOfPolygon: true, getBounds: true, getBoundsOfDistance: true, getCenter: true, getCenterOfBounds: true, getCompassDirection: true, getCoordinateKey: true, getCoordinateKeys: true, getDistance: true, getDistanceFromLine: true, getGreatCircleBearing: true, getLatitude: true, getLongitude: true, getPathLength: true, getPreciseDistance: true, getRhumbLineBearing: true, getRoughCompassDirection: true, getSpeed: true, isDecimal: true, isPointInLine: true, isPointInPolygon: true, isPointNearLine: true, isPointWithinRadius: true, isSexagesimal: true, isValidCoordinate: true, isValidLatitude: true, isValidLongitude: true, orderByDistance: true, sexagesimalToDecimal: true, toDecimal: true, toRad: true, toDeg: true, wktToPolygon: true };
+  Object.defineProperty(exports, "computeDestinationPoint", { enumerable: true, get: function get() {
+    return _computeDestinationPoint.default;
+  } });
+  Object.defineProperty(exports, "convertArea", { enumerable: true, get: function get() {
+    return _convertArea.default;
+  } });
+  Object.defineProperty(exports, "convertDistance", { enumerable: true, get: function get() {
+    return _convertDistance.default;
+  } });
+  Object.defineProperty(exports, "convertSpeed", { enumerable: true, get: function get() {
+    return _convertSpeed.default;
+  } });
+  Object.defineProperty(exports, "decimalToSexagesimal", { enumerable: true, get: function get() {
+    return _decimalToSexagesimal.default;
+  } });
+  Object.defineProperty(exports, "findNearest", { enumerable: true, get: function get() {
+    return _findNearest.default;
+  } });
+  Object.defineProperty(exports, "getAreaOfPolygon", { enumerable: true, get: function get() {
+    return _getAreaOfPolygon.default;
+  } });
+  Object.defineProperty(exports, "getBounds", { enumerable: true, get: function get() {
+    return _getBounds2.default;
+  } });
+  Object.defineProperty(exports, "getBoundsOfDistance", { enumerable: true, get: function get() {
+    return _getBoundsOfDistance.default;
+  } });
+  Object.defineProperty(exports, "getCenter", { enumerable: true, get: function get() {
+    return _getCenter.default;
+  } });
+  Object.defineProperty(exports, "getCenterOfBounds", { enumerable: true, get: function get() {
+    return _getCenterOfBounds.default;
+  } });
+  Object.defineProperty(exports, "getCompassDirection", { enumerable: true, get: function get() {
+    return _getCompassDirection.default;
+  } });
+  Object.defineProperty(exports, "getCoordinateKey", { enumerable: true, get: function get() {
+    return _getCoordinateKey2.default;
+  } });
+  Object.defineProperty(exports, "getCoordinateKeys", { enumerable: true, get: function get() {
+    return _getCoordinateKeys3.default;
+  } });
+  Object.defineProperty(exports, "getDistance", { enumerable: true, get: function get() {
+    return _getDistance2.default;
+  } });
+  Object.defineProperty(exports, "getDistanceFromLine", { enumerable: true, get: function get() {
+    return _getDistanceFromLine2.default;
+  } });
+  Object.defineProperty(exports, "getGreatCircleBearing", { enumerable: true, get: function get() {
+    return _getGreatCircleBearing.default;
+  } });
+  Object.defineProperty(exports, "getLatitude", { enumerable: true, get: function get() {
+    return _getLatitude2.default;
+  } });
+  Object.defineProperty(exports, "getLongitude", { enumerable: true, get: function get() {
+    return _getLongitude2.default;
+  } });
+  Object.defineProperty(exports, "getPathLength", { enumerable: true, get: function get() {
+    return _getPathLength.default;
+  } });
+  Object.defineProperty(exports, "getPreciseDistance", { enumerable: true, get: function get() {
+    return _getPreciseDistance.default;
+  } });
+  Object.defineProperty(exports, "getRhumbLineBearing", { enumerable: true, get: function get() {
+    return _getRhumbLineBearing2.default;
+  } });
+  Object.defineProperty(exports, "getRoughCompassDirection", { enumerable: true, get: function get() {
+    return _getRoughCompassDirection.default;
+  } });
+  Object.defineProperty(exports, "getSpeed", { enumerable: true, get: function get() {
+    return _getSpeed.default;
+  } });
+  Object.defineProperty(exports, "isDecimal", { enumerable: true, get: function get() {
+    return _isDecimal2.default;
+  } });
+  Object.defineProperty(exports, "isPointInLine", { enumerable: true, get: function get() {
+    return _isPointInLine.default;
+  } });
+  Object.defineProperty(exports, "isPointInPolygon", { enumerable: true, get: function get() {
+    return _isPointInPolygon.default;
+  } });
+  Object.defineProperty(exports, "isPointNearLine", { enumerable: true, get: function get() {
+    return _isPointNearLine.default;
+  } });
+  Object.defineProperty(exports, "isPointWithinRadius", { enumerable: true, get: function get() {
+    return _isPointWithinRadius.default;
+  } });
+  Object.defineProperty(exports, "isSexagesimal", { enumerable: true, get: function get() {
+    return _isSexagesimal2.default;
+  } });
+  Object.defineProperty(exports, "isValidCoordinate", { enumerable: true, get: function get() {
+    return _isValidCoordinate2.default;
+  } });
+  Object.defineProperty(exports, "isValidLatitude", { enumerable: true, get: function get() {
+    return _isValidLatitude2.default;
+  } });
+  Object.defineProperty(exports, "isValidLongitude", { enumerable: true, get: function get() {
+    return _isValidLongitude2.default;
+  } });
+  Object.defineProperty(exports, "orderByDistance", { enumerable: true, get: function get() {
+    return _orderByDistance2.default;
+  } });
+  Object.defineProperty(exports, "sexagesimalToDecimal", { enumerable: true, get: function get() {
+    return _sexagesimalToDecimal2.default;
+  } });
+  Object.defineProperty(exports, "toDecimal", { enumerable: true, get: function get() {
+    return _toDecimal2.default;
+  } });
+  Object.defineProperty(exports, "toRad", { enumerable: true, get: function get() {
+    return _toRad2.default;
+  } });
+  Object.defineProperty(exports, "toDeg", { enumerable: true, get: function get() {
+    return _toDeg2.default;
+  } });
+  Object.defineProperty(exports, "wktToPolygon", { enumerable: true, get: function get() {
+    return _wktToPolygon.default;
+  } });
+  var _computeDestinationPoint = _interopRequireDefault2(computeDestinationPoint$1);
+  var _convertArea = _interopRequireDefault2(convertArea$1);
+  var _convertDistance = _interopRequireDefault2(convertDistance$1);
+  var _convertSpeed = _interopRequireDefault2(convertSpeed$1);
+  var _decimalToSexagesimal = _interopRequireDefault2(decimalToSexagesimal);
+  var _findNearest = _interopRequireDefault2(findNearest$1);
+  var _getAreaOfPolygon = _interopRequireDefault2(getAreaOfPolygon$1);
+  var _getBounds2 = _interopRequireDefault2(getBounds$1);
+  var _getBoundsOfDistance = _interopRequireDefault2(getBoundsOfDistance$1);
+  var _getCenter = _interopRequireDefault2(getCenter$1);
+  var _getCenterOfBounds = _interopRequireDefault2(getCenterOfBounds$1);
+  var _getCompassDirection = _interopRequireDefault2(getCompassDirection$1);
+  var _getCoordinateKey2 = _interopRequireDefault2(getCoordinateKey$1);
+  var _getCoordinateKeys3 = _interopRequireDefault2(getCoordinateKeys$1);
+  var _getDistance2 = _interopRequireDefault2(getDistance$2);
+  var _getDistanceFromLine2 = _interopRequireDefault2(getDistanceFromLine$1);
+  var _getGreatCircleBearing = _interopRequireDefault2(getGreatCircleBearing$1);
+  var _getLatitude2 = _interopRequireDefault2(getLatitude$1);
+  var _getLongitude2 = _interopRequireDefault2(getLongitude$1);
+  var _getPathLength = _interopRequireDefault2(getPathLength$1);
+  var _getPreciseDistance = _interopRequireDefault2(getPreciseDistance);
+  var _getRhumbLineBearing2 = _interopRequireDefault2(getRhumbLineBearing$1);
+  var _getRoughCompassDirection = _interopRequireDefault2(getRoughCompassDirection$1);
+  var _getSpeed = _interopRequireDefault2(getSpeed$1);
+  var _isDecimal2 = _interopRequireDefault2(isDecimal$1);
+  var _isPointInLine = _interopRequireDefault2(isPointInLine$1);
+  var _isPointInPolygon = _interopRequireDefault2(isPointInPolygon$1);
+  var _isPointNearLine = _interopRequireDefault2(isPointNearLine$1);
+  var _isPointWithinRadius = _interopRequireDefault2(isPointWithinRadius$1);
+  var _isSexagesimal2 = _interopRequireDefault2(isSexagesimal$1);
+  var _isValidCoordinate2 = _interopRequireDefault2(isValidCoordinate$1);
+  var _isValidLatitude2 = _interopRequireDefault2(isValidLatitude$1);
+  var _isValidLongitude2 = _interopRequireDefault2(isValidLongitude$1);
+  var _orderByDistance2 = _interopRequireDefault2(orderByDistance$1);
+  var _sexagesimalToDecimal2 = _interopRequireDefault2(sexagesimalToDecimal$1);
+  var _toDecimal2 = _interopRequireDefault2(toDecimal$1);
+  var _toRad2 = _interopRequireDefault2(toRad$1);
+  var _toDeg2 = _interopRequireDefault2(toDeg$1);
+  var _wktToPolygon = _interopRequireDefault2(wktToPolygon$1);
+  var _constants2 = constants;
+  Object.keys(_constants2).forEach(function(key) {
+    if (key === "default" || key === "__esModule") return;
+    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+    Object.defineProperty(exports, key, { enumerable: true, get: function get() {
+      return _constants2[key];
+    } });
+  });
+  function _interopRequireDefault2(obj) {
+    return obj && obj.__esModule ? obj : { default: obj };
+  }
+})(es);
+const vs = `/**
+ * Copyright (c) 2022, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#define SHADER_NAME "arrow-layer-vertex-shader"
+
+precision highp float;
+
+attribute vec3 positions;
+
+attribute float instanceSize;
+attribute float instanceArrowDistance;
+attribute vec4 instanceColor;
+attribute float instanceSpeedFactor;
+attribute float instanceLinePositionsTextureOffset;
+attribute float instanceLineDistancesTextureOffset;
+attribute float instanceLinePointCount;
+attribute float instanceLineDistance;
+attribute float instanceArrowDirection;
+attribute float instanceLineParallelIndex;
+attribute vec3 instanceLineAngles;
+attribute vec2 instanceProximityFactors;
+
+uniform float sizeMinPixels;
+uniform float sizeMaxPixels;
+uniform float timestamp;
+uniform sampler2D linePositionsTexture;
+uniform sampler2D lineDistancesTexture;
+uniform ivec2 linePositionsTextureSize;
+uniform ivec2 lineDistancesTextureSize;
+uniform float webgl2;
+uniform float distanceBetweenLines;
+uniform float maxParallelOffset;
+uniform float minParallelOffset;
+uniform float opacity;
+
+varying vec4 vFillColor;
+varying float shouldDiscard;
+
+vec4 texelFetch(sampler2D sampler, ivec2 index, ivec2 size) {
+    float x = (2.0 * float(index.x) + 1.0) / (2.0 * float(size.x));
+    float y = (2.0 * float(index.y) + 1.0) / (2.0 * float(size.y));
+    return texture2D(sampler, vec2(x, y));
+}
+
+/**
+ * Calculate 2 dimensions texture index from flat index.
+ */
+ivec2 calculateTextureIndex(int flatIndex, ivec2 textureSize) {
+    int x = flatIndex - flatIndex / textureSize.x * textureSize.x;
+    int y = flatIndex / textureSize.y;
+    return ivec2(x, y);
+}
+
+/**
+ * Fetch WGS84 position from texture for a given point of the line.
+ */
+vec3 fetchLinePosition(int point) {
+    int flatIndex = int(instanceLinePositionsTextureOffset) + point;
+    ivec2 textureIndex = calculateTextureIndex(flatIndex, linePositionsTextureSize);
+    vec4 color = texelFetch(linePositionsTexture, textureIndex, linePositionsTextureSize);
+    float x = color.r;
+    float y = webgl2 > 0.5 ? color.g : color.a;
+    return vec3(x, y, 0);
+}
+
+/**
+ * Fetch distance (in meters from the start of the line) from texture for a point of the line.
+ */
+float fetchLineDistance(int point) {
+    int flatIndex = int(instanceLineDistancesTextureOffset) + point;
+    ivec2 textureIndex = calculateTextureIndex(flatIndex, lineDistancesTextureSize);
+    return texelFetch(lineDistancesTexture, textureIndex, lineDistancesTextureSize).r;
+}
+
+/**
+ * Find the first point of the line that is after a given distance from the start (first line point).
+ * (implemented using a binary search)
+ * The returned value is always between 1 and instanceLinePointCount - 1, even if the searched distance is out of bounds
+ * Here are example returned values for a path having points at distance 0.0, 10.0, 20.0
+ * -1 => 1
+ *  0 => 1
+ *  1 => 1
+ *  9 => 1
+ *  10 => 2
+ *  11 => 2
+ *  19 => 2
+ *  20 => 2
+ *  21 => 2
+ */
+int findFirstLinePointAfterDistance(float distance) {
+    int firstPoint = 0;
+    int lastPoint = int(instanceLinePointCount) - 1;
+
+    // variable length loops are not supported in WebGL v1, it needs to be a constant and cannot be like in WebGL v2 an
+    // attribute, so we suppose here that we won't have more that 2^log2MaxPointCount points per line...
+    //
+    // WARNING!!!!
+    // also, we need to avoid break/return in the for loop even if search complete because with a WebGL1 browser
+    // it is not possible to call texture2D inside a non deterministic piece of code
+    // https://shadertoyunofficial.wordpress.com/2017/11/19/avoiding-compiler-crash-or-endless-compilation
+    const int log2MaxPointCount = 15;
+    for (int i = 0; i < log2MaxPointCount; i++) {
+        if (firstPoint + 1 != lastPoint) {
+            int middlePoint = (firstPoint + lastPoint) / 2;
+            float middlePointDistance = fetchLineDistance(middlePoint);
+            if (middlePointDistance <= distance) {
+                firstPoint = middlePoint;
+            } else {
+                lastPoint = middlePoint;
+            }
+        }
+    }
+    return lastPoint;
+}
+
+mat3 calculateRotation(vec3 commonPosition1, vec3 commonPosition2) {
+    float angle = atan(commonPosition1.x - commonPosition2.x, commonPosition1.y - commonPosition2.y);
+    if (instanceArrowDirection < 2.0) {
+        angle += radians(180.0);
+    }
+    return mat3(cos(angle), sin(angle), 0, -sin(angle), cos(angle), 0, 0, 0, 0);
+}
+
+/**
+ * Adjustment factor for low zoom levels
+ * Code from deck.gl/modules/core/src/shaderlib/project/project.glsl.ts. We don't have access to this method from here. 
+ * Just to call it from project_size_all_zoom_levels().
+ * Function renamed to project_size_at_latitude_low_zoom, to prevent conflicts with the original code.
+ */
+float project_size_at_latitude_low_zoom(float lat) {
+    float y = clamp(lat, -89.9, 89.9);
+    return 1.0 / cos(radians(y));
+}
+
+/**
+ * Forked version of project_size() from deck.gl deck.gl/modules/core/src/shaderlib/project/project.glsl.ts
+ * Converts the size from the world space (meters) to the common space.
+ * When the zoom level is lower than 12 (zoomed out), we use the arrow latitude to calculate the projection. 
+ * When the zoom level is higher than 12 (zoomed in), we fallback on the standard deck.gl project_size() which uses geometry.position.y. 
+ * I'm not sure why there is a change at zoomLevel = 12, but there seem to be some optimizations on the deck.gl side
+ * (see: https://github.com/visgl/deck.gl/blob/401d624c0529faaa62125714c376b3ba3b8f379f/dev-docs/RFCs/v6.1/improved-lnglat-projection-rfc.md?plain=1#L29)
+ */
+float project_size_all_zoom_levels(float meters, float lat) {
+    // We use project_uScale = 4096 (2^12) which corresponds to zoom = 12
+    if (project_uScale < 4096.0) {
+        return meters * project_uCommonUnitsPerMeter.z * project_size_at_latitude_low_zoom(lat);
+    }
+    return project_size(meters);
+}
+
+void main(void ) {
+    if (instanceArrowDirection < 1.0) {
+        vFillColor = vec4(0, 0, 0, 0);
+        shouldDiscard = 1.0;
+    } else {
+        // arrow distance from the line start shifted with current timestamp
+        // instanceArrowDistance: a float in interval [0,1] describing the initial position of the arrow along the full path between two substations (0: begin, 1.0 end)
+        float arrowDistance = mod(
+            instanceLineDistance * instanceArrowDistance +
+                (instanceArrowDirection < 2.0 ? 1.0 : -1.0) * timestamp * instanceSpeedFactor,
+            instanceLineDistance
+        );
+
+        // look for first line point that is after arrow distance
+        int linePoint = findFirstLinePointAfterDistance(arrowDistance);
+
+        // Interpolate the 2 line points position
+        float lineDistance1 = fetchLineDistance(linePoint - 1);
+        float lineDistance2 = fetchLineDistance(linePoint);
+        float interpolationValue = (arrowDistance - lineDistance1) / (lineDistance2 - lineDistance1);
+
+        // position for the line point just before the arrow
+        vec3 linePosition1 = fetchLinePosition(linePoint - 1);
+
+        // position for the line point just after the arrow
+        vec3 linePosition2 = fetchLinePosition(linePoint);
+
+        // clamp to arrow size limits
+        float sizePixels = clamp(project_size_to_pixel(instanceSize), sizeMinPixels, sizeMaxPixels);
+
+        // project the 2 line points position to common space
+        vec3 position64Low = vec3(0, 0, 0);
+        vec3 commonPosition1 = project_position(linePosition1, position64Low);
+        vec3 commonPosition2 = project_position(linePosition2, position64Low);
+
+        // We call our own project_size_all_zoom_levels() instead of project_size() from deck.gl as the latter causes a bug: the arrows
+        // are not correctly positioned on the lines, they are slightly off.
+        // This hack does not seem necessary for parallel-path or fork-line layers.
+        vec3 arrowPositionWorldSpace = mix(linePosition1, linePosition2, interpolationValue);
+        float offsetCommonSpace = clamp(
+            project_size_all_zoom_levels(distanceBetweenLines, arrowPositionWorldSpace.y),
+            project_pixel_size(minParallelOffset),
+            project_pixel_size(maxParallelOffset)
+        );
+
+        // calculate translation for the parallels lines, use the angle calculated from origin/destination
+        // to maintain the same translation between segments
+        float instanceLineAngle1 = instanceLineAngles[1];
+        float instanceLineAngle2 = instanceLineAngles[1];
+        if (linePoint == 1) {
+            instanceLineAngle1 = instanceLineAngles[0];
+        }
+        if (linePoint == int(instanceLinePointCount) - 1) {
+            instanceLineAngle2 = instanceLineAngles[2];
+        }
+        vec3 transOr = vec3(cos(instanceLineAngle1), -sin(instanceLineAngle1), 0.0) * instanceLineParallelIndex;
+        if (linePoint == 1) {
+            transOr.x -= sin(instanceLineAngle1) * instanceProximityFactors[0];
+            transOr.y -= cos(instanceLineAngle1) * instanceProximityFactors[0];
+        }
+        commonPosition1 += transOr * offsetCommonSpace;
+        vec3 transEx = vec3(cos(instanceLineAngle2), -sin(instanceLineAngle2), 0.0) * instanceLineParallelIndex;
+        if (linePoint == int(instanceLinePointCount) - 1) {
+            transEx.x += sin(instanceLineAngle2) * instanceProximityFactors[1];
+            transEx.y += cos(instanceLineAngle2) * instanceProximityFactors[1];
+        }
+        commonPosition2 += transEx * offsetCommonSpace;
+
+        // calculate arrow position in the common space by interpolating the 2 line points position
+        vec3 arrowPosition = mix(commonPosition1, commonPosition2, interpolationValue);
+
+        // calculate rotation angle for aligning the arrow with the line segment
+        // it has to be done in the common space to get the right angle!!!
+        mat3 rotation = calculateRotation(commonPosition1, commonPosition2);
+
+        // calculate vertex position in the clipspace
+        vec3 offset = positions * project_pixel_size(sizePixels) * rotation;
+        vec4 vertexPosition = project_common_position_to_clipspace(vec4(arrowPosition + offset, 1));
+
+        // vertex shader output
+        gl_Position = vertexPosition;
+
+        // arrow fill color for fragment shader
+        vFillColor = vec4(instanceColor.rgb, opacity);
+        shouldDiscard = 0.0;
+    }
+}
+`;
+const fs = '/**\n * Copyright (c) 2022, RTE (http://www.rte-france.com)\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at http://mozilla.org/MPL/2.0/.\n */\n\n#define SHADER_NAME "arrow-layer-fragment-shader"\n\nprecision highp float;\n\nvarying vec4 vFillColor;\nvarying float shouldDiscard;\n\nvoid main(void ) {\n    if (shouldDiscard > 0.0) {\n        discard;\n    }\n    gl_FragColor = vFillColor;\n}\n';
+const DEFAULT_COLOR = [0, 0, 0, 255];
+const MAX_LINE_POINT_COUNT = 2 ** 15;
+var ArrowDirection = /* @__PURE__ */ ((ArrowDirection2) => {
+  ArrowDirection2["NONE"] = "none";
+  ArrowDirection2["FROM_SIDE_1_TO_SIDE_2"] = "fromSide1ToSide2";
+  ArrowDirection2["FROM_SIDE_2_TO_SIDE_1"] = "fromSide2ToSide1";
+  return ArrowDirection2;
+})(ArrowDirection || {});
+const defaultProps$3 = {
+  sizeMinPixels: { type: "number", min: 0, value: 0 },
+  //  min size in pixels
+  sizeMaxPixels: { type: "number", min: 0, value: Number.MAX_SAFE_INTEGER },
+  // max size in pixels
+  getDistance: { type: "accessor", value: (arrow) => arrow.distance },
+  getLine: { type: "accessor", value: (arrow) => arrow.line },
+  getLinePositions: { type: "accessor", value: (line) => line.positions ?? [] },
+  getSize: { type: "accessor", value: 1 },
+  getColor: { type: "accessor", value: DEFAULT_COLOR },
+  getSpeedFactor: { type: "accessor", value: 1 },
+  getDirection: {
+    type: "accessor",
+    value: "none"
+    /* NONE */
+  },
+  animated: { type: "boolean", value: true },
+  getLineParallelIndex: { type: "accessor", value: 0 },
+  getLineAngles: { type: "accessor", value: [0, 0, 0] },
+  // @ts-expect-error TODO TS2322: distanceBetweenLines does not exist in type DefaultProps<ArrowLayerProps>. Did you mean to write getDistanceBetweenLines?
+  distanceBetweenLines: { type: "number", value: 1e3 },
+  maxParallelOffset: { type: "number", value: 100 },
+  minParallelOffset: { type: "number", value: 3 },
+  opacity: { type: "number", value: 1 }
+};
+const _ArrowLayer = class _ArrowLayer extends Layer {
+  getShaders() {
+    return super.getShaders({ vs, fs, modules: [project32, picking] });
+  }
+  getArrowLineAttributes(arrow) {
+    var _a;
+    const line = this.props.getLine(arrow);
+    if (!line) {
+      throw new Error("Invalid line");
+    }
+    const attributes = (_a = this.state.lineAttributes) == null ? void 0 : _a.get(line);
+    if (!attributes) {
+      throw new Error(`Line ${line.id} not found`);
+    }
+    return attributes;
+  }
+  initializeState() {
+    var _a;
+    const { gl } = this.context;
+    if (!hasFeatures(gl, [FEATURES.TEXTURE_FLOAT])) {
+      throw new Error("Arrow layer not supported on this browser");
+    }
+    const maxTextureSize = gl.getParameter(GL.MAX_TEXTURE_SIZE);
+    this.state = {
+      maxTextureSize,
+      webgl2: isWebGL2(gl)
+    };
+    (_a = this.getAttributeManager()) == null ? void 0 : _a.addInstanced({
+      instanceSize: {
+        size: 1,
+        transition: true,
+        accessor: "getSize",
+        defaultValue: 1
+      },
+      instanceColor: {
+        size: this.props.colorFormat.length,
+        transition: true,
+        normalized: true,
+        type: GL.UNSIGNED_BYTE,
+        accessor: "getColor",
+        defaultValue: [0, 0, 0, 255]
+      },
+      instanceSpeedFactor: {
+        size: 1,
+        transition: true,
+        accessor: "getSpeedFactor",
+        defaultValue: 1
+      },
+      instanceArrowDistance: {
+        size: 1,
+        transition: true,
+        accessor: "getDistance",
+        type: GL.FLOAT,
+        defaultValue: 0
+      },
+      instanceArrowDirection: {
+        size: 1,
+        transition: true,
+        accessor: "getDirection",
+        transform: (direction) => {
+          switch (direction) {
+            case "none":
+              return 0;
+            case "fromSide1ToSide2":
+              return 1;
+            case "fromSide2ToSide1":
+              return 2;
+            default:
+              throw new Error("impossible");
+          }
+        },
+        defaultValue: 0
+      },
+      instanceLineDistance: {
+        size: 1,
+        transition: true,
+        type: GL.FLOAT,
+        accessor: (arrow) => this.getArrowLineAttributes(arrow).distance
+      },
+      instanceLinePositionsTextureOffset: {
+        size: 1,
+        transition: true,
+        type: GL.FLOAT,
+        accessor: (arrow) => this.getArrowLineAttributes(arrow).positionsTextureOffset
+      },
+      instanceLineDistancesTextureOffset: {
+        size: 1,
+        transition: true,
+        type: GL.FLOAT,
+        accessor: (arrow) => this.getArrowLineAttributes(arrow).distancesTextureOffset
+      },
+      instanceLinePointCount: {
+        size: 1,
+        transition: true,
+        type: GL.FLOAT,
+        accessor: (arrow) => this.getArrowLineAttributes(arrow).pointCount
+      },
+      instanceLineParallelIndex: {
+        size: 1,
+        accessor: "getLineParallelIndex",
+        type: GL.FLOAT
+      },
+      instanceLineAngles: {
+        size: 3,
+        accessor: "getLineAngles",
+        type: GL.FLOAT
+      },
+      instanceProximityFactors: {
+        size: 2,
+        accessor: "getProximityFactors",
+        type: GL.FLOAT
+      }
+    });
+  }
+  finalizeState(context) {
+    super.finalizeState(context);
+    this.state.stop = true;
+  }
+  createTexture2D(gl, data, elementSize, format, dataFormat) {
+    const start = performance.now();
+    const elementCount = data.length / elementSize;
+    const n = Math.ceil(Math.log2(elementCount) / 2);
+    const textureSize = 2 ** n;
+    const { maxTextureSize } = this.state;
+    if (textureSize > maxTextureSize) {
+      throw new Error(`Texture size (${textureSize}) cannot be greater than ${maxTextureSize}`);
+    }
+    if (data.length < textureSize * textureSize * elementSize) {
+      const oldLength = data.length;
+      data.length = textureSize * textureSize * elementSize;
+      data.fill(0, oldLength, textureSize * textureSize * elementSize);
+    }
+    const texture2d = new Texture2D(gl, {
+      width: textureSize,
+      height: textureSize,
+      format,
+      dataFormat,
+      type: GL.FLOAT,
+      data: new Float32Array(data),
+      parameters: {
+        [GL.TEXTURE_MAG_FILTER]: GL.NEAREST,
+        [GL.TEXTURE_MIN_FILTER]: GL.NEAREST,
+        [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
+        [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE
+      },
+      mipmaps: false
+    });
+    const stop = performance.now();
+    console.info(
+      `Texture of ${elementCount} elements (${textureSize} * ${textureSize}) created in ${stop - start} ms`
+    );
+    return texture2d;
+  }
+  createTexturesStructure(props) {
+    const start = performance.now();
+    const linePositionsTextureData = [];
+    const lineDistancesTextureData = [];
+    const lineAttributes = /* @__PURE__ */ new Map();
+    let lineDistance = 0;
+    const lines = [...new Set(props.data.map((arrow) => this.props.getLine(arrow)))];
+    lines.forEach((line) => {
+      const positions = props.getLinePositions(line);
+      if (!positions) {
+        throw new Error(`Invalid positions for line ${line.id}`);
+      }
+      const linePositionsTextureOffset = linePositionsTextureData.length / 2;
+      const lineDistancesTextureOffset = lineDistancesTextureData.length;
+      let linePointCount = 0;
+      if (positions.length > 0) {
+        positions.forEach((position) => {
+          linePositionsTextureData.push(position[0]);
+          linePositionsTextureData.push(position[1]);
+          linePointCount++;
+        });
+        lineDistancesTextureData.push(...line.cumulativeDistances ?? []);
+        lineDistance = line.cumulativeDistances[line.cumulativeDistances.length - 1];
+      }
+      if (linePointCount > MAX_LINE_POINT_COUNT) {
+        throw new Error(`Too many line point count (${linePointCount}), maximum is ${MAX_LINE_POINT_COUNT}`);
+      }
+      lineAttributes.set(line, {
+        distance: lineDistance,
+        positionsTextureOffset: linePositionsTextureOffset,
+        distancesTextureOffset: lineDistancesTextureOffset,
+        pointCount: linePointCount
+      });
+    });
+    const stop = performance.now();
+    console.info(`Texture data created in ${stop - start} ms`);
+    return {
+      linePositionsTextureData,
+      lineDistancesTextureData,
+      lineAttributes
+    };
+  }
+  updateGeometry({ props, changeFlags }) {
+    var _a;
+    const geometryChanged = changeFlags.dataChanged || changeFlags.updateTriggersChanged && (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getLinePositions);
+    if (geometryChanged) {
+      const { gl } = this.context;
+      const { linePositionsTextureData, lineDistancesTextureData, lineAttributes } = this.createTexturesStructure(props);
+      const linePositionsTexture = this.createTexture2D(
+        gl,
+        linePositionsTextureData,
+        2,
+        this.state.webgl2 ? GL.RG32F : GL.LUMINANCE_ALPHA,
+        this.state.webgl2 ? GL.RG : GL.LUMINANCE_ALPHA
+      );
+      const lineDistancesTexture = this.createTexture2D(
+        gl,
+        lineDistancesTextureData,
+        1,
+        this.state.webgl2 ? GL.R32F : GL.LUMINANCE,
+        this.state.webgl2 ? GL.RED : GL.LUMINANCE
+      );
+      this.setState({
+        linePositionsTexture,
+        lineDistancesTexture,
+        lineAttributes
+      });
+      if (!changeFlags.dataChanged) {
+        (_a = this.getAttributeManager()) == null ? void 0 : _a.invalidateAll();
+      }
+    }
+  }
+  updateModel({ changeFlags }) {
+    var _a;
+    if (changeFlags.extensionsChanged) {
+      const { gl } = this.context;
+      const { model } = this.state;
+      if (model) {
+        model.delete();
+      }
+      this.setState({
+        model: this._getModel(gl)
+      });
+      (_a = this.getAttributeManager()) == null ? void 0 : _a.invalidateAll();
+    }
+  }
+  updateState(updateParams) {
+    super.updateState(updateParams);
+    this.updateGeometry(updateParams);
+    this.updateModel(updateParams);
+    const { props, oldProps } = updateParams;
+    if (props.animated !== oldProps.animated) {
+      this.setState({
+        stop: !props.animated,
+        timestamp: 0
+      });
+      if (props.animated) {
+        this.startAnimation();
+      }
+    }
+  }
+  animate(timestamp) {
+    if (this.state.stop) {
+      return;
+    }
+    this.setState({
+      timestamp
+    });
+    this.startAnimation();
+  }
+  startAnimation() {
+    window.requestAnimationFrame((timestamp) => this.animate(timestamp));
+  }
+  // TODO find the full type for record values
+  draw({ uniforms }) {
+    var _a;
+    const { sizeMinPixels, sizeMaxPixels } = this.props;
+    const { linePositionsTexture, lineDistancesTexture, timestamp, webgl2 } = this.state;
+    (_a = this.state.model) == null ? void 0 : _a.setUniforms(uniforms).setUniforms({
+      sizeMinPixels,
+      sizeMaxPixels,
+      linePositionsTexture,
+      lineDistancesTexture,
+      // TODO we ask an opacity but we don't seem to set or used it?
+      // @ts-expect-error TODO TS2339: Properties width and height does not exists on type Texture2D
+      linePositionsTextureSize: [linePositionsTexture == null ? void 0 : linePositionsTexture.width, linePositionsTexture == null ? void 0 : linePositionsTexture.height],
+      // @ts-expect-error TODO TS2339: Properties width and height does not exists on type Texture2D
+      lineDistancesTextureSize: [lineDistancesTexture == null ? void 0 : lineDistancesTexture.width, lineDistancesTexture == null ? void 0 : lineDistancesTexture.height],
+      timestamp,
+      webgl2,
+      distanceBetweenLines: this.props.getDistanceBetweenLines,
+      maxParallelOffset: this.props.maxParallelOffset,
+      minParallelOffset: this.props.minParallelOffset
+    }).draw();
+  }
+  // TODO Did you mean getModels?
+  _getModel(gl) {
+    return new Model(
+      gl,
+      Object.assign(this.getShaders(), {
+        id: this.props.id,
+        geometry: new Geometry({
+          drawMode: GL.TRIANGLES,
+          vertexCount: 6,
+          attributes: {
+            positions: {
+              size: 3,
+              value: new Float32Array([-1, -1, 0, 0, 1, 0, 0, -0.6, 0, 1, -1, 0, 0, 1, 0, 0, -0.6, 0])
+            }
+          }
+        }),
+        isInstanced: true
+      })
+    );
+  }
+};
+_ArrowLayer.layerName = "ArrowLayer";
+_ArrowLayer.defaultProps = defaultProps$3;
+let ArrowLayer = _ArrowLayer;
+const substationPositionByIdIndexer = (map, substation) => {
+  map.set(substation.id, substation.coordinate);
+  return map;
+};
+const linePositionByIdIndexer = (map, line) => {
+  map.set(line.id, line.coordinates);
+  return map;
+};
+class GeoData {
+  constructor(substationPositionsById, linePositionsById) {
+    this.substationPositionsById = /* @__PURE__ */ new Map();
+    this.linePositionsById = /* @__PURE__ */ new Map();
+    this.substationPositionsById = substationPositionsById;
+    this.linePositionsById = linePositionsById;
+  }
+  setSubstationPositions(positions) {
+    this.substationPositionsById = positions.reduce(substationPositionByIdIndexer, /* @__PURE__ */ new Map());
+  }
+  updateSubstationPositions(substationIdsToUpdate, fetchedPositions) {
+    fetchedPositions.forEach((pos) => this.substationPositionsById.set(pos.id, pos.coordinate));
+    substationIdsToUpdate.filter((id) => !fetchedPositions.map((pos) => pos.id).includes(id)).forEach((id) => this.substationPositionsById.delete(id));
+  }
+  getSubstationPosition(substationId) {
+    const position = this.substationPositionsById.get(substationId);
+    if (!position) {
+      console.warn(`Position not found for ${substationId}`);
+      return [0, 0];
+    }
+    return [position.lon, position.lat];
+  }
+  setLinePositions(positions) {
+    this.linePositionsById = positions.reduce(linePositionByIdIndexer, /* @__PURE__ */ new Map());
+  }
+  updateLinePositions(lineIdsToUpdate, fetchedPositions) {
+    fetchedPositions.forEach((pos) => {
+      this.linePositionsById.set(pos.id, pos.coordinates);
+    });
+    lineIdsToUpdate.filter((id) => !fetchedPositions.map((pos) => pos.id).includes(id)).forEach((id) => this.linePositionsById.delete(id));
+  }
+  /**
+   * Get line positions always ordered from side 1 to side 2.
+   */
+  getLinePositions(network, line, detailed = true) {
+    const voltageLevel1 = network.getVoltageLevel(line.voltageLevelId1);
+    if (!voltageLevel1) {
+      throw new Error(`Voltage level side 1 '${line.voltageLevelId1}' not found`);
+    }
+    const voltageLevel2 = network.getVoltageLevel(line.voltageLevelId2);
+    if (!voltageLevel2) {
+      throw new Error(`Voltage level side 2 '${line.voltageLevelId1}' not found`);
+    }
+    const substationPosition1 = this.getSubstationPosition(voltageLevel1.substationId);
+    const substationPosition2 = this.getSubstationPosition(voltageLevel2.substationId);
+    if (substationPosition1[0] === 0 && substationPosition1[1] === 0 || substationPosition2[0] === 0 && substationPosition2[1] === 0) {
+      return [
+        [0, 0],
+        [0, 0]
+      ];
+    }
+    if (detailed) {
+      const linePositions = this.linePositionsById.get(line.id);
+      if (linePositions) {
+        const positions = new Array(linePositions.length);
+        for (const [index, position] of linePositions.entries()) {
+          positions[index] = [position.lon, position.lat];
+        }
+        return positions;
+      }
+    }
+    return [substationPosition1, substationPosition2];
+  }
+  getLineDistances(positions) {
+    if (positions !== null && positions.length > 1) {
+      const cumulativeDistanceArray = [0];
+      let cumulativeDistance = 0;
+      let segmentDistance;
+      let ruler;
+      for (let i = 0; i < positions.length - 1; i++) {
+        ruler = new CheapRuler(positions[i][1], "meters");
+        segmentDistance = ruler.lineDistance(positions.slice(i, i + 2));
+        cumulativeDistance = cumulativeDistance + segmentDistance;
+        cumulativeDistanceArray[i + 1] = cumulativeDistance;
+      }
+      return cumulativeDistanceArray;
+    }
+    return null;
+  }
+  /**
+   * Find the segment in which we reach the wanted distance and return the segment
+   * along with the remaining distance to travel on this segment to be at the exact wanted distance
+   * (implemented using a binary search)
+   */
+  findSegment(positions, cumulativeDistances, wantedDistance) {
+    let lowerBound = 0;
+    let upperBound = cumulativeDistances.length - 1;
+    let middlePoint;
+    while (lowerBound + 1 !== upperBound) {
+      middlePoint = Math.floor((lowerBound + upperBound) / 2);
+      const middlePointDistance = cumulativeDistances[middlePoint];
+      if (middlePointDistance <= wantedDistance) {
+        lowerBound = middlePoint;
+      } else {
+        upperBound = middlePoint;
+      }
+    }
+    return {
+      idx: lowerBound,
+      segment: positions.slice(lowerBound, lowerBound + 2),
+      remainingDistance: wantedDistance - cumulativeDistances[lowerBound]
+    };
+  }
+  labelDisplayPosition(positions, cumulativeDistances, arrowPosition, arrowDirection, lineParallelIndex, lineAngle, proximityAngle, distanceBetweenLines, proximityFactor) {
+    if (arrowPosition > 1 || arrowPosition < 0) {
+      throw new Error("Proportional position value incorrect: " + arrowPosition);
+    }
+    if (cumulativeDistances === null || cumulativeDistances.length < 2 || cumulativeDistances[cumulativeDistances.length - 1] === 0) {
+      return null;
+    }
+    const lineDistance = cumulativeDistances[cumulativeDistances.length - 1];
+    let wantedDistance = lineDistance * arrowPosition;
+    if (cumulativeDistances.length === 2) {
+      wantedDistance = wantedDistance - 2 * distanceBetweenLines * arrowPosition * proximityFactor;
+    }
+    const goodSegment = this.findSegment(positions, cumulativeDistances, wantedDistance);
+    let multiplier;
+    switch (arrowDirection) {
+      case ArrowDirection.FROM_SIDE_2_TO_SIDE_1:
+        multiplier = 1.005;
+        break;
+      case ArrowDirection.FROM_SIDE_1_TO_SIDE_2:
+        multiplier = 0.995;
+        break;
+      case ArrowDirection.NONE:
+        multiplier = 1;
+        break;
+      default:
+        throw new Error("impossible");
+    }
+    const remainingDistance = goodSegment.remainingDistance * multiplier;
+    const angle = this.getMapAngle(goodSegment.segment[0], goodSegment.segment[1]);
+    const neededOffset = this.getLabelOffset(angle, 20, arrowDirection);
+    const position = {
+      position: es.computeDestinationPoint(goodSegment.segment[0], remainingDistance, angle),
+      angle,
+      offset: neededOffset
+    };
+    position.position = es.computeDestinationPoint(
+      position.position,
+      distanceBetweenLines * lineParallelIndex,
+      lineAngle + 90
+    );
+    if (cumulativeDistances.length === 2) {
+      position.position = es.computeDestinationPoint(
+        position.position,
+        -distanceBetweenLines * proximityFactor,
+        lineAngle
+      );
+    } else if (goodSegment.idx === 0 || goodSegment.idx === cumulativeDistances.length - 2) {
+      const segmentDistance = cumulativeDistances[goodSegment.idx + 1] - cumulativeDistances[goodSegment.idx];
+      const alreadyDoneDistance = segmentDistance - remainingDistance;
+      let labelDistanceInSegment;
+      if (goodSegment.idx === 0) {
+        labelDistanceInSegment = -alreadyDoneDistance;
+      } else {
+        labelDistanceInSegment = remainingDistance;
+      }
+      const labelPercentage = labelDistanceInSegment / segmentDistance;
+      position.position = es.computeDestinationPoint(
+        position.position,
+        distanceBetweenLines * labelPercentage,
+        proximityAngle
+      );
+    }
+    return position;
+  }
+  getLabelOffset(angle, offsetDistance, arrowDirection) {
+    const radiantAngle = (-angle + 90) / (180 / Math.PI);
+    let direction = 0;
+    switch (arrowDirection) {
+      case ArrowDirection.FROM_SIDE_2_TO_SIDE_1:
+        direction = 1;
+        break;
+      case ArrowDirection.FROM_SIDE_1_TO_SIDE_2:
+        direction = -1;
+        break;
+      case ArrowDirection.NONE:
+        direction = 0;
+        break;
+      default:
+        throw new Error("impossible");
+    }
+    return [
+      Math.cos(radiantAngle) * offsetDistance * direction,
+      -Math.sin(radiantAngle) * offsetDistance * direction
+    ];
+  }
+  //returns the angle between point1 and point2 in degrees [0-360)
+  getMapAngle(point1, point2) {
+    let angle = es.getRhumbLineBearing(point1, point2);
+    const angle2 = es.getGreatCircleBearing(point1, point2);
+    const coeff = 0.1;
+    angle = coeff * angle + (1 - coeff) * angle2;
+    return angle;
+  }
+}
+const BoltIcon = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20enable-background='new%200%200%2024%2024'%20height='24px'%20viewBox='0%200%2024%2024'%20width='24px'%20fill='%23000000'%3e%3cg%3e%3crect%20fill='none'%20height='24'%20width='24'/%3e%3c/g%3e%3cg%3e%3cpath%20d='M11,21h-1l1-7H7.5c-0.88,0-0.33-0.75-0.31-0.78C8.48,10.94,10.42,7.54,13.01,3h1l-1,7h3.51c0.4,0,0.62,0.19,0.4,0.66%20C12.97,17.55,11,21,11,21z'/%3e%3c/g%3e%3c/svg%3e";
+const PadlockIcon = "data:image/svg+xml,%3csvg%20xmlns='http://www.w3.org/2000/svg'%20height='24px'%20viewBox='0%200%2024%2024'%20width='24px'%20fill='%23000000'%3e%3cg%20fill='none'%3e%3cpath%20d='M0%200h24v24H0V0z'/%3e%3cpath%20d='M0%200h24v24H0V0z'%20opacity='.87'/%3e%3c/g%3e%3cpath%20d='M18%208h-1V6c0-2.76-2.24-5-5-5S7%203.24%207%206v2H6c-1.1%200-2%20.9-2%202v10c0%201.1.9%202%202%202h12c1.1%200%202-.9%202-2V10c0-1.1-.9-2-2-2zM9%206c0-1.66%201.34-3%203-3s3%201.34%203%203v2H9V6zm9%2014H6V10h12v10zm-6-3c1.1%200%202-.9%202-2s-.9-2-2-2-2%20.9-2%202%20.9%202%202%202z'/%3e%3c/svg%3e";
+function getNominalVoltageColor(nominalVoltage) {
+  if (nominalVoltage >= 300) {
+    return [255, 0, 0];
+  } else if (nominalVoltage >= 170 && nominalVoltage < 300) {
+    return [34, 139, 34];
+  } else if (nominalVoltage >= 120 && nominalVoltage < 170) {
+    return [1, 175, 175];
+  } else if (nominalVoltage >= 70 && nominalVoltage < 120) {
+    return [204, 85, 0];
+  } else if (nominalVoltage >= 50 && nominalVoltage < 70) {
+    return [160, 32, 240];
+  } else if (nominalVoltage >= 30 && nominalVoltage < 50) {
+    return [255, 130, 144];
+  } else {
+    return [171, 175, 40];
+  }
+}
+const INVALID_FLOW_OPACITY = 0.2;
+const SUBSTATION_RADIUS = 500;
+const SUBSTATION_RADIUS_MAX_PIXEL = 5;
+const SUBSTATION_RADIUS_MIN_PIXEL = 1;
+const defaultProps$2 = {
+  getLineParallelIndex: { type: "accessor", value: 0 },
+  getLineAngle: { type: "accessor", value: 0 },
+  distanceBetweenLines: { type: "number", value: 1e3 },
+  maxParallelOffset: { type: "number", value: 100 },
+  minParallelOffset: { type: "number", value: 3 },
+  substationRadius: { type: "number", value: 500 },
+  substationMaxPixel: { type: "number", value: 5 },
+  minSubstationRadiusPixel: { type: "number", value: 1 }
+};
+const _ForkLineLayer = class _ForkLineLayer extends LineLayer$1 {
+  getShaders() {
+    const shaders = super.getShaders();
+    shaders.inject = {
+      "vs:#decl": `
+attribute float instanceLineParallelIndex;
+attribute float instanceLineAngle;
+attribute float instanceOffsetStart;
+attribute float instanceProximityFactor;
+uniform float distanceBetweenLines;
+uniform float maxParallelOffset;
+uniform float minParallelOffset;
+uniform float substationRadius;
+uniform float substationMaxPixel;
+uniform float minSubstationRadiusPixel;
+            `,
+      "float segmentIndex = positions.x": `;
+    target = source ;
+    float offsetPixels = clamp(project_size_to_pixel( distanceBetweenLines), minParallelOffset, maxParallelOffset );
+    float offsetCommonSpace = project_pixel_size(offsetPixels);
+
+    float offsetSubstation = clamp(project_size_to_pixel(substationRadius*instanceOffsetStart ), 
+                                    minSubstationRadiusPixel, 
+                                    substationMaxPixel * instanceOffsetStart );
+    float offsetSubstationCommonSpace = project_pixel_size(offsetSubstation) ;
+
+    vec4 trans = vec4(cos(instanceLineAngle), -sin(instanceLineAngle ), 0, 0.) * instanceLineParallelIndex;
+
+    trans.x -= sin(instanceLineAngle) * instanceProximityFactor;
+    trans.y -= cos(instanceLineAngle) * instanceProximityFactor;
+
+    source+=project_common_position_to_clipspace(trans * (offsetSubstationCommonSpace / sqrt(trans.x*trans.x+trans.y*trans.y))) - project_uCenter;
+    target+=project_common_position_to_clipspace(trans * offsetCommonSpace) - project_uCenter;
+
+            `
+    };
+    return shaders;
+  }
+  initializeState() {
+    super.initializeState();
+    const attributeManager = this.getAttributeManager();
+    attributeManager == null ? void 0 : attributeManager.addInstanced({
+      instanceLineParallelIndex: {
+        size: 1,
+        type: GL.FLOAT,
+        accessor: "getLineParallelIndex"
+      },
+      instanceLineAngle: {
+        size: 1,
+        type: GL.FLOAT,
+        accessor: "getLineAngle"
+      },
+      instanceOffsetStart: {
+        size: 1,
+        type: GL.FLOAT,
+        accessor: "getSubstationOffset"
+      },
+      instanceProximityFactor: {
+        size: 1,
+        type: GL.FLOAT,
+        accessor: "getProximityFactor"
+      }
+    });
+  }
+  // TODO find the full type for record values
+  draw({ uniforms }) {
+    super.draw({
+      uniforms: {
+        ...uniforms,
+        distanceBetweenLines: this.props.getDistanceBetweenLines,
+        maxParallelOffset: this.props.getMaxParallelOffset,
+        minParallelOffset: this.props.getMinParallelOffset,
+        substationRadius: this.props.getSubstationRadius,
+        substationMaxPixel: this.props.getSubstationMaxPixel,
+        minSubstationRadiusPixel: this.props.getMinSubstationRadiusPixel
+      }
+    });
+  }
+};
+_ForkLineLayer.layerName = "ForkLineLayer";
+_ForkLineLayer.defaultProps = defaultProps$2;
+let ForkLineLayer = _ForkLineLayer;
+const defaultProps$1 = {
+  getLineParallelIndex: { type: "accessor", value: 0 },
+  getLineAngle: { type: "accessor", value: 0 },
+  distanceBetweenLines: { type: "number", value: 1e3 },
+  maxParallelOffset: { type: "number", value: 100 },
+  minParallelOffset: { type: "number", value: 3 }
+};
+const _ParallelPathLayer = class _ParallelPathLayer extends PathLayer {
+  getShaders() {
+    const shaders = super.getShaders();
+    shaders.inject = Object.assign({}, shaders.inject, {
+      "vs:#decl": shaders.inject["vs:#decl"] + `//Note: with the following attribute, we have reached the limit (16 on most platforms) of the number of attributes.
+//      with webgl2, this might be raised in the future to 32 on most platforms...
+//      The PathLayer that this class extends already uses 13 attributes (and 15 with the dash extension).
+//      we have packed all our attributes together in a single attribute to
+//      workaround the low limit of the number of vertex attrbutes...
+//      To pack the attributes, for now we use a very simple system. If needed, we can change it to a more efficient packing.
+//      We just add an extra float to the line angles vec3. The
+//      extra float contains the previous attributes:
+//          parallelIndex (an half integer, between -15.5 and +15.5 (32 lines max..))
+//          proximityFactors (two floats, between 0 and 1)
+//
+//          To simplify further, we use only positive integers for
+//          this extra float, ie values only from 0 to 2^24. For parallelIndex, we encode the half integers from -15.5 to 15.5
+//          to 0..62, which fits in 6 bits.
+//          For proximityFactors, We switch from floating to a fixed precision of 9 bits
+//          without the 0 (ie multiples of 512: 1/512, 2/512, ..., 1).
+//          So in the 24 bits of the integer value of the float, we have 6 bits of parallel index,
+//          9 bits of proximity factor start, 9 bits of proximity factor end, for a total of 24 bits.
+//Note2: packing the attributes together, in addition to not beeing very readable,
+//       also has the downside that you can't update one attribute and reconstruct
+//       only its buffer, so it hurts performance a bit in this case.
+//       But this is a rare case for us (changing parameters) so it doesn't matter much.
+attribute vec4 instanceExtraAttributes;
+uniform float distanceBetweenLines;
+uniform float maxParallelOffset;
+uniform float minParallelOffset;
+`,
+      "vs:#main-end": shaders.inject["vs:#main-end"] + `
+bool isSegmentEnd = isEnd > EPSILON;
+bool isFirstSegment = (instanceTypes == 1.0 || instanceTypes == 3.0);
+bool isLastSegment = (instanceTypes == 2.0 || instanceTypes == 3.0);
+
+float instanceLineAngle = instanceExtraAttributes[1];
+if ( !isSegmentEnd && isFirstSegment ){
+    instanceLineAngle = instanceExtraAttributes[0];
+}
+else if ( isSegmentEnd && isLastSegment){
+    instanceLineAngle = instanceExtraAttributes[2];
+}
+float instanceLineParallelIndex = (mod(instanceExtraAttributes[3], 64.0) - 31.0) / 2.0;
+ 
+float offsetPixels = clamp(project_size_to_pixel(distanceBetweenLines), minParallelOffset, maxParallelOffset);
+float offsetCommonSpace = project_pixel_size(offsetPixels);
+vec4 trans = vec4(cos(instanceLineAngle), -sin(instanceLineAngle), 0, 0.) * instanceLineParallelIndex;
+
+if(isSegmentEnd && isLastSegment) {
+  float pf = (mod(instanceExtraAttributes[3] / 64.0, 512.0) + 1.0) / 512.0;
+  trans.x += sin(instanceLineAngle) * pf ;
+  trans.y += cos(instanceLineAngle) * pf;
+}
+else if (!isSegmentEnd && isFirstSegment)
+{
+  float pf = (mod(instanceExtraAttributes[3] / 32768.0, 512.0) + 1.0) / 512.0;
+  trans.x -= sin(instanceLineAngle) * pf;
+  trans.y -= cos(instanceLineAngle) * pf;
+}
+
+trans = trans * offsetCommonSpace;
+gl_Position += project_common_position_to_clipspace(trans) - project_uCenter;
+`
+    });
+    return shaders;
+  }
+  initializeState() {
+    var _a;
+    super.initializeState();
+    (_a = this.getAttributeManager()) == null ? void 0 : _a.addInstanced({
+      // too much instances variables need to compact some...
+      instanceExtraAttributes: {
+        size: 4,
+        type: GL.FLOAT,
+        accessor: "getExtraAttributes"
+      }
+    });
+  }
+  // TODO find the full type for record values
+  draw({ uniforms }) {
+    super.draw({
+      uniforms: {
+        ...uniforms,
+        distanceBetweenLines: this.props.distanceBetweenLines,
+        maxParallelOffset: this.props.maxParallelOffset,
+        minParallelOffset: this.props.minParallelOffset
+      }
+    });
+  }
+};
+_ParallelPathLayer.layerName = "ParallelPathLayer";
+_ParallelPathLayer.defaultProps = defaultProps$1;
+let ParallelPathLayer = _ParallelPathLayer;
+const DISTANCE_BETWEEN_ARROWS = 1e4;
+const START_ARROW_POSITION = 0.1;
+const END_ARROW_POSITION = 0.9;
+var LineFlowMode = /* @__PURE__ */ ((LineFlowMode2) => {
+  LineFlowMode2["STATIC_ARROWS"] = "staticArrows";
+  LineFlowMode2["ANIMATED_ARROWS"] = "animatedArrows";
+  LineFlowMode2["FEEDERS"] = "feeders";
+  return LineFlowMode2;
+})(LineFlowMode || {});
+var LineFlowColorMode = /* @__PURE__ */ ((LineFlowColorMode2) => {
+  LineFlowColorMode2["NOMINAL_VOLTAGE"] = "nominalVoltage";
+  LineFlowColorMode2["OVERLOADS"] = "overloads";
+  return LineFlowColorMode2;
+})(LineFlowColorMode || {});
+const noDashArray = [0, 0];
+const dashArray = [15, 10];
+function doDash(lineConnection) {
+  return !lineConnection.terminal1Connected || !lineConnection.terminal2Connected;
+}
+function getArrowDirection(p = 0) {
+  if (p < 0) {
+    return ArrowDirection.FROM_SIDE_2_TO_SIDE_1;
+  } else if (p > 0) {
+    return ArrowDirection.FROM_SIDE_1_TO_SIDE_2;
+  } else {
+    return ArrowDirection.NONE;
+  }
+}
+function getLineLoadingZoneOfSide(limit, intensity, lineFlowAlertThreshold) {
+  if (limit === void 0 || intensity === void 0 || intensity === 0) {
+    return 0;
+  } else {
+    const threshold = lineFlowAlertThreshold * limit / 100;
+    const absoluteIntensity = Math.abs(intensity);
+    if (absoluteIntensity < threshold) {
+      return 1;
+    } else if (absoluteIntensity >= threshold && absoluteIntensity < limit) {
+      return 2;
+    } else {
+      return 3;
+    }
+  }
+}
+function getLineLoadingZone(line, lineFlowAlertThreshold) {
+  var _a, _b;
+  const zone1 = getLineLoadingZoneOfSide((_a = line.currentLimits1) == null ? void 0 : _a.permanentLimit, line.i1, lineFlowAlertThreshold);
+  const zone2 = getLineLoadingZoneOfSide((_b = line.currentLimits2) == null ? void 0 : _b.permanentLimit, line.i2, lineFlowAlertThreshold);
+  return Math.max(zone1, zone2);
+}
+function getLineLoadingZoneColor(zone) {
+  if (zone === 0) {
+    return [128, 128, 128];
+  } else if (zone === 1) {
+    return [107, 178, 40];
+  } else if (zone === 2) {
+    return [210, 179, 63];
+  } else if (zone === 3) {
+    return [255, 0, 0];
+  } else {
+    throw new Error("Unsupported line loading zone: " + zone);
+  }
+}
+function getLineColor(line, nominalVoltageColor, props, lineConnection) {
+  if (props.lineFlowColorMode === "nominalVoltage") {
+    if (!lineConnection.terminal1Connected && !lineConnection.terminal2Connected) {
+      return props.disconnectedLineColor;
+    } else {
+      return nominalVoltageColor;
+    }
+  } else if (props.lineFlowColorMode === "overloads") {
+    const zone = getLineLoadingZone(line, props.lineFlowAlertThreshold);
+    return getLineLoadingZoneColor(zone);
+  } else {
+    return nominalVoltageColor;
+  }
+}
+function getLineIcon(lineStatus) {
+  return {
+    url: lineStatus === "PLANNED_OUTAGE" ? PadlockIcon : lineStatus === "FORCED_OUTAGE" ? BoltIcon : "",
+    height: 24,
+    width: 24,
+    mask: true
+  };
+}
+function getArrowSpeedOfSide(limit, intensity) {
+  if (limit === void 0 || intensity === void 0 || intensity === 0) {
+    return 0;
+  } else {
+    if (intensity > 0 && intensity < limit / 3) {
+      return 1;
+    } else if (intensity >= limit / 3 && intensity < limit * 2 / 3) {
+      return 2;
+    } else if (intensity >= limit * 2 / 3 && intensity < limit) {
+      return 3;
+    } else {
+      return 4;
+    }
+  }
+}
+function getArrowSpeed(line) {
+  var _a, _b;
+  const speed1 = getArrowSpeedOfSide((_a = line.currentLimits1) == null ? void 0 : _a.permanentLimit, line.i1);
+  const speed2 = getArrowSpeedOfSide((_b = line.currentLimits2) == null ? void 0 : _b.permanentLimit, line.i2);
+  return Math.max(speed1, speed2);
+}
+function getArrowSpeedFactor(speed) {
+  switch (speed) {
+    case 0:
+      return 0;
+    case 1:
+      return 0.5;
+    case 2:
+      return 2;
+    case 3:
+      return 4;
+    case 4:
+      return 10;
+    default:
+      throw new Error("Unknown arrow speed: " + speed);
+  }
+}
+const _LineLayer = class _LineLayer extends CompositeLayer {
+  initializeState(context) {
+    super.initializeState(context);
+    this.state = {
+      compositeData: [],
+      linesConnection: /* @__PURE__ */ new Map(),
+      linesStatus: /* @__PURE__ */ new Map()
+    };
+  }
+  getVoltageLevelIndex(voltageLevelId) {
+    const { network } = this.props;
+    const vl = network.getVoltageLevel(voltageLevelId);
+    const substation = network.getSubstation(vl == null ? void 0 : vl.substationId);
+    return [
+      ...new Set(
+        substation == null ? void 0 : substation.voltageLevels.map((vl2) => vl2.nominalV)
+        // only one voltage level
+      )
+    ].sort((a, b) => {
+      return a - b;
+    }).indexOf(vl == null ? void 0 : vl.nominalV) + 1;
+  }
+  //TODO this is a huge function, refactor
+  updateState({ props, oldProps, changeFlags }) {
+    let compositeData;
+    let linesConnection;
+    let linesStatus;
+    if (changeFlags.dataChanged) {
+      compositeData = [];
+      linesConnection = /* @__PURE__ */ new Map();
+      linesStatus = /* @__PURE__ */ new Map();
+      if (props.network != null && props.network.substations && props.data.length !== 0 && props.geoData != null) {
+        const lineNominalVoltageIndexer = (map, line) => {
+          const network = props.network;
+          const vl1 = network.getVoltageLevel(line.voltageLevelId1);
+          const vl2 = network.getVoltageLevel(line.voltageLevelId2);
+          const vl = vl1 || vl2;
+          let list = map.get(vl == null ? void 0 : vl.nominalV);
+          if (!list) {
+            list = [];
+            map.set(vl == null ? void 0 : vl.nominalV, list);
+          }
+          if ((vl1 == null ? void 0 : vl1.substationId) !== (vl2 == null ? void 0 : vl2.substationId)) {
+            list.push(line);
+          }
+          return map;
+        };
+        const linesByNominalVoltage = props.data.reduce(
+          lineNominalVoltageIndexer,
+          /* @__PURE__ */ new Map()
+        );
+        compositeData = Array.from(linesByNominalVoltage.entries()).map((e) => {
+          return { nominalV: e[0], lines: e[1] };
+        }).sort((a, b) => b.nominalV - a.nominalV);
+        compositeData.forEach((compositeData2) => {
+          var _a;
+          const mapOriginDestination = /* @__PURE__ */ new Map();
+          compositeData2.mapOriginDestination = mapOriginDestination;
+          (_a = compositeData2.lines) == null ? void 0 : _a.forEach((line) => {
+            linesConnection.set(line.id, {
+              terminal1Connected: line.terminal1Connected,
+              terminal2Connected: line.terminal2Connected
+            });
+            linesStatus.set(line.id, {
+              operatingStatus: line.operatingStatus
+            });
+            const key = this.genLineKey(line);
+            const val = mapOriginDestination.get(key);
+            if (val == null) {
+              mapOriginDestination.set(key, /* @__PURE__ */ new Set([line]));
+            } else {
+              mapOriginDestination.set(key, val.add(line));
+            }
+          });
+        });
+      }
+    } else {
+      compositeData = this.state.compositeData;
+      linesConnection = this.state.linesConnection;
+      linesStatus = this.state.linesStatus;
+      if (props.updatedLines !== oldProps.updatedLines) {
+        props.updatedLines.forEach((line1) => {
+          linesConnection.set(line1.id, {
+            terminal1Connected: line1.terminal1Connected,
+            terminal2Connected: line1.terminal2Connected
+          });
+          linesStatus.set(line1.id, {
+            operatingStatus: line1.operatingStatus
+          });
+        });
+      }
+    }
+    if (changeFlags.dataChanged || changeFlags.propsChanged && (oldProps.lineFullPath !== props.lineFullPath || props.lineParallelPath !== oldProps.lineParallelPath || props.geoData !== oldProps.geoData)) {
+      this.recomputeParallelLinesIndex(compositeData, props);
+    }
+    if (changeFlags.dataChanged || changeFlags.propsChanged && (oldProps.lineFullPath !== props.lineFullPath || oldProps.geoData !== props.geoData)) {
+      compositeData.forEach((compositeData2) => {
+        var _a;
+        const lineMap = /* @__PURE__ */ new Map();
+        (_a = compositeData2.lines) == null ? void 0 : _a.forEach((line) => {
+          const positions = props.geoData.getLinePositions(props.network, line, props.lineFullPath);
+          const cumulativeDistances = props.geoData.getLineDistances(positions);
+          lineMap.set(line.id, {
+            positions,
+            // @ts-expect-error TODO: manage null case
+            cumulativeDistances,
+            line
+          });
+        });
+        compositeData2.lineMap = lineMap;
+      });
+    }
+    if (changeFlags.dataChanged || changeFlags.propsChanged && (props.lineFullPath !== oldProps.lineFullPath || props.lineParallelPath !== oldProps.lineParallelPath || props.geoData !== oldProps.geoData)) {
+      this.recomputeForkLines(compositeData, props);
+    }
+    if (changeFlags.dataChanged || changeFlags.propsChanged && (oldProps.lineFullPath !== props.lineFullPath || props.lineParallelPath !== oldProps.lineParallelPath || props.geoData !== oldProps.geoData)) {
+      compositeData.forEach((compositeData2) => {
+        var _a;
+        compositeData2.activePower = [];
+        (_a = compositeData2.lines) == null ? void 0 : _a.forEach((line) => {
+          var _a2, _b, _c;
+          const lineData = (_a2 = compositeData2.lineMap) == null ? void 0 : _a2.get(line.id);
+          const arrowDirection = getArrowDirection(line.p1);
+          const coordinates1 = props.geoData.labelDisplayPosition(
+            // @ts-expect-error TODO: manage undefined case
+            lineData == null ? void 0 : lineData.positions,
+            lineData == null ? void 0 : lineData.cumulativeDistances,
+            START_ARROW_POSITION,
+            arrowDirection,
+            line.parallelIndex,
+            // @ts-expect-error TODO: manage undefined case
+            line.angle * 180 / Math.PI,
+            // @ts-expect-error TODO: manage undefined case
+            line.angleStart * 180 / Math.PI,
+            props.distanceBetweenLines,
+            line.proximityFactorStart
+          );
+          const coordinates2 = props.geoData.labelDisplayPosition(
+            // @ts-expect-error TODO: manage undefined case
+            lineData == null ? void 0 : lineData.positions,
+            lineData == null ? void 0 : lineData.cumulativeDistances,
+            END_ARROW_POSITION,
+            arrowDirection,
+            line.parallelIndex,
+            // @ts-expect-error TODO: manage undefined case
+            line.angle * 180 / Math.PI,
+            // @ts-expect-error TODO: manage undefined case
+            line.angleEnd * 180 / Math.PI,
+            props.distanceBetweenLines,
+            line.proximityFactorEnd
+          );
+          if (coordinates1 !== null && coordinates2 !== null) {
+            (_b = compositeData2.activePower) == null ? void 0 : _b.push({
+              line,
+              p: line.p1,
+              printPosition: [coordinates1.position.longitude, coordinates1.position.latitude],
+              offset: coordinates1.offset
+            });
+            (_c = compositeData2.activePower) == null ? void 0 : _c.push({
+              line,
+              p: line.p2,
+              printPosition: [coordinates2.position.longitude, coordinates2.position.latitude],
+              offset: coordinates2.offset
+            });
+          }
+        });
+      });
+    }
+    if (changeFlags.dataChanged || changeFlags.propsChanged && (props.updatedLines !== oldProps.updatedLines || oldProps.lineFullPath !== props.lineFullPath || props.lineParallelPath !== oldProps.lineParallelPath || props.geoData !== oldProps.geoData)) {
+      compositeData.forEach((compositeData2) => {
+        var _a;
+        compositeData2.operatingStatus = [];
+        (_a = compositeData2.lines) == null ? void 0 : _a.forEach((line) => {
+          var _a2, _b;
+          const lineStatus = linesStatus.get(line.id);
+          if (lineStatus !== void 0 && lineStatus.operatingStatus !== void 0 && lineStatus.operatingStatus !== "IN_OPERATION") {
+            const lineData = (_a2 = compositeData2.lineMap) == null ? void 0 : _a2.get(line.id);
+            const coordinatesIcon = props.geoData.labelDisplayPosition(
+              // @ts-expect-error TODO: manage undefined case
+              lineData == null ? void 0 : lineData.positions,
+              lineData == null ? void 0 : lineData.cumulativeDistances,
+              0.5,
+              ArrowDirection.NONE,
+              line.parallelIndex,
+              // @ts-expect-error TODO: manage undefined case
+              line.angle * 180 / Math.PI,
+              // @ts-expect-error TODO: manage undefined case
+              line.angleEnd * 180 / Math.PI,
+              props.distanceBetweenLines,
+              line.proximityFactorEnd
+            );
+            if (coordinatesIcon !== null) {
+              (_b = compositeData2.operatingStatus) == null ? void 0 : _b.push({
+                status: lineStatus.operatingStatus,
+                printPosition: [coordinatesIcon.position.longitude, coordinatesIcon.position.latitude],
+                offset: coordinatesIcon.offset
+              });
+            }
+          }
+        });
+      });
+    }
+    if (changeFlags.dataChanged || changeFlags.propsChanged && (oldProps.lineFullPath !== props.lineFullPath || props.geoData !== oldProps.geoData || //For lineFlowMode, recompute only if mode goes to or from LineFlowMode.FEEDERS
+    //because for LineFlowMode.STATIC_ARROWS and LineFlowMode.ANIMATED_ARROWS it's the same
+    props.lineFlowMode !== oldProps.lineFlowMode && (props.lineFlowMode === "feeders" || oldProps.lineFlowMode === "feeders"))) {
+      compositeData.forEach((compositeData2) => {
+        var _a;
+        const lineMap = compositeData2.lineMap;
+        compositeData2.arrows = (_a = compositeData2.lines) == null ? void 0 : _a.flatMap((line) => {
+          const lineData = lineMap == null ? void 0 : lineMap.get(line.id);
+          line.cumulativeDistances = lineData == null ? void 0 : lineData.cumulativeDistances;
+          line.positions = lineData == null ? void 0 : lineData.positions;
+          if (props.lineFlowMode === "feeders") {
+            return [
+              {
+                distance: START_ARROW_POSITION,
+                line
+              },
+              {
+                distance: END_ARROW_POSITION,
+                line
+              }
+            ];
+          }
+          const directLinePositions = props.geoData.getLinePositions(props.network, line, false);
+          const directLineDistance = es.getDistance(
+            {
+              latitude: directLinePositions[0][1],
+              longitude: directLinePositions[0][0]
+            },
+            {
+              latitude: directLinePositions[1][1],
+              longitude: directLinePositions[1][0]
+            }
+          );
+          const arrowCount = Math.ceil(directLineDistance / DISTANCE_BETWEEN_ARROWS);
+          return [...new Array(arrowCount).keys()].map((index) => {
+            return {
+              distance: index / arrowCount,
+              line
+            };
+          });
+        });
+      });
+    }
+    this.setState({
+      compositeData,
+      linesConnection,
+      linesStatus
+    });
+  }
+  genLineKey(line) {
+    return line.voltageLevelId1 > line.voltageLevelId2 ? line.voltageLevelId1 + "##" + line.voltageLevelId2 : line.voltageLevelId2 + "##" + line.voltageLevelId1;
+  }
+  recomputeParallelLinesIndex(compositeData, props) {
+    compositeData.forEach((compositeData2) => {
+      const mapOriginDestination = compositeData2.mapOriginDestination;
+      mapOriginDestination == null ? void 0 : mapOriginDestination.forEach((samePathLine, key) => {
+        let truncatedSize = samePathLine.size;
+        if (truncatedSize > 32) {
+          console.warn(
+            "Warning, more than 32 parallel lines between vls " + key + ". The map will only show 32 parallel lines."
+          );
+          truncatedSize = 32;
+        }
+        let index = -(truncatedSize - 1) / 2;
+        samePathLine.forEach((line) => {
+          line.parallelIndex = props.lineParallelPath ? index : 0;
+          if (index < 15) {
+            index += 1;
+          }
+        });
+      });
+    });
+  }
+  recomputeForkLines(compositeData, props) {
+    const mapMinProximityFactor = /* @__PURE__ */ new Map();
+    compositeData.forEach((compositeData2) => {
+      compositeData2.lines.forEach((line) => {
+        var _a, _b;
+        const positions = (_b = (_a = compositeData2.lineMap) == null ? void 0 : _a.get(line.id)) == null ? void 0 : _b.positions;
+        line.origin = positions[0];
+        line.end = positions[positions.length - 1];
+        line.substationIndexStart = this.getVoltageLevelIndex(line.voltageLevelId1);
+        line.substationIndexEnd = this.getVoltageLevelIndex(line.voltageLevelId2);
+        line.angle = this.computeAngle(props, positions[0], positions[positions.length - 1]);
+        line.angleStart = this.computeAngle(props, positions[0], positions[1]);
+        line.angleEnd = this.computeAngle(
+          props,
+          positions[positions.length - 2],
+          positions[positions.length - 1]
+        );
+        line.proximityFactorStart = this.getProximityFactor(positions[0], positions[1]);
+        line.proximityFactorEnd = this.getProximityFactor(
+          positions[positions.length - 2],
+          positions[positions.length - 1]
+        );
+        const key = this.genLineKey(line);
+        const val = mapMinProximityFactor.get(key);
+        if (val == null) {
+          mapMinProximityFactor.set(key, {
+            lines: [line],
+            start: line.proximityFactorStart,
+            end: line.proximityFactorEnd
+          });
+        } else {
+          val.lines.push(line);
+          val.start = Math.min(val.start, line.proximityFactorStart);
+          val.end = Math.min(val.end, line.proximityFactorEnd);
+          mapMinProximityFactor.set(key, val);
+        }
+      });
+    });
+    mapMinProximityFactor.forEach(
+      (samePathLine) => samePathLine.lines.forEach((line) => {
+        line.proximityFactorStart = samePathLine.start;
+        line.proximityFactorEnd = samePathLine.end;
+      })
+    );
+  }
+  getProximityFactor(firstPosition, secondPosition) {
+    let factor = es.getDistance(firstPosition, secondPosition) / (3 * this.props.distanceBetweenLines);
+    if (factor > 1) {
+      factor = 1;
+    }
+    return factor;
+  }
+  computeAngle(props, position1, position2) {
+    let angle = props.geoData.getMapAngle(position1, position2);
+    angle = angle * Math.PI / 180 + Math.PI;
+    if (angle < 0) {
+      angle += 2 * Math.PI;
+    }
+    return angle;
+  }
+  renderLayers() {
+    const layers = [];
+    const linePathUpdateTriggers = [
+      this.props.lineFullPath,
+      this.props.geoData.linePositionsById,
+      this.props.network.lines
+    ];
+    this.state.compositeData.forEach((compositeData) => {
+      const nominalVoltageColor = this.props.getNominalVoltageColor(compositeData.nominalV);
+      const lineLayer = new ParallelPathLayer(
+        this.getSubLayerProps({
+          id: "LineNominalVoltage" + compositeData.nominalV,
+          data: compositeData.lines,
+          widthScale: 20,
+          widthMinPixels: 1,
+          widthMaxPixels: 2,
+          getPath: (line) => this.props.geoData.getLinePositions(this.props.network, line, this.props.lineFullPath),
+          // @ts-expect-error TODO: manage undefined case
+          getColor: (line) => (
+            // @ts-expect-error TODO: manage undefined case
+            getLineColor(line, nominalVoltageColor, this.props, this.state.linesConnection.get(line.id))
+          ),
+          getWidth: 2,
+          // @ts-expect-error TODO: manage undefined case
+          getLineParallelIndex: (line) => line.parallelIndex,
+          getExtraAttributes: (line) => [
+            line.angleStart,
+            line.angle,
+            line.angleEnd,
+            // @ts-expect-error TODO: manage undefined case
+            line.parallelIndex * 2 + 31 + // @ts-expect-error TODO: manage undefined case
+            64 * (Math.ceil(line.proximityFactorStart * 512) - 1) + // @ts-expect-error TODO: manage undefined case
+            64 * 512 * (Math.ceil(line.proximityFactorEnd * 512) - 1)
+          ],
+          distanceBetweenLines: this.props.distanceBetweenLines,
+          maxParallelOffset: this.props.maxParallelOffset,
+          minParallelOffset: this.props.minParallelOffset,
+          visible: !this.props.filteredNominalVoltages || this.props.filteredNominalVoltages.includes(compositeData.nominalV),
+          updateTriggers: {
+            getPath: linePathUpdateTriggers,
+            getExtraAttributes: [this.props.lineParallelPath, linePathUpdateTriggers],
+            getColor: [
+              this.props.disconnectedLineColor,
+              this.props.lineFlowColorMode,
+              this.props.lineFlowAlertThreshold,
+              this.props.updatedLines
+            ],
+            getDashArray: [this.props.updatedLines]
+          },
+          getDashArray: (line) => (
+            // @ts-expect-error TODO: manage undefined case
+            doDash(this.state.linesConnection.get(line.id)) ? dashArray : noDashArray
+          ),
+          extensions: [new PathStyleExtension({ dash: true })]
+        })
+      );
+      layers.push(lineLayer);
+      const arrowLayer = new ArrowLayer(
+        this.getSubLayerProps(
+          {
+            id: "ArrowNominalVoltage" + compositeData.nominalV,
+            data: compositeData.arrows,
+            sizeMinPixels: 3,
+            sizeMaxPixels: 7,
+            getDistance: (arrow) => arrow.distance,
+            getLine: (arrow) => arrow.line,
+            getLinePositions: (line) => this.props.geoData.getLinePositions(this.props.network, line, this.props.lineFullPath),
+            // @ts-expect-error TODO: manage undefined case
+            getColor: (arrow) => getLineColor(
+              arrow.line,
+              nominalVoltageColor,
+              this.props,
+              // @ts-expect-error TODO: manage undefined case
+              this.state.linesConnection.get(arrow.line.id)
+            ),
+            getSize: 700,
+            getSpeedFactor: (arrow) => getArrowSpeedFactor(getArrowSpeed(arrow.line)),
+            // @ts-expect-error TODO: manage undefined case
+            getLineParallelIndex: (arrow) => arrow.line.parallelIndex,
+            // @ts-expect-error TODO: manage undefined case
+            getLineAngles: (arrow) => [arrow.line.angleStart, arrow.line.angle, arrow.line.angleEnd],
+            getProximityFactors: (arrow) => [
+              arrow.line.proximityFactorStart,
+              arrow.line.proximityFactorEnd
+            ],
+            getDistanceBetweenLines: this.props.distanceBetweenLines,
+            maxParallelOffset: this.props.maxParallelOffset,
+            minParallelOffset: this.props.minParallelOffset,
+            getDirection: (arrow) => {
+              return getArrowDirection(arrow.line.p1);
+            },
+            animated: this.props.showLineFlow && this.props.lineFlowMode === "animatedArrows",
+            visible: this.props.showLineFlow && (!this.props.filteredNominalVoltages || this.props.filteredNominalVoltages.includes(compositeData.nominalV)),
+            opacity: this.props.areFlowsValid ? 1 : INVALID_FLOW_OPACITY,
+            updateTriggers: {
+              getLinePositions: linePathUpdateTriggers,
+              getLineParallelIndex: [this.props.lineParallelPath],
+              getLineAngles: linePathUpdateTriggers,
+              getColor: [
+                this.props.disconnectedLineColor,
+                this.props.lineFlowColorMode,
+                this.props.lineFlowAlertThreshold,
+                this.props.updatedLines
+              ],
+              opacity: [this.props.areFlowsValid]
+            }
+          }
+          /*<Arrow>*/
+        )
+      );
+      layers.push(arrowLayer);
+      const startFork = new ForkLineLayer(
+        this.getSubLayerProps({
+          id: "LineForkStart" + compositeData.nominalV,
+          getSourcePosition: (line) => line.origin,
+          getTargetPosition: (line) => line.end,
+          getSubstationOffset: (line) => line.substationIndexStart,
+          data: compositeData.lines,
+          widthScale: 20,
+          widthMinPixels: 1,
+          widthMaxPixels: 2,
+          // @ts-expect-error TODO: manage undefined case
+          getColor: (line) => (
+            // @ts-expect-error TODO: manage undefined case
+            getLineColor(line, nominalVoltageColor, this.props, this.state.linesConnection.get(line.id))
+          ),
+          getWidth: 2,
+          getProximityFactor: (line) => line.proximityFactorStart,
+          // @ts-expect-error TODO: manage undefined case
+          getLineParallelIndex: (line) => line.parallelIndex,
+          // @ts-expect-error TODO: manage undefined case
+          getLineAngle: (line) => line.angleStart,
+          getDistanceBetweenLines: this.props.distanceBetweenLines,
+          getMaxParallelOffset: this.props.maxParallelOffset,
+          getMinParallelOffset: this.props.minParallelOffset,
+          getSubstationRadius: this.props.substationRadius,
+          getSubstationMaxPixel: this.props.substationMaxPixel,
+          getMinSubstationRadiusPixel: this.props.minSubstationRadiusPixel,
+          visible: !this.props.filteredNominalVoltages || this.props.filteredNominalVoltages.includes(compositeData.nominalV),
+          updateTriggers: {
+            getLineParallelIndex: linePathUpdateTriggers,
+            getSourcePosition: linePathUpdateTriggers,
+            getTargetPosition: linePathUpdateTriggers,
+            getLineAngle: linePathUpdateTriggers,
+            getProximityFactor: linePathUpdateTriggers,
+            getColor: [
+              this.props.disconnectedLineColor,
+              this.props.lineFlowColorMode,
+              this.props.lineFlowAlertThreshold,
+              this.props.updatedLines
+            ]
+          }
+        })
+      );
+      layers.push(startFork);
+      const endFork = new ForkLineLayer(
+        this.getSubLayerProps({
+          id: "LineForkEnd" + compositeData.nominalV,
+          getSourcePosition: (line) => line.end,
+          getTargetPosition: (line) => line.origin,
+          getSubstationOffset: (line) => line.substationIndexEnd,
+          data: compositeData.lines,
+          widthScale: 20,
+          widthMinPixels: 1,
+          widthMaxPixels: 2,
+          // @ts-expect-error TODO: manage undefined case
+          getColor: (line) => (
+            // @ts-expect-error TODO: manage undefined case
+            getLineColor(line, nominalVoltageColor, this.props, this.state.linesConnection.get(line.id))
+          ),
+          getWidth: 2,
+          getProximityFactor: (line) => line.proximityFactorEnd,
+          // @ts-expect-error TODO: manage undefined case
+          getLineParallelIndex: (line) => -line.parallelIndex,
+          // @ts-expect-error TODO: manage undefined case
+          getLineAngle: (line) => line.angleEnd + Math.PI,
+          getDistanceBetweenLines: this.props.distanceBetweenLines,
+          getMaxParallelOffset: this.props.maxParallelOffset,
+          getMinParallelOffset: this.props.minParallelOffset,
+          getSubstationRadius: this.props.substationRadius,
+          getSubstationMaxPixel: this.props.substationMaxPixel,
+          getMinSubstationRadiusPixel: this.props.minSubstationRadiusPixel,
+          visible: !this.props.filteredNominalVoltages || this.props.filteredNominalVoltages.includes(compositeData.nominalV),
+          updateTriggers: {
+            getLineParallelIndex: [this.props.lineParallelPath],
+            getSourcePosition: linePathUpdateTriggers,
+            getTargetPosition: linePathUpdateTriggers,
+            getLineAngle: linePathUpdateTriggers,
+            getProximityFactor: linePathUpdateTriggers,
+            getColor: [
+              this.props.disconnectedLineColor,
+              this.props.lineFlowColorMode,
+              this.props.lineFlowAlertThreshold,
+              this.props.updatedLines
+            ]
+          }
+        })
+      );
+      layers.push(endFork);
+      const lineActivePowerLabelsLayer = new TextLayer(
+        this.getSubLayerProps({
+          id: "ActivePower" + compositeData.nominalV,
+          data: compositeData.activePower,
+          getText: (activePower) => activePower.p !== void 0 ? Math.round(activePower.p).toString() : "",
+          // The position passed to this layer causes a bug when zooming and maxParallelOffset is reached:
+          // the label is not correctly positioned on the lines, they are slightly off.
+          // In the custom layers, we clamp the distanceBetweenLines. This is not done in the deck.gl TextLayer
+          // and IconLayer or in the position calculated here.
+          getPosition: (activePower) => activePower.printPosition,
+          getColor: this.props.labelColor,
+          fontFamily: "Roboto",
+          getSize: this.props.labelSize,
+          getAngle: 0,
+          getPixelOffset: (activePower) => [...activePower.offset],
+          getTextAnchor: "middle",
+          visible: (!this.props.filteredNominalVoltages || this.props.filteredNominalVoltages.includes(compositeData.nominalV)) && this.props.labelsVisible,
+          opacity: this.props.areFlowsValid ? 1 : INVALID_FLOW_OPACITY,
+          updateTriggers: {
+            getPosition: [this.props.lineParallelPath, linePathUpdateTriggers],
+            getPixelOffset: linePathUpdateTriggers,
+            opacity: [this.props.areFlowsValid]
+          }
+        })
+      );
+      layers.push(lineActivePowerLabelsLayer);
+      const lineStatusIconLayer = new IconLayer(
+        this.getSubLayerProps({
+          id: "OperatingStatus" + compositeData.nominalV,
+          data: compositeData.operatingStatus,
+          // The position passed to this layer causes a bug when zooming and maxParallelOffset is reached:
+          // the icon is not correctly positioned on the lines, they are slightly off.
+          // In the custom layers, we clamp the distanceBetweenLines. This is not done in the deck.gl TextLayer
+          // and IconLayer or in the position calculated here.
+          getPosition: (operatingStatus) => operatingStatus.printPosition,
+          getIcon: (operatingStatus) => getLineIcon(operatingStatus.status),
+          getSize: this.props.iconSize,
+          getColor: () => this.props.labelColor,
+          getPixelOffset: (operatingStatus) => operatingStatus.offset,
+          visible: (!this.props.filteredNominalVoltages || this.props.filteredNominalVoltages.includes(compositeData.nominalV)) && this.props.labelsVisible,
+          updateTriggers: {
+            getPosition: [this.props.lineParallelPath, linePathUpdateTriggers],
+            getPixelOffset: linePathUpdateTriggers,
+            getIcon: [this.state.linesStatus],
+            getColor: [this.props.labelColor]
+          }
+        })
+      );
+      layers.push(lineStatusIconLayer);
+    });
+    return layers;
+  }
+};
+_LineLayer.layerName = "LineLayer";
+_LineLayer.defaultProps = {
+  network: void 0,
+  geoData: void 0,
+  getNominalVoltageColor: {
+    type: "accessor",
+    value: () => [255, 255, 255]
+    /*getNominalVoltageColor*/
+  },
+  disconnectedLineColor: { type: "color", value: [255, 255, 255] },
+  filteredNominalVoltages: void 0,
+  lineFlowMode: "feeders",
+  lineFlowColorMode: "nominalVoltage",
+  lineFlowAlertThreshold: 100,
+  showLineFlow: true,
+  lineFullPath: true,
+  lineParallelPath: true,
+  labelSize: 12,
+  iconSize: 48,
+  distanceBetweenLines: 1e3,
+  maxParallelOffset: 100,
+  minParallelOffset: 3,
+  substationRadius: { type: "number", value: SUBSTATION_RADIUS },
+  substationMaxPixel: { type: "number", value: SUBSTATION_RADIUS_MAX_PIXEL },
+  minSubstationRadiusPixel: {
+    type: "number",
+    value: SUBSTATION_RADIUS_MIN_PIXEL
+  },
+  labelColor: [255, 255, 255]
+};
+let LineLayer = _LineLayer;
+const elementIdIndexer = (map, element) => map.set(element.id, element);
+class MapEquipments {
+  constructor() {
+    this.substations = [];
+    this.substationsById = /* @__PURE__ */ new Map();
+    this.lines = [];
+    this.linesById = /* @__PURE__ */ new Map();
+    this.tieLines = [];
+    this.tieLinesById = /* @__PURE__ */ new Map();
+    this.hvdcLines = [];
+    this.hvdcLinesById = /* @__PURE__ */ new Map();
+    this.voltageLevels = [];
+    this.voltageLevelsById = /* @__PURE__ */ new Map();
+    this.nominalVoltages = [];
+  }
+  newMapEquipmentForUpdate() {
+    return Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+  }
+  checkAndGetValues(equipments) {
+    return equipments ?? [];
+  }
+  completeSubstationsInfos(equipmentsToIndex) {
+    const nominalVoltagesSet = new Set(this.nominalVoltages);
+    if ((equipmentsToIndex == null ? void 0 : equipmentsToIndex.length) === 0) {
+      this.substationsById = /* @__PURE__ */ new Map();
+      this.voltageLevelsById = /* @__PURE__ */ new Map();
+    }
+    const substations = (equipmentsToIndex == null ? void 0 : equipmentsToIndex.length) > 0 ? equipmentsToIndex : this.substations;
+    substations.forEach((substation) => {
+      substation.voltageLevels = substation.voltageLevels.sort(
+        (voltageLevel1, voltageLevel2) => voltageLevel1.nominalV - voltageLevel2.nominalV
+      );
+      this.substationsById.set(substation.id, substation);
+      substation.voltageLevels.forEach((voltageLevel) => {
+        voltageLevel.substationId = substation.id;
+        voltageLevel.substationName = substation.name;
+        this.voltageLevelsById.set(voltageLevel.id, voltageLevel);
+        nominalVoltagesSet.add(voltageLevel.nominalV);
+      });
+    });
+    this.voltageLevels = Array.from(this.voltageLevelsById.values());
+    this.nominalVoltages = Array.from(nominalVoltagesSet).sort((a, b) => b - a);
+  }
+  updateEquipments(currentEquipments, newEquipments) {
+    currentEquipments.forEach((equipment1, index) => {
+      const found = newEquipments.filter((equipment2) => equipment2.id === equipment1.id);
+      currentEquipments[index] = found.length > 0 ? found[0] : equipment1;
+    });
+    const eqptsToAdd = newEquipments.filter(
+      (eqpt) => !currentEquipments.some((otherEqpt) => otherEqpt.id === eqpt.id)
+    );
+    if (eqptsToAdd.length === 0) {
+      return currentEquipments;
+    }
+    return [...currentEquipments, ...eqptsToAdd];
+  }
+  updateSubstations(substations, fullReload) {
+    if (fullReload) {
+      this.substations = [];
+      this.nominalVoltages = [];
+    }
+    let voltageLevelAdded = false;
+    this.substations.forEach((substation1, index) => {
+      const found = substations.filter((substation2) => substation2.id === substation1.id);
+      if (found.length > 0) {
+        if (found[0].voltageLevels.length > substation1.voltageLevels.length) {
+          voltageLevelAdded = true;
+        }
+        this.substations[index] = found[0];
+      }
+    });
+    let substationAdded = false;
+    substations.forEach((substation1) => {
+      const found = this.substations.find((substation2) => substation2.id === substation1.id);
+      if (found === void 0) {
+        this.substations.push(substation1);
+        substationAdded = true;
+      }
+    });
+    if (substationAdded || voltageLevelAdded) {
+      this.substations = [...this.substations];
+    }
+    this.completeSubstationsInfos(fullReload ? [] : substations);
+  }
+  completeLinesInfos(equipmentsToIndex) {
+    if ((equipmentsToIndex == null ? void 0 : equipmentsToIndex.length) > 0) {
+      equipmentsToIndex.forEach((line) => {
+        var _a;
+        (_a = this.linesById) == null ? void 0 : _a.set(line.id, line);
+      });
+    } else {
+      this.linesById = this.lines.reduce(elementIdIndexer, /* @__PURE__ */ new Map());
+    }
+  }
+  completeTieLinesInfos(equipmentsToIndex) {
+    if ((equipmentsToIndex == null ? void 0 : equipmentsToIndex.length) > 0) {
+      equipmentsToIndex.forEach((tieLine) => {
+        var _a;
+        (_a = this.tieLinesById) == null ? void 0 : _a.set(tieLine.id, tieLine);
+      });
+    } else {
+      this.tieLinesById = this.tieLines.reduce(elementIdIndexer, /* @__PURE__ */ new Map());
+    }
+  }
+  updateLines(lines, fullReload) {
+    if (fullReload) {
+      this.lines = [];
+    }
+    this.lines = this.updateEquipments(this.lines, lines);
+    this.completeLinesInfos(fullReload ? [] : lines);
+  }
+  updateTieLines(tieLines, fullReload) {
+    if (fullReload) {
+      this.tieLines = [];
+    }
+    this.tieLines = this.updateEquipments(this.tieLines, tieLines);
+    this.completeTieLinesInfos(fullReload ? [] : tieLines);
+  }
+  updateHvdcLines(hvdcLines, fullReload) {
+    if (fullReload) {
+      this.hvdcLines = [];
+    }
+    this.hvdcLines = this.updateEquipments(this.hvdcLines, hvdcLines);
+    this.completeHvdcLinesInfos(fullReload ? [] : hvdcLines);
+  }
+  completeHvdcLinesInfos(equipmentsToIndex) {
+    if ((equipmentsToIndex == null ? void 0 : equipmentsToIndex.length) > 0) {
+      equipmentsToIndex.forEach((hvdcLine) => {
+        var _a;
+        (_a = this.hvdcLinesById) == null ? void 0 : _a.set(hvdcLine.id, hvdcLine);
+      });
+    } else {
+      this.hvdcLinesById = this.hvdcLines.reduce(elementIdIndexer, /* @__PURE__ */ new Map());
+    }
+  }
+  removeBranchesOfVoltageLevel(branchesList, voltageLevelId) {
+    const remainingLines = branchesList.filter(
+      (l) => l.voltageLevelId1 !== voltageLevelId && l.voltageLevelId2 !== voltageLevelId
+    );
+    branchesList.filter((l) => !remainingLines.includes(l)).forEach((l) => this.linesById.delete(l.id));
+    return remainingLines;
+  }
+  removeEquipment(equipmentType, equipmentId) {
+    var _a, _b;
+    switch (equipmentType) {
+      case EQUIPMENT_TYPES.LINE: {
+        this.lines = this.lines.filter((l) => l.id !== equipmentId);
+        this.linesById.delete(equipmentId);
+        break;
+      }
+      case EQUIPMENT_TYPES.VOLTAGE_LEVEL: {
+        const substationId = (_a = this.voltageLevelsById.get(equipmentId)) == null ? void 0 : _a.substationId;
+        let voltageLevelsOfSubstation = (_b = this.substationsById.get(substationId)) == null ? void 0 : _b.voltageLevels;
+        voltageLevelsOfSubstation = voltageLevelsOfSubstation == null ? void 0 : voltageLevelsOfSubstation.filter((l) => l.id !== equipmentId);
+        const substation = this.substationsById.get(substationId);
+        if (substation !== void 0) {
+          substation.voltageLevels = voltageLevelsOfSubstation;
+        }
+        this.removeBranchesOfVoltageLevel(this.lines, equipmentId);
+        this.substations = [...this.substations];
+        break;
+      }
+      case EQUIPMENT_TYPES.SUBSTATION: {
+        this.substations = this.substations.filter((l) => l.id !== equipmentId);
+        const substation = this.substationsById.get(equipmentId);
+        substation == null ? void 0 : substation.voltageLevels.forEach((vl) => this.removeEquipment(EQUIPMENT_TYPES.VOLTAGE_LEVEL, vl.id));
+        this.completeSubstationsInfos([substation]);
+        break;
+      }
+    }
+  }
+  getVoltageLevels() {
+    return this.voltageLevels;
+  }
+  getVoltageLevel(id) {
+    return this.voltageLevelsById.get(id);
+  }
+  getSubstations() {
+    return this.substations;
+  }
+  getSubstation(id) {
+    return this.substationsById.get(id);
+  }
+  getNominalVoltages() {
+    return this.nominalVoltages;
+  }
+  getLines() {
+    return this.lines;
+  }
+  getLine(id) {
+    return this.linesById.get(id);
+  }
+  getHvdcLines() {
+    return this.hvdcLines;
+  }
+  getHvdcLine(id) {
+    return this.hvdcLinesById.get(id);
+  }
+  getTieLines() {
+    return this.tieLines;
+  }
+  getTieLine(id) {
+    return this.tieLinesById.get(id);
+  }
+}
+const defaultProps = {
+  getRadiusMaxPixels: { type: "accessor", value: 1 }
+};
+const _ScatterplotLayerExt = class _ScatterplotLayerExt extends ScatterplotLayer {
+  getShaders() {
+    const shaders = super.getShaders();
+    return Object.assign({}, shaders, {
+      vs: shaders.vs.replace(", radiusMaxPixels", ", instanceRadiusMaxPixels"),
+      // hack to replace the uniform variable to corresponding attribute
+      inject: {
+        "vs:#decl": `attribute float instanceRadiusMaxPixels;
+`
+      }
+    });
+  }
+  initializeState() {
+    var _a;
+    super.initializeState();
+    (_a = this.getAttributeManager()) == null ? void 0 : _a.addInstanced({
+      instanceRadiusMaxPixels: {
+        size: 1,
+        transition: true,
+        accessor: "getRadiusMaxPixels",
+        type: GL.FLOAT,
+        defaultValue: 0
+      }
+    });
+  }
+};
+_ScatterplotLayerExt.layerName = "ScatterplotLayerExt";
+_ScatterplotLayerExt.defaultProps = defaultProps;
+let ScatterplotLayerExt = _ScatterplotLayerExt;
+function voltageLevelNominalVoltageIndexer(map, voltageLevel) {
+  let list = map.get(voltageLevel.nominalV);
+  if (!list) {
+    list = [];
+    map.set(voltageLevel.nominalV, list);
+  }
+  list.push(voltageLevel);
+  return map;
+}
+const _SubstationLayer = class _SubstationLayer extends CompositeLayer {
+  initializeState(context) {
+    super.initializeState(context);
+    this.state = {
+      compositeData: [],
+      substationsLabels: [],
+      metaVoltageLevelsByNominalVoltage: []
+    };
+  }
+  updateState({ props, oldProps, changeFlags }) {
+    if (changeFlags.dataChanged) {
+      const metaVoltageLevelsByNominalVoltage = /* @__PURE__ */ new Map();
+      if (props.network != null && props.geoData != null) {
+        props.data.forEach((substation) => {
+          const voltageLevelsByNominalVoltage = substation.voltageLevels.reduce(
+            voltageLevelNominalVoltageIndexer,
+            /* @__PURE__ */ new Map()
+          );
+          const nominalVoltages = [
+            ...new Set(
+              substation.voltageLevels.map((voltageLevel) => voltageLevel.nominalV).sort((nominalVoltage1, nominalVoltage2) => nominalVoltage1 - nominalVoltage2)
+            )
+          ];
+          Array.from(voltageLevelsByNominalVoltage.entries()).forEach((e) => {
+            const nominalV = e[0];
+            const voltageLevels = e[1];
+            let metaVoltageLevels = metaVoltageLevelsByNominalVoltage.get(nominalV);
+            if (!metaVoltageLevels) {
+              metaVoltageLevels = [];
+              metaVoltageLevelsByNominalVoltage.set(nominalV, metaVoltageLevels);
+            }
+            metaVoltageLevels.push({
+              voltageLevels,
+              nominalVoltageIndex: nominalVoltages.indexOf(nominalV)
+            });
+          });
+        });
+      }
+      const metaVoltageLevelsByNominalVoltageArray = Array.from(metaVoltageLevelsByNominalVoltage).map((e) => ({ nominalV: e[0], metaVoltageLevels: e[1] })).sort((a, b) => b.nominalV - a.nominalV);
+      this.setState({ metaVoltageLevelsByNominalVoltage: metaVoltageLevelsByNominalVoltageArray });
+    }
+    if (changeFlags.dataChanged || props.getNameOrId !== oldProps.getNameOrId || props.filteredNominalVoltages !== oldProps.filteredNominalVoltages) {
+      let substationsLabels = props.data;
+      if (props.network != null && props.geoData != null && props.filteredNominalVoltages != null) {
+        substationsLabels = substationsLabels.filter(
+          (substation) => substation.voltageLevels.find((v) => {
+            var _a;
+            return (_a = props.filteredNominalVoltages) == null ? void 0 : _a.includes(v.nominalV);
+          }) !== void 0
+        );
+      }
+      this.setState({ substationsLabels });
+    }
+  }
+  renderLayers() {
+    const layers = [];
+    this.state.metaVoltageLevelsByNominalVoltage.forEach((e) => {
+      const substationsLayer = new ScatterplotLayerExt(
+        this.getSubLayerProps({
+          id: "NominalVoltage" + e.nominalV,
+          data: e.metaVoltageLevels,
+          radiusMinPixels: SUBSTATION_RADIUS_MIN_PIXEL,
+          getRadiusMaxPixels: (metaVoltageLevel) => SUBSTATION_RADIUS_MAX_PIXEL * (metaVoltageLevel.nominalVoltageIndex + 1),
+          getPosition: (metaVoltageLevel) => this.props.geoData.getSubstationPosition(metaVoltageLevel.voltageLevels[0].substationId),
+          getFillColor: this.props.getNominalVoltageColor(e.nominalV),
+          getRadius: (voltageLevel) => SUBSTATION_RADIUS * (voltageLevel.nominalVoltageIndex + 1),
+          visible: !this.props.filteredNominalVoltages || this.props.filteredNominalVoltages.includes(e.nominalV),
+          updateTriggers: {
+            getPosition: [this.props.geoData.substationPositionsById, this.props.network.substations]
+          }
+        })
+      );
+      layers.push(substationsLayer);
+    });
+    const substationLabelsLayer = new TextLayer(
+      this.getSubLayerProps({
+        id: "Label",
+        data: this.state.substationsLabels,
+        getPosition: (substation) => this.props.geoData.getSubstationPosition(substation.id),
+        getText: (substation) => this.props.getNameOrId(substation) ?? "",
+        getColor: this.props.labelColor,
+        fontFamily: "Roboto",
+        getSize: this.props.labelSize,
+        getAngle: 0,
+        getTextAnchor: "start",
+        getAlignmentBaseline: "center",
+        getPixelOffset: [20 / 1.5, 0],
+        visible: this.props.labelsVisible,
+        updateTriggers: {
+          getText: [this.props.getNameOrId],
+          getPosition: [this.props.geoData.substationPositionsById, this.props.network.substations]
+        }
+      })
+    );
+    layers.push(substationLabelsLayer);
+    return layers;
+  }
+};
+_SubstationLayer.layerName = "SubstationLayer";
+_SubstationLayer.defaultProps = {
+  network: void 0,
+  geoData: void 0,
+  getNominalVoltageColor: { type: "accessor", value: () => [255, 255, 255] },
+  filteredNominalVoltages: null,
+  labelsVisible: false,
+  labelColor: { type: "color", value: [255, 255, 255] },
+  labelSize: 12
+};
+let SubstationLayer = _SubstationLayer;
+var Country = /* @__PURE__ */ ((Country2) => {
+  Country2["AF"] = "AFGHANISTAN";
+  Country2["AX"] = "ÅLAND ISLANDS";
+  Country2["AL"] = "ALBANIA";
+  Country2["DZ"] = "ALGERIA";
+  Country2["AS"] = "AMERICAN SAMOA";
+  Country2["AD"] = "ANDORRA";
+  Country2["AO"] = "ANGOLA";
+  Country2["AI"] = "ANGUILLA";
+  Country2["AQ"] = "ANTARCTICA";
+  Country2["AG"] = "ANTIGUA AND BARBUDA";
+  Country2["AR"] = "ARGENTINA";
+  Country2["AM"] = "ARMENIA";
+  Country2["AW"] = "ARUBA";
+  Country2["AU"] = "AUSTRALIA";
+  Country2["AT"] = "AUSTRIA";
+  Country2["AZ"] = "AZERBAIJAN";
+  Country2["BS"] = "BAHAMAS";
+  Country2["BH"] = "BAHRAIN";
+  Country2["BD"] = "BANGLADESH";
+  Country2["BB"] = "BARBADOS";
+  Country2["BY"] = "BELARUS";
+  Country2["BE"] = "BELGIUM";
+  Country2["BZ"] = "BELIZE";
+  Country2["BJ"] = "BENIN";
+  Country2["BM"] = "BERMUDA";
+  Country2["BT"] = "BHUTAN";
+  Country2["BO"] = "BOLIVIA, PLURINATIONAL STATE OF";
+  Country2["BQ"] = "BONAIRE, SINT EUSTATIUS AND SABA";
+  Country2["BA"] = "BOSNIA AND HERZEGOVINA";
+  Country2["BW"] = "BOTSWANA";
+  Country2["BV"] = "BOUVET ISLAND";
+  Country2["BR"] = "BRAZIL";
+  Country2["IO"] = "BRITISH INDIAN OCEAN TERRITORY";
+  Country2["BN"] = "BRUNEI DARUSSALAM";
+  Country2["BG"] = "BULGARIA";
+  Country2["BF"] = "BURKINA FASO";
+  Country2["BI"] = "BURUNDI";
+  Country2["KH"] = "CAMBODIA";
+  Country2["CM"] = "CAMEROON";
+  Country2["CA"] = "CANADA";
+  Country2["CV"] = "CAPE VERDE";
+  Country2["KY"] = "CAYMAN ISLANDS";
+  Country2["CF"] = "CENTRAL AFRICAN REPUBLIC";
+  Country2["TD"] = "CHAD";
+  Country2["CL"] = "CHILE";
+  Country2["CN"] = "CHINA";
+  Country2["CX"] = "CHRISTMAS ISLAND";
+  Country2["CC"] = "COCOS (KEELING) ISLANDS";
+  Country2["CO"] = "COLOMBIA";
+  Country2["KM"] = "COMOROS";
+  Country2["CG"] = "CONGO";
+  Country2["CD"] = "CONGO, THE DEMOCRATIC REPUBLIC OF THE";
+  Country2["CK"] = "COOK ISLANDS";
+  Country2["CR"] = "COSTA RICA";
+  Country2["CI"] = "CÔTE D'IVOIRE";
+  Country2["HR"] = "CROATIA";
+  Country2["CU"] = "CUBA";
+  Country2["CW"] = "CURAÇAO";
+  Country2["CY"] = "CYPRUS";
+  Country2["CZ"] = "CZECH REPUBLIC";
+  Country2["DK"] = "DENMARK";
+  Country2["DJ"] = "DJIBOUTI";
+  Country2["DM"] = "DOMINICA";
+  Country2["DO"] = "DOMINICAN REPUBLIC";
+  Country2["EC"] = "ECUADOR";
+  Country2["EG"] = "EGYPT";
+  Country2["SV"] = "EL SALVADOR";
+  Country2["GQ"] = "EQUATORIAL GUINEA";
+  Country2["ER"] = "ERITREA";
+  Country2["EE"] = "ESTONIA";
+  Country2["ET"] = "ETHIOPIA";
+  Country2["FK"] = "FALKLAND ISLANDS (MALVINAS)";
+  Country2["FO"] = "FAROE ISLANDS";
+  Country2["FJ"] = "FIJI";
+  Country2["FI"] = "FINLAND";
+  Country2["FR"] = "FRANCE";
+  Country2["GF"] = "FRENCH GUIANA";
+  Country2["PF"] = "FRENCH POLYNESIA";
+  Country2["TF"] = "FRENCH SOUTHERN TERRITORIES";
+  Country2["GA"] = "GABON";
+  Country2["GM"] = "GAMBIA";
+  Country2["GE"] = "GEORGIA";
+  Country2["DE"] = "GERMANY";
+  Country2["GH"] = "GHANA";
+  Country2["GI"] = "GIBRALTAR";
+  Country2["GR"] = "GREECE";
+  Country2["GL"] = "GREENLAND";
+  Country2["GD"] = "GRENADA";
+  Country2["GP"] = "GUADELOUPE";
+  Country2["GU"] = "GUAM";
+  Country2["GT"] = "GUATEMALA";
+  Country2["GG"] = "GUERNSEY";
+  Country2["GN"] = "GUINEA";
+  Country2["GW"] = "GUINEA-BISSAU";
+  Country2["GY"] = "GUYANA";
+  Country2["HT"] = "HAITI";
+  Country2["HM"] = "HEARD ISLAND AND MCDONALD ISLANDS";
+  Country2["VA"] = "HOLY SEE (VATICAN CITY STATE)";
+  Country2["HN"] = "HONDURAS";
+  Country2["HK"] = "HONG KONG";
+  Country2["HU"] = "HUNGARY";
+  Country2["IS"] = "ICELAND";
+  Country2["IN"] = "INDIA";
+  Country2["ID"] = "INDONESIA";
+  Country2["IR"] = "IRAN, ISLAMIC REPUBLIC OF";
+  Country2["IQ"] = "IRAQ";
+  Country2["IE"] = "IRELAND";
+  Country2["IM"] = "ISLE OF MAN";
+  Country2["IL"] = "ISRAEL";
+  Country2["IT"] = "ITALY";
+  Country2["JM"] = "JAMAICA";
+  Country2["JP"] = "JAPAN";
+  Country2["JE"] = "JERSEY";
+  Country2["JO"] = "JORDAN";
+  Country2["KZ"] = "KAZAKHSTAN";
+  Country2["KE"] = "KENYA";
+  Country2["KI"] = "KIRIBATI";
+  Country2["KP"] = "KOREA, DEMOCRATIC PEOPLE'S REPUBLIC OF";
+  Country2["KR"] = "KOREA, REPUBLIC OF";
+  Country2["XK"] = "KOSOVO";
+  Country2["KW"] = "KUWAIT";
+  Country2["KG"] = "KYRGYZSTAN";
+  Country2["LA"] = "LAO PEOPLE'S DEMOCRATIC REPUBLIC";
+  Country2["LV"] = "LATVIA";
+  Country2["LB"] = "LEBANON";
+  Country2["LS"] = "LESOTHO";
+  Country2["LR"] = "LIBERIA";
+  Country2["LY"] = "LIBYA";
+  Country2["LI"] = "LIECHTENSTEIN";
+  Country2["LT"] = "LITHUANIA";
+  Country2["LU"] = "LUXEMBOURG";
+  Country2["MO"] = "MACAO";
+  Country2["MK"] = "MACEDONIA, THE FORMER YUGOSLAV REPUBLIC OF";
+  Country2["MG"] = "MADAGASCAR";
+  Country2["MW"] = "MALAWI";
+  Country2["MY"] = "MALAYSIA";
+  Country2["MV"] = "MALDIVES";
+  Country2["ML"] = "MALI";
+  Country2["MT"] = "MALTA";
+  Country2["MH"] = "MARSHALL ISLANDS";
+  Country2["MQ"] = "MARTINIQUE";
+  Country2["MR"] = "MAURITANIA";
+  Country2["MU"] = "MAURITIUS";
+  Country2["YT"] = "MAYOTTE";
+  Country2["MX"] = "MEXICO";
+  Country2["FM"] = "MICRONESIA, FEDERATED STATES OF";
+  Country2["MD"] = "MOLDOVA, REPUBLIC OF";
+  Country2["MC"] = "MONACO";
+  Country2["MN"] = "MONGOLIA";
+  Country2["ME"] = "MONTENEGRO";
+  Country2["MS"] = "MONTSERRAT";
+  Country2["MA"] = "MOROCCO";
+  Country2["MZ"] = "MOZAMBIQUE";
+  Country2["MM"] = "MYANMAR";
+  Country2["NA"] = "NAMIBIA";
+  Country2["NR"] = "NAURU";
+  Country2["NP"] = "NEPAL";
+  Country2["NL"] = "NETHERLANDS";
+  Country2["NC"] = "NEW CALEDONIA";
+  Country2["NZ"] = "NEW ZEALAND";
+  Country2["NI"] = "NICARAGUA";
+  Country2["NE"] = "NIGER";
+  Country2["NG"] = "NIGERIA";
+  Country2["NU"] = "NIUE";
+  Country2["NF"] = "NORFOLK ISLAND";
+  Country2["MP"] = "NORTHERN MARIANA ISLANDS";
+  Country2["NO"] = "NORWAY";
+  Country2["OM"] = "OMAN";
+  Country2["PK"] = "PAKISTAN";
+  Country2["PW"] = "PALAU";
+  Country2["PS"] = "PALESTINE, STATE OF";
+  Country2["PA"] = "PANAMA";
+  Country2["PG"] = "PAPUA NEW GUINEA";
+  Country2["PY"] = "PARAGUAY";
+  Country2["PE"] = "PERU";
+  Country2["PH"] = "PHILIPPINES";
+  Country2["PN"] = "PITCAIRN";
+  Country2["PL"] = "POLAND";
+  Country2["PT"] = "PORTUGAL";
+  Country2["PR"] = "PUERTO RICO";
+  Country2["QA"] = "QATAR";
+  Country2["RE"] = "RÉUNION";
+  Country2["RO"] = "ROMANIA";
+  Country2["RU"] = "RUSSIAN FEDERATION";
+  Country2["RW"] = "RWANDA";
+  Country2["BL"] = "SAINT BARTHÉLEMY";
+  Country2["SH"] = "SAINT HELENA, ASCENSION AND TRISTAN DA CUNHA";
+  Country2["KN"] = "SAINT KITTS AND NEVIS";
+  Country2["LC"] = "SAINT LUCIA";
+  Country2["MF"] = "SAINT MARTIN (FRENCH PART)";
+  Country2["PM"] = "SAINT PIERRE AND MIQUELON";
+  Country2["VC"] = "SAINT VINCENT AND THE GRENADINES";
+  Country2["WS"] = "SAMOA";
+  Country2["SM"] = "SAN MARINO";
+  Country2["ST"] = "SAO TOME AND PRINCIPE";
+  Country2["SA"] = "SAUDI ARABIA";
+  Country2["SN"] = "SENEGAL";
+  Country2["RS"] = "SERBIA";
+  Country2["SC"] = "SEYCHELLES";
+  Country2["SL"] = "SIERRA LEONE";
+  Country2["SG"] = "SINGAPORE";
+  Country2["SX"] = "SINT MAARTEN (DUTCH PART)";
+  Country2["SK"] = "SLOVAKIA";
+  Country2["SI"] = "SLOVENIA";
+  Country2["SB"] = "SOLOMON ISLANDS";
+  Country2["SO"] = "SOMALIA";
+  Country2["ZA"] = "SOUTH AFRICA";
+  Country2["GS"] = "SOUTH GEORGIA AND THE SOUTH SANDWICH ISLANDS";
+  Country2["SS"] = "SOUTH SUDAN";
+  Country2["ES"] = "SPAIN";
+  Country2["LK"] = "SRI LANKA";
+  Country2["SD"] = "SUDAN";
+  Country2["SR"] = "SURINAME";
+  Country2["SJ"] = "SVALBARD AND JAN MAYEN";
+  Country2["SZ"] = "SWAZILAND";
+  Country2["SE"] = "SWEDEN";
+  Country2["CH"] = "SWITZERLAND";
+  Country2["SY"] = "SYRIAN ARAB REPUBLIC";
+  Country2["TW"] = "TAIWAN, PROVINCE OF CHINA";
+  Country2["TJ"] = "TAJIKISTAN";
+  Country2["TZ"] = "TANZANIA, UNITED REPUBLIC OF";
+  Country2["TH"] = "THAILAND";
+  Country2["TL"] = "TIMOR-LESTE";
+  Country2["TG"] = "TOGO";
+  Country2["TK"] = "TOKELAU";
+  Country2["TO"] = "TONGA";
+  Country2["TT"] = "TRINIDAD AND TOBAGO";
+  Country2["TN"] = "TUNISIA";
+  Country2["TR"] = "TURKEY";
+  Country2["TM"] = "TURKMENISTAN";
+  Country2["TC"] = "TURKS AND CAICOS ISLANDS";
+  Country2["TV"] = "TUVALU";
+  Country2["UG"] = "UGANDA";
+  Country2["UA"] = "UKRAINE";
+  Country2["AE"] = "UNITED ARAB EMIRATES";
+  Country2["GB"] = "UNITED KINGDOM";
+  Country2["US"] = "UNITED STATES";
+  Country2["UM"] = "UNITED STATES MINOR OUTLYING ISLANDS";
+  Country2["UY"] = "URUGUAY";
+  Country2["UZ"] = "UZBEKISTAN";
+  Country2["VU"] = "VANUATU";
+  Country2["VE"] = "VENEZUELA, BOLIVARIAN REPUBLIC OF";
+  Country2["VN"] = "VIET NAM";
+  Country2["VG"] = "VIRGIN ISLANDS, BRITISH";
+  Country2["VI"] = "VIRGIN ISLANDS, U.S.";
+  Country2["WF"] = "WALLIS AND FUTUNA";
+  Country2["EH"] = "WESTERN SAHARA";
+  Country2["YE"] = "YEMEN";
+  Country2["ZM"] = "ZAMBIA";
+  Country2["ZW"] = "ZIMBABWE";
+  return Country2;
+})(Country || {});
+export {
+  Country,
+  EQUIPMENT_TYPES,
+  GeoData,
+  LineFlowColorMode,
+  LineFlowMode,
+  LineLayer,
+  MapEquipments,
+  SubstationLayer,
+  getNominalVoltageColor
+};