@wemap/geo 10.10.0 → 10.11.2

package/dist/index.js

@@ -0,0 +1,1848 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const maths = require("@wemap/maths");
+const Logger = require("@wemap/logger");
+const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
+const Logger__default = /* @__PURE__ */ _interopDefaultLegacy(Logger);
+const R_MAJOR = 6378137;
+const R_MINOR = 63567523142e-4;
+const EARTH_GRAVITY = 9.80665;
+const EPS_DEG_MM = 1e-8;
+const EPS_MM = 1e-3;
+const ELLIPSOID_FLATNESS = (R_MAJOR - R_MINOR) / R_MAJOR;
+const ECCENTRICITY = Math.sqrt(ELLIPSOID_FLATNESS * (2 - ELLIPSOID_FLATNESS));
+const ECCENTRICITY_2 = ECCENTRICITY * ECCENTRICITY;
+const R_MAJOR_2 = R_MAJOR * R_MAJOR;
+const R_MAJOR_4 = R_MAJOR_2 * R_MAJOR_2;
+const R_MINOR_2 = R_MINOR * R_MINOR;
+const R_MINOR_4 = R_MINOR_2 * R_MINOR_2;
+const CIRCUMFERENCE = R_MAJOR * 2 * Math.PI;
+const Constants = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  R_MAJOR,
+  R_MINOR,
+  EARTH_GRAVITY,
+  EPS_DEG_MM,
+  EPS_MM,
+  ELLIPSOID_FLATNESS,
+  ECCENTRICITY,
+  ECCENTRICITY_2,
+  R_MAJOR_2,
+  R_MAJOR_4,
+  R_MINOR_2,
+  R_MINOR_4,
+  CIRCUMFERENCE
+}, Symbol.toStringTag, { value: "Module" }));
+const _Level = class {
+  static checkType(level) {
+    if (level === null) {
+      return;
+    }
+    if (typeof level === "number" && !isNaN(level)) {
+      return;
+    }
+    if (Array.isArray(level) && level.length === 2) {
+      const [low, up] = level;
+      if (typeof low === "number" && !isNaN(low) && typeof up === "number" && !isNaN(up)) {
+        if (low > up || low === up) {
+          throw Error(`Invalid level range: [${low}, ${up}]`);
+        }
+        return;
+      }
+    }
+    throw Error(`Unknown level format: ${level}`);
+  }
+  static isRange(level) {
+    if (_Level.VERIFY_TYPING) {
+      this.checkType(level);
+    }
+    return Array.isArray(level);
+  }
+  static clone(level) {
+    if (_Level.VERIFY_TYPING) {
+      this.checkType(level);
+    }
+    if (level === null) {
+      return null;
+    }
+    if (typeof level === "number") {
+      return level;
+    }
+    return [level[0], level[1]];
+  }
+  static fromString(str) {
+    if (str === null) {
+      return null;
+    }
+    if (typeof str !== "string") {
+      throw Error(`argument must be a string, got ${typeof str}`);
+    }
+    if (!isNaN(Number(str))) {
+      return parseFloat(str);
+    }
+    const splited = str.split(";");
+    if (splited.length === 2) {
+      const low = Number(splited[0]);
+      const up = Number(splited[1]);
+      this.checkType([low, up]);
+      return [parseFloat(splited[0]), parseFloat(splited[1])];
+    }
+    throw Error(`Cannot parse following level: ${str}`);
+  }
+  static contains(container, targeted) {
+    if (_Level.VERIFY_TYPING) {
+      this.checkType(container);
+      this.checkType(targeted);
+    }
+    if (container === targeted) {
+      return true;
+    }
+    if (Array.isArray(container)) {
+      if (Array.isArray(targeted)) {
+        return container[0] <= targeted[0] && container[1] >= targeted[1];
+      }
+      if (targeted === null) {
+        return false;
+      }
+      return container[0] <= targeted && container[1] >= targeted;
+    }
+    if (container === null || targeted === null) {
+      return false;
+    }
+    return container <= targeted[0] && container >= targeted[1];
+  }
+  static intersection(first, second) {
+    if (_Level.VERIFY_TYPING) {
+      this.checkType(first);
+      this.checkType(second);
+    }
+    if (first === null || second === null) {
+      return null;
+    }
+    if (this.equals(first, second)) {
+      return this.clone(first);
+    }
+    if (typeof first === "number" && typeof second === "number") {
+      return first === second ? first : null;
+    }
+    if (Array.isArray(first) && !Array.isArray(second)) {
+      if (this.contains(first, second)) {
+        return second;
+      }
+      return null;
+    }
+    if (!Array.isArray(first) && Array.isArray(second)) {
+      if (this.contains(second, first)) {
+        return first;
+      }
+      return null;
+    }
+    const low = Math.max(first[0], second[0]);
+    const up = Math.min(first[1], second[1]);
+    if (up === low) {
+      return up;
+    }
+    return up < low ? null : [low, up];
+  }
+  static intersect(first, second) {
+    if (_Level.VERIFY_TYPING) {
+      this.checkType(first);
+      this.checkType(second);
+    }
+    if (first === null && second === null) {
+      return true;
+    }
+    return this.intersection(first, second) !== null;
+  }
+  static union(first, second) {
+    if (_Level.VERIFY_TYPING) {
+      this.checkType(first);
+      this.checkType(second);
+    }
+    if (first === second) {
+      return this.clone(first);
+    }
+    if (second === null) {
+      return this.clone(first);
+    }
+    if (first === null) {
+      return this.clone(second);
+    }
+    let low, up;
+    if (!Array.isArray(first) && !Array.isArray(second)) {
+      low = Math.min(first, second);
+      up = Math.max(first, second);
+    } else if (Array.isArray(first) && !Array.isArray(second)) {
+      low = Math.min(first[0], second);
+      up = Math.max(first[1], second);
+    } else if (!Array.isArray(first) && Array.isArray(second)) {
+      low = Math.min(second[0], first);
+      up = Math.max(second[1], first);
+    } else {
+      low = Math.min(first[0], second[0]);
+      up = Math.max(first[1], second[1]);
+    }
+    if (low === up) {
+      return low;
+    }
+    return [low, up];
+  }
+  static multiplyBy(level, factor) {
+    if (_Level.VERIFY_TYPING) {
+      this.checkType(level);
+    }
+    if (level === null) {
+      return null;
+    }
+    return Array.isArray(level) ? [level[0] * factor, level[1] * factor] : level * factor;
+  }
+  static toString(level) {
+    if (_Level.VERIFY_TYPING) {
+      this.checkType(level);
+    }
+    if (level === null) {
+      return null;
+    }
+    return Array.isArray(level) ? level[0] + ";" + level[1] : String(level);
+  }
+  static equals(first, second) {
+    if (_Level.VERIFY_TYPING) {
+      this.checkType(first);
+      this.checkType(second);
+    }
+    if (first === second) {
+      return true;
+    }
+    if (Array.isArray(first) && Array.isArray(second)) {
+      return first[0] === second[0] && first[1] === second[1];
+    }
+    return false;
+  }
+  static diff(first, second) {
+    if (_Level.VERIFY_TYPING) {
+      this.checkType(first);
+      this.checkType(second);
+    }
+    if (first === null || second === null) {
+      return null;
+    }
+    if (!Array.isArray(first) && !Array.isArray(second)) {
+      return second - first;
+    }
+    if (Array.isArray(first) && !Array.isArray(second)) {
+      if (first[0] === second) {
+        return second - first[1];
+      }
+      if (first[1] === second) {
+        return second - first[0];
+      }
+      return null;
+    }
+    if (Array.isArray(second) && !Array.isArray(first)) {
+      if (first === second[0]) {
+        return second[1] - first;
+      }
+      if (first === second[1]) {
+        return second[0] - first;
+      }
+      return null;
+    }
+    if (_Level.equals(first, second)) {
+      return 0;
+    }
+    return null;
+  }
+};
+let Level = _Level;
+__publicField(Level, "VERIFY_TYPING", false);
+class Coordinates {
+  constructor(lat, lng, alt = null, level = null) {
+    __publicField(this, "_lat");
+    __publicField(this, "_lng");
+    __publicField(this, "_alt", null);
+    __publicField(this, "_level", null);
+    __publicField(this, "_ecef");
+    __publicField(this, "autoWrap", true);
+    this.lat = lat;
+    this.lng = lng;
+    this.alt = alt;
+    this.level = level;
+    this._ecef = null;
+  }
+  get lat() {
+    return this._lat;
+  }
+  set lat(lat) {
+    if (Math.abs(lat) <= 90) {
+      this._lat = lat;
+    } else {
+      throw new Error("lat argument is not in [-90; 90]");
+    }
+    this._ecef = null;
+  }
+  get latitude() {
+    return this._lat;
+  }
+  set latitude(_) {
+    throw new Error("Please use Coordinates#lat setter instead of Coordinate#latitude");
+  }
+  get lng() {
+    return this._lng;
+  }
+  set lng(lng) {
+    this._lng = lng;
+    if (this.autoWrap) {
+      this.wrap();
+    }
+    this._ecef = null;
+  }
+  get longitude() {
+    return this._lng;
+  }
+  set longitude(_) {
+    throw new Error("Please use Coordinates#lng setter instead of Coordinate#longitude");
+  }
+  get alt() {
+    return this._alt;
+  }
+  set alt(alt) {
+    this._alt = alt;
+    this._ecef = null;
+  }
+  get level() {
+    return this._level;
+  }
+  set level(level) {
+    Level.checkType(level);
+    this._level = level;
+  }
+  clone() {
+    const output = new Coordinates(this.lat, this.lng, this.alt);
+    if (this.level !== null) {
+      output.level = Level.clone(this.level);
+    }
+    return output;
+  }
+  wrap() {
+    if (this._lng <= -180 || this._lng > 180) {
+      this._lng = maths.wrap(this._lng, -180, 180);
+    }
+  }
+  static equals(pos1, pos2, eps = EPS_DEG_MM, epsAlt = EPS_MM) {
+    if (pos1 === null && pos1 === pos2) {
+      return true;
+    }
+    if (!(pos1 instanceof Coordinates) || !(pos2 instanceof Coordinates)) {
+      return false;
+    }
+    return Math.abs(pos2.lat - pos1.lat) < eps && Math.abs(pos2.lng - pos1.lng) < eps && (pos1.alt === pos2.alt || pos1.alt !== null && pos2.alt !== null && Math.abs(pos2.alt - pos1.alt) < epsAlt) && Level.equals(pos1.level, pos2.level);
+  }
+  equals(other) {
+    return Coordinates.equals(this, other);
+  }
+  destinationPoint(distance, bearing, elevation = null) {
+    const newPoint = this.clone();
+    newPoint.move(distance, bearing, elevation);
+    return newPoint;
+  }
+  move(distance, bearing, elevation = null) {
+    const dR = distance / R_MAJOR;
+    const cosDr = Math.cos(dR);
+    const sinDr = Math.sin(dR);
+    const phi1 = maths.deg2rad(this.lat);
+    const lambda1 = maths.deg2rad(this.lng);
+    const phi2 = Math.asin(
+      Math.sin(phi1) * cosDr + Math.cos(phi1) * sinDr * Math.cos(bearing)
+    );
+    const lambda2 = lambda1 + Math.atan2(
+      Math.sin(bearing) * sinDr * Math.cos(phi1),
+      cosDr - Math.sin(phi1) * Math.sin(phi2)
+    );
+    this.lat = maths.rad2deg(phi2);
+    this.lng = maths.rad2deg(lambda2);
+    if (elevation !== null) {
+      if (this.alt === null) {
+        throw new Error("Point altitude is not defined");
+      }
+      this.alt += elevation;
+    }
+    return this;
+  }
+  distanceTo(location2) {
+    const lat1 = this.lat;
+    const lng1 = this.lng;
+    const lat2 = location2.lat;
+    const lng2 = location2.lng;
+    const dlat = maths.deg2rad(lat2 - lat1);
+    const dlng = maths.deg2rad(lng2 - lng1);
+    const dlngsin = Math.sin(dlng / 2);
+    const dlatsin = Math.sin(dlat / 2);
+    const lat1rad = maths.deg2rad(lat1);
+    const lat1cos = Math.cos(lat1rad);
+    const lat2rad = maths.deg2rad(lat2);
+    const lat2cos = Math.cos(lat2rad);
+    const angle = dlatsin * dlatsin + lat1cos * lat2cos * dlngsin * dlngsin;
+    const tangy = Math.sqrt(angle);
+    const tangx = Math.sqrt(1 - angle);
+    const cosn = 2 * Math.atan2(tangy, tangx);
+    return R_MAJOR * cosn;
+  }
+  static distanceBetween(point1, point2) {
+    return point1.distanceTo(point2);
+  }
+  bearingTo(location2) {
+    const lat1 = maths.deg2rad(this.lat);
+    const lat2 = maths.deg2rad(location2.lat);
+    const diffLng = maths.deg2rad(location2.lng - this.lng);
+    return Math.atan2(
+      Math.sin(diffLng) * Math.cos(lat2),
+      Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(diffLng)
+    );
+  }
+  static bearingTo(point1, point2) {
+    return point1.bearingTo(point2);
+  }
+  get enuToEcefRotation() {
+    const rot1 = maths.Quaternion.fromAxisAngle([0, 0, 1], Math.PI / 2 + maths.deg2rad(this.lng));
+    const rot2 = maths.Quaternion.fromAxisAngle([1, 0, 0], Math.PI / 2 - maths.deg2rad(this.lat));
+    return maths.Quaternion.multiply(rot1, rot2);
+  }
+  get ecefToEnuRotation() {
+    const rot1 = maths.Quaternion.fromAxisAngle([1, 0, 0], maths.deg2rad(this.lat) - Math.PI / 2);
+    const rot2 = maths.Quaternion.fromAxisAngle([0, 0, 1], -maths.deg2rad(this.lng) - Math.PI / 2);
+    return maths.Quaternion.multiply(rot1, rot2);
+  }
+  get ecef() {
+    if (!this._ecef) {
+      const lat = maths.deg2rad(this.lat);
+      const lng = maths.deg2rad(this.lng);
+      const alt = this.alt || 0;
+      const x = (R_MAJOR + alt) * Math.cos(lat) * Math.cos(lng);
+      const y = (R_MAJOR + alt) * Math.cos(lat) * Math.sin(lng);
+      const z = (R_MAJOR + alt) * Math.sin(lat);
+      this._ecef = [x, y, z];
+    }
+    return this._ecef;
+  }
+  static fromECEF(ecef) {
+    const x = ecef[0];
+    const y = ecef[1];
+    const z = ecef[2];
+    const p = Math.sqrt(x ** 2 + y ** 2);
+    let lng = Math.atan2(y, x);
+    const lat = Math.atan2(z, p);
+    const alt = p / Math.cos(lat) - R_MAJOR;
+    lng = lng % (2 * Math.PI);
+    const newPoint = new Coordinates(maths.rad2deg(lat), maths.rad2deg(lng), alt);
+    newPoint._ecef = ecef;
+    return newPoint;
+  }
+  getSegmentProjection(p1, p2) {
+    const a = maths.Vector3.normalize(p1.ecef);
+    const b = maths.Vector3.normalize(p2.ecef);
+    const c = maths.Vector3.normalize(this.ecef);
+    const G = maths.Vector3.cross(a, b);
+    if (maths.Vector3.norm(G) === 0) {
+      return null;
+    }
+    const F = maths.Vector3.cross(c, G);
+    const t = maths.Vector3.normalize(maths.Vector3.cross(G, F));
+    const posECEF = maths.Vector3.multiplyScalar(t, R_MAJOR);
+    const poseCoordinates = Coordinates.fromECEF(posECEF);
+    let alt;
+    if (p1.alt !== null && p2.alt !== null) {
+      alt = (p1.alt + p2.alt) / 2;
+    }
+    const projection = new Coordinates(
+      poseCoordinates.lat,
+      poseCoordinates.lng,
+      alt,
+      Level.intersection(p1.level, p2.level)
+    );
+    if (Math.abs(p1.distanceTo(p2) - p1.distanceTo(projection) - p2.distanceTo(projection)) > EPS_MM) {
+      return null;
+    }
+    return projection;
+  }
+  toString() {
+    let str = "[" + this._lat.toFixed(7) + ", " + this._lng.toFixed(7);
+    if (this._alt !== null) {
+      str += ", " + this._alt.toFixed(2);
+    }
+    if (this._level !== null) {
+      str += ", [" + Level.toString(this._level) + "]";
+    }
+    str += "]";
+    return str;
+  }
+  toJson() {
+    return {
+      lat: this.lat,
+      lng: this.lng,
+      ...this.alt !== null && { alt: this.alt },
+      ...this.level !== null && { level: this.level }
+    };
+  }
+  static fromJson(json) {
+    return new Coordinates(json.lat, json.lng, json.alt, json.level);
+  }
+  toCompressedJson() {
+    if (this.level !== null) {
+      return [this.lat, this.lng, this.alt, this.level];
+    }
+    if (this.alt !== null) {
+      return [this.lat, this.lng, this.alt];
+    }
+    return [this.lat, this.lng];
+  }
+  static fromCompressedJson(json) {
+    const coords = new Coordinates(json[0], json[1]);
+    if (json.length > 2) {
+      coords.alt = json[2];
+    }
+    if (json.length > 3) {
+      coords.level = json[3];
+    }
+    return coords;
+  }
+}
+class UserPosition extends Coordinates {
+  constructor(lat, lng, alt = null, level = null, time = null, accuracy = null, bearing = null) {
+    super(lat, lng, alt, level);
+    __publicField(this, "_time", null);
+    __publicField(this, "_accuracy", null);
+    __publicField(this, "_bearing", null);
+    this.time = time;
+    this.accuracy = accuracy;
+    this.bearing = bearing;
+  }
+  get time() {
+    return this._time;
+  }
+  set time(time) {
+    this._time = time;
+  }
+  get accuracy() {
+    return this._accuracy;
+  }
+  set accuracy(accuracy) {
+    if (accuracy !== null && accuracy < 0) {
+      throw new Error("accuracy argument is not a positive number");
+    }
+    this._accuracy = accuracy;
+  }
+  get bearing() {
+    return this._bearing;
+  }
+  set bearing(bearing) {
+    this._bearing = bearing !== null ? bearing % (2 * Math.PI) : null;
+  }
+  move(distance, bearing, elevation = null) {
+    super.move(distance, bearing, elevation);
+    return this;
+  }
+  destinationPoint(distance, bearing, elevation = null) {
+    const newPoint = this.clone();
+    newPoint.move(distance, bearing, elevation);
+    return newPoint;
+  }
+  static fromCoordinates(coordinates) {
+    return new UserPosition(
+      coordinates.lat,
+      coordinates.lng,
+      coordinates.alt,
+      coordinates.level
+    );
+  }
+  clone() {
+    const cloned = UserPosition.fromCoordinates(super.clone());
+    cloned.time = this.time;
+    cloned.accuracy = this.accuracy;
+    cloned.bearing = this.bearing;
+    return cloned;
+  }
+  static equals(pos1, pos2, eps = EPS_DEG_MM, epsAlt = EPS_MM) {
+    if (pos1 === null && pos1 === pos2) {
+      return true;
+    }
+    if (!(pos1 instanceof UserPosition) || !(pos2 instanceof UserPosition)) {
+      return false;
+    }
+    if (!super.equals(pos1, pos2, eps, epsAlt)) {
+      return false;
+    }
+    return pos1.time === pos2.time && pos1.accuracy === pos2.accuracy && pos1.bearing === pos2.bearing;
+  }
+  equals(other, eps = EPS_DEG_MM, epsAlt = EPS_MM) {
+    return UserPosition.equals(this, other, eps, epsAlt);
+  }
+  toJson() {
+    return {
+      ...super.toJson(),
+      ...this.time !== null && { time: this.time },
+      ...this.accuracy !== null && { accuracy: this.accuracy },
+      ...this.bearing !== null && { bearing: this.bearing }
+    };
+  }
+  static fromJson(json) {
+    const position = UserPosition.fromCoordinates(Coordinates.fromJson(json));
+    if (typeof json.time !== "undefined") {
+      position.time = json.time;
+    }
+    if (typeof json.accuracy !== "undefined") {
+      position.accuracy = json.accuracy;
+    }
+    if (typeof json.bearing !== "undefined") {
+      position.bearing = json.bearing;
+    }
+    return position;
+  }
+}
+function sampleRoute(route, stepSize = 0.7, startSampling = 0, length = Number.MAX_VALUE) {
+  const endSampling = startSampling + length;
+  const sampledRoute = [];
+  let lastSample;
+  let totalDistanceTraveled = 0;
+  let distanceToNextSample = 0;
+  let startFound = false;
+  for (let segmentIndex = 0; segmentIndex < route.length - 1; segmentIndex++) {
+    const p1 = route[segmentIndex];
+    const p2 = route[segmentIndex + 1];
+    const segmentSize = p1.distanceTo(p2);
+    const segmentBearing = p1.bearingTo(p2);
+    let distanceTraveledOnSegment = 0;
+    if (!startFound) {
+      if (startSampling < totalDistanceTraveled + segmentSize) {
+        startFound = true;
+        distanceToNextSample = startSampling - totalDistanceTraveled;
+      } else {
+        totalDistanceTraveled += segmentSize;
+        continue;
+      }
+    }
+    lastSample = Object.assign(p1.clone(), { bearing: segmentBearing });
+    while (distanceTraveledOnSegment + distanceToNextSample < segmentSize && totalDistanceTraveled + distanceToNextSample <= endSampling) {
+      const newPoint = lastSample.destinationPoint(distanceToNextSample, segmentBearing);
+      newPoint.bearing = segmentBearing;
+      sampledRoute.push(newPoint);
+      lastSample = newPoint;
+      distanceTraveledOnSegment += distanceToNextSample;
+      totalDistanceTraveled += distanceToNextSample;
+      distanceToNextSample = stepSize;
+    }
+    if (totalDistanceTraveled + distanceToNextSample > endSampling) {
+      break;
+    }
+    const rest = segmentSize - distanceTraveledOnSegment;
+    totalDistanceTraveled += rest;
+    distanceToNextSample -= rest;
+  }
+  return sampledRoute;
+}
+function trimRoute(route, startPosition = route[0], length = Number.MAX_VALUE) {
+  const newRoute = [];
+  let previousPoint = null;
+  let currentPointIndex;
+  let cumulativeDistance = 0;
+  if (route.length <= 1) {
+    throw new Error("Route must have at least 2 points");
+  }
+  for (currentPointIndex = 1; currentPointIndex < route.length; currentPointIndex++) {
+    const p1 = route[currentPointIndex - 1];
+    const p2 = route[currentPointIndex];
+    if (Coordinates.equals(startPosition, p1)) {
+      newRoute.push(p1);
+      previousPoint = p1;
+      break;
+    }
+    const proj = startPosition.getSegmentProjection(p1, p2);
+    if (proj && Coordinates.equals(startPosition, proj) && !proj.equals(p2)) {
+      newRoute.push(proj);
+      previousPoint = proj;
+      break;
+    }
+  }
+  if (!newRoute.length) {
+    throw new Error("startPosition is not on the route");
+  }
+  while (previousPoint && currentPointIndex < route.length) {
+    const currentPoint = route[currentPointIndex];
+    const dist = previousPoint.distanceTo(currentPoint);
+    if (cumulativeDistance + dist >= length || Math.abs(cumulativeDistance + dist - length) <= EPS_MM) {
+      const bearing = previousPoint.bearingTo(currentPoint);
+      const remainingLength = length - cumulativeDistance;
+      const end = previousPoint.destinationPoint(remainingLength, bearing);
+      newRoute.push(end);
+      break;
+    }
+    newRoute.push(currentPoint);
+    previousPoint = currentPoint;
+    cumulativeDistance += dist;
+    currentPointIndex++;
+  }
+  return newRoute;
+}
+function simplifyRoute(coords, precisionAngle = maths.deg2rad(5)) {
+  const isClosed = coords[0].equals(coords[coords.length - 1]);
+  let newRoute = coords.slice(0, coords.length - (isClosed ? 1 : 0));
+  const len = newRoute.length;
+  for (let i = isClosed ? 0 : 1; i < len; i++) {
+    const p0 = coords[maths.positiveMod(i - 1, len)];
+    const p1 = coords[i];
+    const p2 = coords[maths.positiveMod(i + 1, len)];
+    const seg1Dir = p0.bearingTo(p1);
+    const seg2Dir = p1.bearingTo(p2);
+    if (Math.abs(seg2Dir - seg1Dir) < precisionAngle) {
+      newRoute = newRoute.filter((coord) => coord !== p1);
+    }
+  }
+  if (isClosed) {
+    newRoute.push(newRoute[0]);
+  }
+  return newRoute;
+}
+function geolocationPositionToUserPosition(geolocationPosition) {
+  if (geolocationPosition === null) {
+    return null;
+  }
+  const { latitude, longitude, accuracy, heading } = geolocationPosition.coords;
+  const userPosition = new UserPosition(latitude, longitude);
+  userPosition.time = geolocationPosition.timestamp;
+  userPosition.accuracy = accuracy;
+  userPosition.bearing = heading ? maths.deg2rad(heading) : null;
+  return userPosition;
+}
+function calcDistance(coords) {
+  return coords.reduce((acc, coords2, idx, arr) => acc + (idx ? arr[idx - 1].distanceTo(coords2) : 0), 0);
+}
+const Utils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  sampleRoute,
+  trimRoute,
+  simplifyRoute,
+  geolocationPositionToUserPosition,
+  calcDistance
+}, Symbol.toStringTag, { value: "Module" }));
+class BoundingBox {
+  constructor(northEast, southWest) {
+    __publicField(this, "northEast");
+    __publicField(this, "southWest");
+    this.northEast = northEast;
+    this.southWest = southWest;
+    if (this.northEast && this.southWest && this.getNorth() < this.getSouth()) {
+      throw new Error("Incorrect bounding box");
+    }
+  }
+  get center() {
+    const latCenter = (this.southWest.lat + this.northEast.lat) / 2;
+    const lngCenter = (this.northEast.lng + this.southWest.lng) / 2;
+    return new Coordinates(latCenter, lngCenter);
+  }
+  contains(point) {
+    return point.lat <= this.northEast.lat && point.lat >= this.southWest.lat && point.lng <= this.northEast.lng && point.lng >= this.southWest.lng;
+  }
+  extend(obj) {
+    const sw = this.southWest, ne = this.northEast;
+    let sw2, ne2;
+    if (obj instanceof Coordinates) {
+      sw2 = obj;
+      ne2 = obj;
+    } else if (obj instanceof BoundingBox) {
+      sw2 = obj.southWest;
+      ne2 = obj.northEast;
+    } else {
+      throw new Error("Unknown parameter");
+    }
+    this.southWest = new Coordinates(
+      Math.min(sw2.lat, sw.lat),
+      Math.min(sw2.lng, sw.lng)
+    );
+    this.northEast = new Coordinates(
+      Math.max(ne2.lat, ne.lat),
+      Math.max(ne2.lng, ne.lng)
+    );
+    return this;
+  }
+  extendsWithMeasure(measure) {
+    if (typeof measure !== "number") {
+      throw new Error("measure is not a number");
+    }
+    this.northEast = this.northEast.destinationPoint(measure, 0).move(measure, Math.PI / 2);
+    this.southWest = this.southWest.clone().destinationPoint(measure, -Math.PI / 2).destinationPoint(measure, Math.PI);
+    return this;
+  }
+  pad(bufferRatio) {
+    const sw = this.southWest;
+    const ne = this.northEast;
+    const heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio;
+    const widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
+    this.southWest = new Coordinates(sw.lat - heightBuffer, sw.lng - widthBuffer);
+    this.northEast = new Coordinates(ne.lat + heightBuffer, ne.lng + widthBuffer);
+    return this;
+  }
+  getSouthWest() {
+    return this.southWest;
+  }
+  getNorthEast() {
+    return this.northEast;
+  }
+  getNorthWest() {
+    return new Coordinates(this.getNorth(), this.getWest());
+  }
+  getSouthEast() {
+    return new Coordinates(this.getSouth(), this.getEast());
+  }
+  getWest() {
+    return this.southWest.lng;
+  }
+  getSouth() {
+    return this.southWest.lat;
+  }
+  getEast() {
+    return this.northEast.lng;
+  }
+  getNorth() {
+    return this.northEast.lat;
+  }
+  static equals(bb1, bb2) {
+    return Coordinates.equals(bb1.northEast, bb2.northEast) && Coordinates.equals(bb1.southWest, bb2.southWest);
+  }
+  equals(other) {
+    return BoundingBox.equals(this, other);
+  }
+  static fromArray(bounds) {
+    return new BoundingBox(
+      new Coordinates(bounds[3], bounds[2]),
+      new Coordinates(bounds[1], bounds[0])
+    );
+  }
+  static fromCoordinates(coords) {
+    if (coords.length === 0) {
+      return null;
+    }
+    return coords.reduce(
+      (acc, _coords) => acc.extend(_coords),
+      new BoundingBox(coords[0], coords[0])
+    );
+  }
+  toArray() {
+    return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()];
+  }
+}
+class RelativePosition {
+  constructor(x, y, z, time = null, accuracy = null, bearing = null) {
+    __publicField(this, "x");
+    __publicField(this, "y");
+    __publicField(this, "z");
+    __publicField(this, "time", null);
+    __publicField(this, "_accuracy", null);
+    __publicField(this, "_bearing", null);
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.time = time;
+    this.accuracy = accuracy;
+    this.bearing = bearing;
+  }
+  get accuracy() {
+    return this._accuracy;
+  }
+  set accuracy(accuracy) {
+    if (accuracy !== null && accuracy < 0) {
+      throw new Error("accuracy argument is not a positive number");
+    }
+    this._accuracy = accuracy;
+  }
+  get bearing() {
+    return this._bearing;
+  }
+  set bearing(bearing) {
+    this._bearing = bearing !== null ? bearing % (2 * Math.PI) : null;
+  }
+  clone() {
+    return new RelativePosition(this.x, this.y, this.z, this.time, this.accuracy, this.bearing);
+  }
+  static equals(pos1, pos2, eps = EPS_MM) {
+    if (pos1 === null && pos1 === pos2) {
+      return true;
+    }
+    if (!(pos1 instanceof RelativePosition) || !(pos2 instanceof RelativePosition)) {
+      return false;
+    }
+    return Math.abs(pos2.x - pos1.x) < eps && Math.abs(pos2.y - pos1.y) < eps && Math.abs(pos2.z - pos1.z) < eps && pos1.time === pos2.time && pos1.accuracy === pos2.accuracy && pos1.bearing === pos2.bearing;
+  }
+  equals(other) {
+    return RelativePosition.equals(this, other);
+  }
+  toJson() {
+    return {
+      x: this.x,
+      y: this.y,
+      z: this.z,
+      ...this.time !== null && { time: this.time },
+      ...this.accuracy !== null && { accuracy: this.accuracy },
+      ...this.bearing !== null && { bearing: this.bearing }
+    };
+  }
+  static fromJson(json) {
+    return new RelativePosition(json.x, json.y, json.z, json.time, json.accuracy, json.bearing);
+  }
+}
+class GeoRelativePosition extends RelativePosition {
+}
+class GeoRef {
+  constructor(origin) {
+    __publicField(this, "origin");
+    __publicField(this, "scale", 1);
+    __publicField(this, "heading", 0);
+    this.origin = origin;
+  }
+  localToWorld(localPosition) {
+    const enuTranslationScaled = maths.Vector3.multiplyScalar(localPosition, this.scale);
+    const rotationOffset = maths.Quaternion.fromAxisAngle([0, 0, 1], this.heading);
+    const enuToEcefRotationOrigin = maths.Quaternion.multiply(rotationOffset, this.origin.enuToEcefRotation);
+    const ecefTranslation = maths.Quaternion.rotate(enuToEcefRotationOrigin, enuTranslationScaled);
+    const ecef = maths.Vector3.sum(this.origin.ecef, ecefTranslation);
+    return Coordinates.fromECEF(ecef);
+  }
+  worldToLocal(coords) {
+    const rotationOffset = maths.Quaternion.fromAxisAngle([0, 0, 1], -this.heading);
+    const ecefToEnuRotationOrigin = maths.Quaternion.multiply(this.origin.ecefToEnuRotation, rotationOffset);
+    const ecefTranslation = maths.Vector3.subtract(coords.ecef, this.origin.ecef);
+    const ecefTranslationScaled = maths.Vector3.multiplyScalar(ecefTranslation, 1 / this.scale);
+    return maths.Quaternion.rotate(ecefToEnuRotationOrigin, ecefTranslationScaled);
+  }
+  toJson() {
+    return {
+      origin: this.origin.toJson(),
+      ...this.scale !== 1 && { scale: this.scale },
+      ...this.heading !== 0 && { heading: this.heading }
+    };
+  }
+  static fromJson(json) {
+    const geoRef = new GeoRef(Coordinates.fromJson(json.origin));
+    geoRef.scale = typeof json.scale !== "undefined" ? json.scale : 1;
+    geoRef.heading = typeof json.heading !== "undefined" ? json.heading : 0;
+    return geoRef;
+  }
+}
+class Attitude {
+  constructor(quaternion, time = null, accuracy = null) {
+    __publicField(this, "_quaternion", [1, 0, 0, 0]);
+    __publicField(this, "_heading", null);
+    __publicField(this, "_eulerAngles", null);
+    __publicField(this, "_time", null);
+    __publicField(this, "_accuracy", null);
+    this.quaternion = quaternion;
+    this.time = time;
+    this.accuracy = accuracy;
+  }
+  static unitary() {
+    return new Attitude([1, 0, 0, 0]);
+  }
+  get quaternion() {
+    return this._quaternion;
+  }
+  set quaternion(quaternion) {
+    if (Math.abs(1 - maths.Quaternion.norm(quaternion)) > 1e-4) {
+      throw new Error("quaternion is not a unit quaternion");
+    }
+    this._quaternion = quaternion;
+    this._heading = null;
+    this._eulerAngles = null;
+  }
+  get time() {
+    return this._time;
+  }
+  set time(time) {
+    this._time = time;
+  }
+  get accuracy() {
+    return this._accuracy;
+  }
+  set accuracy(accuracy) {
+    if (accuracy !== null && (accuracy < 0 || accuracy > Math.PI)) {
+      throw new Error("accuracy argument (" + accuracy + ") is not in range [0; PI]");
+    }
+    this._accuracy = accuracy;
+  }
+  get eulerAngles() {
+    if (this._eulerAngles === null) {
+      this._eulerAngles = maths.Rotations.quaternionToEulerZXY(this.quaternion);
+    }
+    return this._eulerAngles;
+  }
+  get eulerAnglesDegrees() {
+    return this.eulerAngles.map((x) => maths.rad2deg(x));
+  }
+  get heading() {
+    if (this._heading === null) {
+      let offset = 0;
+      if (typeof window !== "undefined" && window && window.orientation) {
+        offset = maths.deg2rad(window.orientation);
+      }
+      this._heading = maths.Rotations.getHeadingFromQuaternion(this.quaternion) + offset;
+    }
+    return this._heading;
+  }
+  get headingDegrees() {
+    return maths.rad2deg(this.heading);
+  }
+  static equals(att1, att2) {
+    if (att1 === null && att1 === att2) {
+      return true;
+    }
+    if (!(att1 instanceof Attitude) || !(att2 instanceof Attitude)) {
+      return false;
+    }
+    if (att1 === att2) {
+      return true;
+    }
+    return maths.Quaternion.equals(att1.quaternion, att2.quaternion);
+  }
+  equals(other) {
+    return Attitude.equals(this, other);
+  }
+  toJson() {
+    if (this.time === null && this.accuracy === null) {
+      return this.quaternion;
+    }
+    return {
+      q: this.quaternion,
+      ...this.time !== null && { time: this.time },
+      ...this.accuracy !== null && { accuracy: this.accuracy }
+    };
+  }
+  static fromJson(json) {
+    if (Array.isArray(json)) {
+      return new Attitude(json, null, null);
+    }
+    return new Attitude(json.q, json.time, json.accuracy);
+  }
+  clone() {
+    return new Attitude(this.quaternion.slice(0), this.time, this.accuracy);
+  }
+  static diff(attitudeStart, attitudeEnd) {
+    const quaternionDiff = maths.Quaternion.multiply(
+      maths.Quaternion.inverse(attitudeStart.quaternion),
+      attitudeEnd.quaternion
+    );
+    let timeDiff = null;
+    if (attitudeEnd.time !== null && attitudeStart.time !== null) {
+      timeDiff = attitudeEnd.time - attitudeStart.time;
+    }
+    let accuracyDiff = null;
+    if (attitudeStart.accuracy !== null && attitudeEnd.accuracy !== null) {
+      accuracyDiff = Math.max(attitudeEnd.accuracy - attitudeStart.accuracy);
+    }
+    return new Attitude(quaternionDiff, timeDiff, accuracyDiff);
+  }
+}
+class AbsoluteHeading {
+  constructor(heading, time = null, accuracy = null) {
+    __publicField(this, "heading");
+    __publicField(this, "time", null);
+    __publicField(this, "_accuracy", null);
+    this.heading = heading;
+    this.time = time;
+    this.accuracy = accuracy;
+  }
+  get accuracy() {
+    return this._accuracy;
+  }
+  set accuracy(accuracy) {
+    if (accuracy !== null && (accuracy < 0 || accuracy > Math.PI)) {
+      throw new Error("accuracy argument (" + accuracy + ") is not in range [0; PI]");
+    }
+    this._accuracy = accuracy;
+  }
+  toAttitude() {
+    return new Attitude(
+      maths.Quaternion.fromAxisAngle([0, 0, 1], -this.heading),
+      this.time,
+      this.accuracy
+    );
+  }
+  static equals(heading1, heading2) {
+    if (heading1 === null && heading1 === heading2) {
+      return true;
+    }
+    if (!(heading1 instanceof AbsoluteHeading) || !(heading2 instanceof AbsoluteHeading)) {
+      return false;
+    }
+    return Math.abs(heading1.heading - heading2.heading) < 1e-8;
+  }
+  equals(other) {
+    return AbsoluteHeading.equals(this, other);
+  }
+  toJson() {
+    return {
+      heading: this.heading,
+      ...this.time !== null && { time: this.time },
+      ...this.accuracy !== null && { accuracy: this.accuracy }
+    };
+  }
+  static fromJson(json) {
+    return new AbsoluteHeading(json.heading, json.time, json.accuracy);
+  }
+  clone() {
+    return new AbsoluteHeading(this.heading, this.time, this.accuracy);
+  }
+}
+class GraphNode {
+  constructor(coords, builtFrom = null) {
+    __publicField(this, "coords");
+    __publicField(this, "edges", []);
+    __publicField(this, "builtFrom");
+    __publicField(this, "io", false);
+    this.coords = coords;
+    this.builtFrom = builtFrom;
+  }
+  distanceTo(other) {
+    return this.coords.distanceTo(other.coords);
+  }
+  bearingTo(other) {
+    return this.coords.bearingTo(other.coords);
+  }
+  equals(other) {
+    return this.coords.equals(other.coords) && this.builtFrom === other.builtFrom;
+  }
+  clone() {
+    const node = new GraphNode(this.coords, this.builtFrom);
+    node.edges = this.edges.slice(0);
+    node.io = this.io;
+    return node;
+  }
+  toJson() {
+    return this.coords.toCompressedJson();
+  }
+  static fromJson(json, builtFrom = null) {
+    return new GraphNode(Coordinates.fromCompressedJson(json), builtFrom);
+  }
+  _generateLevelFromEdges() {
+    let tmpLevel = null;
+    for (let i = 0; i < this.edges.length; i++) {
+      const edge = this.edges[i];
+      if (edge.level !== null) {
+        if (tmpLevel === null) {
+          tmpLevel = Level.clone(edge.level);
+        } else {
+          tmpLevel = Level.intersection(tmpLevel, edge.level);
+          if (tmpLevel === null) {
+            throw Error("Something bad happend during parsing: We cannot retrieve node level from adjacent ways: " + this.coords);
+          }
+        }
+      }
+    }
+    this.coords.level = tmpLevel;
+  }
+  _inferNodeLevelByRecursion() {
+    const { level } = this.coords;
+    if (level === null || !Level.isRange(level)) {
+      return;
+    }
+    if (this.edges.length > 1) {
+      return;
+    }
+    const lookForLevel = (node, visitedNodes) => {
+      visitedNodes.push(node);
+      if (node.coords.level === null) {
+        return null;
+      }
+      if (!Level.isRange(node.coords.level)) {
+        return node.coords.level;
+      }
+      let tmpLevel = null;
+      for (let i = 0; i < node.edges.length; i++) {
+        const edge = node.edges[i];
+        const otherNode = edge.node1 === node ? edge.node2 : edge.node1;
+        if (!visitedNodes.includes(otherNode)) {
+          tmpLevel = Level.union(lookForLevel(otherNode, visitedNodes), tmpLevel);
+        }
+      }
+      return tmpLevel;
+    };
+    const othersLevels = lookForLevel(this, []);
+    if (othersLevels !== null) {
+      if (!Level.isRange(othersLevels)) {
+        this.coords.level = othersLevels === level[0] ? level[1] : level[0];
+        return;
+      }
+      throw Error("Level of: " + this.coords.toString() + " cannot be decided");
+    }
+  }
+  _inferNodeLevelByNeighboors() {
+    const { level } = this.coords;
+    if (level === null || !Level.isRange(level)) {
+      return true;
+    }
+    let tmpLevel = null;
+    for (let i = 0; i < this.edges.length; i++) {
+      const edge = this.edges[i];
+      const otherNode = edge.node1 === this ? edge.node2 : edge.node1;
+      tmpLevel = Level.union(otherNode.coords.level, tmpLevel);
+    }
+    if (tmpLevel === null || !Level.isRange(tmpLevel)) {
+      this.coords.level = tmpLevel === level[0] ? level[1] : level[0];
+    }
+    return true;
+  }
+  _checkIO() {
+    this.io = this.coords.level !== null && this.edges.some((edge) => edge.level === null);
+    return true;
+  }
+  static generateNodesLevels(nodes) {
+    nodes.forEach((node) => node._generateLevelFromEdges());
+    nodes.forEach((node) => node._inferNodeLevelByNeighboors());
+    nodes.forEach((node) => node._inferNodeLevelByRecursion());
+    nodes.forEach((node) => node._checkIO());
+  }
+}
+class GraphEdge {
+  constructor(node1, node2, level = null, builtFrom = null) {
+    __publicField(this, "_node1");
+    __publicField(this, "_node2");
+    __publicField(this, "_level", null);
+    __publicField(this, "_bearing", null);
+    __publicField(this, "_length", null);
+    __publicField(this, "_computedSizeAndBearing", false);
+    __publicField(this, "builtFrom");
+    __publicField(this, "isOneway", false);
+    this.node1 = node1;
+    this.node2 = node2;
+    this.level = level;
+    this.builtFrom = builtFrom;
+  }
+  get node1() {
+    return this._node1;
+  }
+  set node1(node) {
+    if (!(node instanceof GraphNode)) {
+      throw new TypeError("node1 is not a GraphNode");
+    }
+    if (this._node1 instanceof GraphNode && this._node2 !== this._node1) {
+      this._node1.edges = this._node1.edges.filter((edge) => edge !== this);
+    }
+    node.edges.push(this);
+    this._node1 = node;
+    this._computedSizeAndBearing = false;
+  }
+  get node2() {
+    return this._node2;
+  }
+  set node2(node) {
+    if (!(node instanceof GraphNode)) {
+      throw new TypeError("node2 is not a GraphNode");
+    }
+    if (this._node2 instanceof GraphNode && this._node2 !== this._node1) {
+      this._node2.edges = this._node2.edges.filter((edge) => edge !== this);
+    }
+    node.edges.push(this);
+    this._node2 = node;
+    this._computedSizeAndBearing = false;
+  }
+  get level() {
+    return this._level;
+  }
+  set level(level) {
+    Level.checkType(level);
+    this._level = level;
+  }
+  get bearing() {
+    if (!this._computedSizeAndBearing) {
+      this._computeSizeAndBearing();
+    }
+    return this._bearing;
+  }
+  get length() {
+    if (!this._computedSizeAndBearing) {
+      this._computeSizeAndBearing();
+    }
+    return this._length;
+  }
+  _computeSizeAndBearing() {
+    this._length = this.node1.distanceTo(this.node2);
+    this._bearing = this.node1.bearingTo(this.node2);
+    this._computedSizeAndBearing = true;
+  }
+  equals(other) {
+    if (this === other) {
+      return true;
+    }
+    if (!(other instanceof GraphEdge)) {
+      return false;
+    }
+    return other.node1.equals(this.node1) && other.node2.equals(this.node2) && Level.equals(other.level, this.level) && other.isOneway === this.isOneway && other.builtFrom === this.builtFrom;
+  }
+  clone() {
+    const edge = new GraphEdge(this.node1, this.node2, this.level, this.builtFrom);
+    edge.isOneway = this.isOneway;
+    return edge;
+  }
+}
+function getEdgeByNodes(edges, node1, node2) {
+  return edges.find(
+    (edge) => node1 === edge.node1 && node2 === edge.node2 || node2 === edge.node1 && node1 === edge.node2
+  );
+}
+function getNodeByCoords(nodes, coords) {
+  return nodes.find((node) => node.coords.equals(coords));
+}
+const GraphUtils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getEdgeByNodes,
+  getNodeByCoords
+}, Symbol.toStringTag, { value: "Module" }));
+class Network {
+  constructor(nodes, edges) {
+    __publicField(this, "nodes");
+    __publicField(this, "edges");
+    this.nodes = Array.isArray(nodes) ? nodes : [];
+    this.edges = Array.isArray(edges) ? edges : [];
+  }
+  getNodeByCoords(coords) {
+    return this.nodes.find((node) => node.coords.equals(coords));
+  }
+  getEdgeByNodes(node1, node2) {
+    return getEdgeByNodes(this.edges, node1, node2);
+  }
+  getBoundingBox(extendedMeasure) {
+    if (!this.nodes.length) {
+      return null;
+    }
+    const boundingBox = BoundingBox.fromCoordinates(this.nodes.map((node) => node.coords));
+    if (extendedMeasure) {
+      boundingBox.extendsWithMeasure(extendedMeasure);
+    }
+    return boundingBox;
+  }
+  toDetailedString(_nodeToStringFn, _edgeToStringFn) {
+    let nodeToStringFn = _nodeToStringFn;
+    if (!nodeToStringFn) {
+      nodeToStringFn = (node) => `${node.builtFrom}`;
+    }
+    let edgeToStringFn = _edgeToStringFn;
+    if (!_edgeToStringFn) {
+      edgeToStringFn = (edge) => `${edge.builtFrom}`;
+    }
+    let output = `--- Network ---
+Nodes: ${this.nodes.length}
+Edges: ${this.edges.length}
+---
+Nodes
+`;
+    this.nodes.forEach((node) => {
+      output += `${nodeToStringFn(node)} [edges: ${node.edges.length}]
+`;
+    });
+    output += "---\nEdges\n";
+    this.edges.forEach((edge) => {
+      output += `${edgeToStringFn(edge)} `;
+      output += `[${nodeToStringFn(edge.node1)} -- ${nodeToStringFn(edge.node2)}]
+`;
+    });
+    output += "---";
+    return output;
+  }
+  toCompressedJson() {
+    return {
+      nodes: this.nodes.map((node) => node.toJson()),
+      edges: this.edges.map((edge) => {
+        const node1Idx = this.nodes.indexOf(edge.node1);
+        const node2Idx = this.nodes.indexOf(edge.node2);
+        if (edge.isOneway) {
+          return [node1Idx, node2Idx, edge.level, true];
+        }
+        if (edge.level) {
+          return [node1Idx, node2Idx, edge.level];
+        }
+        return [node1Idx, node2Idx];
+      })
+    };
+  }
+  static fromCompressedJson(json) {
+    const network = new Network();
+    network.nodes = json.nodes.map((node) => GraphNode.fromJson(node, null));
+    network.edges = json.edges.map((jsonEdge) => {
+      const edge = new GraphEdge(
+        network.nodes[jsonEdge[0]],
+        network.nodes[jsonEdge[1]],
+        jsonEdge[2],
+        null
+      );
+      if (jsonEdge.length > 3 && jsonEdge[3]) {
+        edge.isOneway = true;
+      }
+      return edge;
+    });
+    return network;
+  }
+  static fromCoordinates(segments) {
+    const network = new Network();
+    const getOrCreateNode = (coords) => {
+      const node = network.nodes.find((otherNode) => otherNode.coords.equals(coords));
+      if (node) {
+        return node;
+      }
+      const newNode = new GraphNode(coords, null);
+      network.nodes.push(newNode);
+      return newNode;
+    };
+    const createEdgeFromNodes = (node1, node2) => new GraphEdge(
+      node1,
+      node2,
+      Level.union(node1.coords.level, node2.coords.level),
+      null
+    );
+    for (const segment of segments) {
+      let previousNode = null;
+      for (const coords of segment) {
+        const currentNode = getOrCreateNode(coords);
+        if (previousNode) {
+          const edge = createEdgeFromNodes(currentNode, previousNode);
+          network.edges.push(edge);
+        }
+        previousNode = currentNode;
+      }
+    }
+    return network;
+  }
+  getEdgesAtLevel(targetLevel, useMultiLevelEdges = true) {
+    return this.edges.filter(
+      ({ level }) => useMultiLevelEdges ? Level.intersect(targetLevel, level) : Level.contains(targetLevel, level)
+    );
+  }
+}
+class GraphProjection {
+  constructor(origin, distanceFromNearestElement, coords, nearestElement) {
+    __publicField(this, "origin");
+    __publicField(this, "distanceFromNearestElement");
+    __publicField(this, "coords");
+    __publicField(this, "nearestElement");
+    this.origin = origin;
+    this.distanceFromNearestElement = distanceFromNearestElement;
+    this.coords = coords;
+    this.nearestElement = nearestElement;
+  }
+}
+const _MapMatching = class {
+  constructor(network = null) {
+    __publicField(this, "network", null);
+    __publicField(this, "_maxDistance", Number.MAX_VALUE);
+    __publicField(this, "_maxAngleBearing", Math.PI);
+    this.network = network;
+  }
+  set maxAngleBearing(maxAngleBearing) {
+    this._maxAngleBearing = maxAngleBearing;
+  }
+  get maxAngleBearing() {
+    return this._maxAngleBearing;
+  }
+  set maxDistance(maxDistance) {
+    this._maxDistance = maxDistance;
+  }
+  get maxDistance() {
+    return this._maxDistance;
+  }
+  _shouldProjectOnEdgeAndNodes(edge, location, useBearing, useMultiLevelSegments, acceptEdgeFn) {
+    if (!acceptEdgeFn(edge)) {
+      return [false, false, false];
+    }
+    let checkEdge = Level.intersect(location.level, edge.level);
+    let checkNode1 = Level.intersect(location.level, edge.node1.coords.level);
+    let checkNode2 = Level.intersect(location.level, edge.node2.coords.level);
+    checkNode1 = checkNode1 || edge.node1.io && location.level === null;
+    checkNode2 = checkNode2 || edge.node2.io && location.level === null;
+    if (!useMultiLevelSegments) {
+      checkEdge = checkEdge && !Level.isRange(edge.level);
+      checkNode1 = checkNode1 && !Level.isRange(edge.node1.coords.level);
+      checkNode2 = checkNode2 && !Level.isRange(edge.node2.coords.level);
+    }
+    if (useBearing) {
+      if (checkEdge) {
+        const diffAngle = maths.diffAngleLines(edge.bearing, location.bearing);
+        if (diffAngle > this._maxAngleBearing) {
+          checkEdge = false;
+        }
+      }
+      checkNode1 = false;
+      checkNode2 = false;
+    }
+    return [checkEdge, checkNode1, checkNode2];
+  }
+  static _assignLatLngLevel(fromCoordinates, toCoordinates) {
+    toCoordinates.lat = fromCoordinates.lat;
+    toCoordinates.lng = fromCoordinates.lng;
+    toCoordinates.level = Level.clone(fromCoordinates.level);
+  }
+  static _handleLevelsWithIONodes(projection, location, projectionNode) {
+    if (location.level === null && projectionNode.io) {
+      projection.level = null;
+    }
+  }
+  getProjection(location, useDistance = false, useBearing = false, useMultiLevelSegments = true, acceptEdgeFn = () => true) {
+    if (this.network === null) {
+      throw new Error("Network has not been set yet");
+    }
+    if (!(location instanceof Coordinates)) {
+      throw new TypeError("location is not an instance of Coordinates");
+    }
+    if (useBearing && (!("bearing" in location && location.bearing !== null) || !this._maxAngleBearing)) {
+      return null;
+    }
+    let distanceFromNearestElement = Number.MAX_VALUE;
+    const projection = location.clone();
+    let nearestElement = null;
+    const isProjectionBetter = (distanceOfNewProjection) => {
+      return distanceOfNewProjection < distanceFromNearestElement && (!useDistance || distanceOfNewProjection <= this._maxDistance);
+    };
+    for (const edge of this.network.edges) {
+      const [checkEdge, checkNode1, checkNode2] = this._shouldProjectOnEdgeAndNodes(
+        edge,
+        location,
+        useBearing,
+        useMultiLevelSegments,
+        acceptEdgeFn
+      );
+      if (checkNode1) {
+        const distNode1 = location.distanceTo(edge.node1.coords);
+        if (isProjectionBetter(distNode1) || distNode1 <= EPS_MM) {
+          distanceFromNearestElement = distNode1;
+          nearestElement = edge.node1;
+          _MapMatching._assignLatLngLevel(edge.node1.coords, projection);
+          _MapMatching._handleLevelsWithIONodes(projection, location, edge.node1);
+          if (distNode1 <= EPS_MM) {
+            break;
+          }
+        }
+      }
+      if (checkNode2) {
+        const distNode2 = location.distanceTo(edge.node2.coords);
+        if (isProjectionBetter(distNode2) || distNode2 <= EPS_MM) {
+          distanceFromNearestElement = distNode2;
+          nearestElement = edge.node2;
+          _MapMatching._assignLatLngLevel(edge.node2.coords, projection);
+          _MapMatching._handleLevelsWithIONodes(projection, location, edge.node2);
+          if (distNode2 <= EPS_MM) {
+            break;
+          }
+        }
+      }
+      if (checkEdge) {
+        const segmentProjection = location.getSegmentProjection(edge.node1.coords, edge.node2.coords);
+        if (segmentProjection) {
+          const distEdge = location.distanceTo(segmentProjection);
+          if (isProjectionBetter(distEdge)) {
+            distanceFromNearestElement = distEdge;
+            nearestElement = edge;
+            _MapMatching._assignLatLngLevel(segmentProjection, projection);
+            _MapMatching._updateProjectionLevelFromEdge(edge, projection);
+          }
+        }
+      }
+    }
+    if (!nearestElement) {
+      return null;
+    }
+    if (projection instanceof UserPosition && projection.accuracy !== null) {
+      projection.accuracy += distanceFromNearestElement;
+    }
+    return new GraphProjection(
+      location,
+      distanceFromNearestElement,
+      projection,
+      nearestElement
+    );
+  }
+};
+let MapMatching = _MapMatching;
+__publicField(MapMatching, "_updateProjectionLevelFromEdge", (_edge, _projection) => {
+  _projection.level = Level.clone(_edge.level);
+});
+class GraphItinerary {
+  constructor(start, end, nodes, edges, edgesWeights) {
+    __publicField(this, "start");
+    __publicField(this, "end");
+    __publicField(this, "nodes");
+    __publicField(this, "edges");
+    __publicField(this, "edgesWeights");
+    this.start = start;
+    this.end = end;
+    this.nodes = nodes;
+    this.edges = edges;
+    this.edgesWeights = edgesWeights;
+  }
+  static fromNetworkNodes(start, end, networkNodes, edgesWeights) {
+    const nodes = networkNodes.map((node) => {
+      const newNode = node.clone();
+      newNode.edges = [];
+      if (newNode.io) {
+        newNode.coords = newNode.coords.clone();
+        newNode.coords.level = null;
+      }
+      return newNode;
+    });
+    const edges = [];
+    networkNodes.forEach((node, idx, arr) => {
+      if (idx === 0) {
+        return;
+      }
+      const prevNode = arr[idx - 1];
+      const edge = getEdgeByNodes(prevNode.edges, prevNode, node);
+      if (!edge) {
+        Logger__default.default.error("Cannot retrieve edge to create itinerary");
+        return;
+      }
+      const newEdge = new GraphEdge(
+        nodes[idx - 1],
+        nodes[idx],
+        edge.level,
+        edge.builtFrom
+      );
+      newEdge.isOneway = edge.isOneway;
+      edges.push(newEdge);
+    });
+    return new GraphItinerary(start, end, nodes, edges, edgesWeights);
+  }
+}
+class NoRouteFoundError extends Error {
+  constructor(start, end, details) {
+    super();
+    __publicField(this, "details");
+    __publicField(this, "end");
+    __publicField(this, "start");
+    this.start = start;
+    this.end = end;
+    this.details = details;
+  }
+  get startStr() {
+    if (this.start instanceof GraphNode) {
+      return `GraphNode ${this.start.coords.toString()}`;
+    }
+    return this.start.toString();
+  }
+  get endStr() {
+    if (this.end instanceof GraphNode) {
+      return `GraphNode ${this.end.coords.toString()}`;
+    }
+    return this.end.toString();
+  }
+  get message() {
+    let message = `No route found from ${this.startStr} to ${this.endStr}.`;
+    if (this.details) {
+      message += ` Details: ${this.details}`;
+    }
+    return message;
+  }
+}
+class GraphRouterOptions {
+  constructor() {
+    __publicField(this, "projectionMaxDistance", 50);
+    __publicField(this, "weightEdgeFn", (edge) => edge.length);
+    __publicField(this, "acceptEdgeFn", () => true);
+  }
+}
+class GraphRouter {
+  constructor(network) {
+    __publicField(this, "_mapMatching");
+    __publicField(this, "_network");
+    __publicField(this, "disabledEdges", /* @__PURE__ */ new Set());
+    this._network = network;
+    this._mapMatching = new MapMatching(network);
+  }
+  getShortestPath(start, end, options = new GraphRouterOptions()) {
+    if (!(start instanceof GraphNode) && !(start instanceof Coordinates)) {
+      throw new Error("Unknown start type");
+    }
+    if (!(end instanceof GraphNode) && !(end instanceof Coordinates)) {
+      throw new Error("Unknown end type");
+    }
+    const { acceptEdgeFn, weightEdgeFn, projectionMaxDistance } = options;
+    this._mapMatching.maxDistance = projectionMaxDistance;
+    const createdNodes = [];
+    const retrieveOrCreateNearestNode = (point) => {
+      if (point instanceof GraphNode) {
+        return point;
+      }
+      const closeNode = this._network.getNodeByCoords(point);
+      if (closeNode) {
+        return closeNode;
+      }
+      const proj = this._mapMatching.getProjection(point, true, false, false, acceptEdgeFn);
+      if (!proj) {
+        let message = `Point ${point.toString()} is too far from the network > ${this._mapMatching.maxDistance.toFixed(0)} meters.`;
+        if (point.level !== null) {
+          message += ` If it is a multi-level map, please verify if you have a network at level ${Level.toString(point.level)}.`;
+        }
+        throw new NoRouteFoundError(start, end, message);
+      }
+      if (proj.nearestElement instanceof GraphNode) {
+        return proj.nearestElement;
+      }
+      const nodeCreated = this.createNodeInsideEdge(
+        proj.nearestElement,
+        proj.coords
+      );
+      createdNodes.push(nodeCreated);
+      return nodeCreated;
+    };
+    const removeCreatedNodes = () => {
+      while (createdNodes.length) {
+        this.removeNodeFromPreviouslyCreatedEdge(createdNodes.pop());
+      }
+    };
+    const startNode = retrieveOrCreateNearestNode(start);
+    const endNode = retrieveOrCreateNearestNode(end);
+    const startCoords = start instanceof GraphNode ? start.coords : start;
+    const endCoords = end instanceof GraphNode ? end.coords : end;
+    let graphItinerary;
+    if (startNode === endNode) {
+      graphItinerary = GraphItinerary.fromNetworkNodes(
+        startCoords,
+        endCoords,
+        [startNode],
+        []
+      );
+    } else {
+      graphItinerary = this.getShortestPathBetweenGraphNodes(
+        startNode,
+        endNode,
+        acceptEdgeFn,
+        weightEdgeFn
+      );
+    }
+    graphItinerary.start = startCoords;
+    graphItinerary.end = endCoords;
+    removeCreatedNodes();
+    if (!graphItinerary.nodes.length) {
+      throw new NoRouteFoundError(start, end);
+    }
+    return graphItinerary;
+  }
+  createNodeInsideEdge(edge, point) {
+    const a = edge.node1;
+    const b = edge.node2;
+    const m = new GraphNode(point, null);
+    m.coords.level = edge.level;
+    const u = edge.clone();
+    u.node1 = a;
+    u.node2 = m;
+    const v = edge.clone();
+    v.node1 = m;
+    v.node2 = b;
+    a.edges = a.edges.filter((_edge) => _edge !== edge);
+    b.edges = b.edges.filter((_edge) => _edge !== edge);
+    this._network.nodes.push(m);
+    this._network.edges.push(u, v);
+    this._network.edges = this._network.edges.filter(
+      (_edge) => _edge !== edge
+    );
+    return m;
+  }
+  removeNodeFromPreviouslyCreatedEdge(_node) {
+    const u = _node.edges[0];
+    const v = _node.edges[1];
+    u.node1.edges = u.node1.edges.filter((edge) => edge !== u);
+    v.node1.edges = v.node1.edges.filter((edge) => edge !== v);
+    const oldEdge = u.clone();
+    oldEdge.node1 = u.node1;
+    oldEdge.node2 = v.node2;
+    this._network.edges.push(oldEdge);
+    this._network.nodes = this._network.nodes.filter((node) => node !== _node);
+    this._network.edges = this._network.edges.filter(
+      (edge) => edge !== u && edge !== v
+    );
+  }
+  getShortestPathBetweenGraphNodes(start, end, acceptEdgeFn, weightFn) {
+    const distanceMap = {}, checking = {}, vertexList = {}, vertexNodes = {}, parentVertices = {}, path = [];
+    let vertexId = 1;
+    this._network.nodes.forEach((vertex) => {
+      vertex.uniqueRouterId = vertexId;
+      vertexNodes[vertexId] = vertex;
+      distanceMap[vertexId] = Infinity;
+      checking[vertexId] = null;
+      vertexList[vertexId] = true;
+      vertexId++;
+    });
+    const startVertex = Object.values(vertexNodes).find((vertex) => start.equals(vertex));
+    const endVertex = Object.values(vertexNodes).find((vertex) => end.equals(vertex));
+    distanceMap[startVertex.uniqueRouterId] = 0;
+    while (Object.keys(vertexList).length > 0) {
+      const keys = Object.keys(vertexList).map(Number);
+      const current = Number(
+        keys.reduce((_checking, vertexId2) => {
+          return distanceMap[_checking] > distanceMap[vertexId2] ? vertexId2 : _checking;
+        }, keys[0])
+      );
+      this._network.edges.filter((edge) => {
+        if (!acceptEdgeFn(edge) || this.disabledEdges.has(edge)) {
+          return false;
+        }
+        const from = edge.node1.uniqueRouterId, to = edge.node2.uniqueRouterId;
+        return from === current || to === current;
+      }).forEach((edge) => {
+        let to, from, reversed = false;
+        if (edge.node1.uniqueRouterId === current) {
+          to = edge.node2.uniqueRouterId;
+          from = edge.node1.uniqueRouterId;
+        } else {
+          to = edge.node1.uniqueRouterId;
+          from = edge.node2.uniqueRouterId;
+          reversed = true;
+        }
+        if (edge.isOneway && reversed) {
+          return;
+        }
+        const distance = distanceMap[current] + weightFn(edge);
+        if (distanceMap[to] > distance) {
+          distanceMap[to] = distance;
+          checking[to] = current;
+          parentVertices[to] = from;
+        }
+      });
+      delete vertexList[current];
+    }
+    const edgesWeights = [];
+    let endId = endVertex.uniqueRouterId;
+    while (parentVertices[endId]) {
+      path.unshift(vertexNodes[endId]);
+      edgesWeights.unshift(distanceMap[endId] - distanceMap[parentVertices[endId]]);
+      endId = parentVertices[endId];
+    }
+    if (path.length !== 0) {
+      path.unshift(start);
+    }
+    this._network.nodes.forEach((vertex) => {
+      delete vertex.uniqueRouterId;
+    });
+    return GraphItinerary.fromNetworkNodes(start.coords, end.coords, path, edgesWeights);
+  }
+}
+exports.AbsoluteHeading = AbsoluteHeading;
+exports.Attitude = Attitude;
+exports.BoundingBox = BoundingBox;
+exports.Constants = Constants;
+exports.Coordinates = Coordinates;
+exports.GeoRef = GeoRef;
+exports.GeoRelativePosition = GeoRelativePosition;
+exports.GraphEdge = GraphEdge;
+exports.GraphItinerary = GraphItinerary;
+exports.GraphNode = GraphNode;
+exports.GraphProjection = GraphProjection;
+exports.GraphRouter = GraphRouter;
+exports.GraphRouterOptions = GraphRouterOptions;
+exports.GraphUtils = GraphUtils;
+exports.Level = Level;
+exports.MapMatching = MapMatching;
+exports.Network = Network;
+exports.NoRouteFoundError = NoRouteFoundError;
+exports.RelativePosition = RelativePosition;
+exports.UserPosition = UserPosition;
+exports.Utils = Utils;
+//# sourceMappingURL=index.js.map