@wemap/geo 11.8.2 → 12.0.0-alpha.11

package/dist/index.js

@@ -7,8 +7,6 @@ var __publicField = (obj, key, value) => {
 };
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const maths = require("@wemap/maths");
-const utils = require("@wemap/utils");
-const Logger = require("@wemap/logger");
 const R_MAJOR = 6378137;
 const R_MINOR = 63567523142e-4;
 const EARTH_GRAVITY = 9.80665;
@@ -62,13 +60,13 @@ const _Level = class _Level {
    */
   static isRange(level) {
     if (_Level.VERIFY_TYPING) {
-      this.checkType(level);
+      _Level.checkType(level);
     }
     return Array.isArray(level);
   }
   static clone(level) {
     if (_Level.VERIFY_TYPING) {
-      this.checkType(level);
+      _Level.checkType(level);
     }
     if (level === null) {
       return null;
@@ -96,14 +94,14 @@ const _Level = class _Level {
       const levels = splited.map((str2) => Number(str2));
       const low = Math.min(...levels);
       const up = Math.max(...levels);
-      this.checkType([low, up]);
+      _Level.checkType([low, up]);
       return [low, up];
     } else {
       const rangeSeparator = str.substring(1).indexOf("-") + 1;
       if (rangeSeparator > 0) {
         const low = Number(str.substring(0, rangeSeparator));
         const up = Number(str.substring(rangeSeparator + 1));
-        this.checkType([low, up]);
+        _Level.checkType([low, up]);
         return [low, up];
       }
     }
@@ -116,8 +114,8 @@ const _Level = class _Level {
    */
   static contains(container, targeted) {
     if (_Level.VERIFY_TYPING) {
-      this.checkType(container);
-      this.checkType(targeted);
+      _Level.checkType(container);
+      _Level.checkType(targeted);
     }
     if (container === targeted) {
       return true;
@@ -138,29 +136,40 @@ const _Level = class _Level {
   }
   /**
    * Retrieve the intersection of two levels
+   * null n null => null
+   * null n 1 => null // Conception choice
+   * null n [1,2] => null // Conception choice
+   * 1 n 1 => 1
+   * 1 n 2 => null
+   * 1 n [1,2] => 1
+   * 1 n [0,2] => 1
+   * 1 n [2,3] => null
+   * [1,2] n [1,2] => [1,2]
+   * [1,2] n [2,3] => 2
+   * [1,2] n [3,4] => null
    */
   static intersection(first, second) {
     if (_Level.VERIFY_TYPING) {
-      this.checkType(first);
-      this.checkType(second);
+      _Level.checkType(first);
+      _Level.checkType(second);
     }
     if (first === null || second === null) {
       return null;
     }
-    if (this.equals(first, second)) {
-      return this.clone(first);
+    if (_Level.equals(first, second)) {
+      return _Level.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)) {
+      if (_Level.contains(first, second)) {
         return second;
       }
       return null;
     }
     if (!Array.isArray(first) && Array.isArray(second)) {
-      if (this.contains(second, first)) {
+      if (_Level.contains(second, first)) {
         return first;
       }
       return null;
@@ -180,30 +189,41 @@ const _Level = class _Level {
   */
   static intersect(first, second) {
     if (_Level.VERIFY_TYPING) {
-      this.checkType(first);
-      this.checkType(second);
+      _Level.checkType(first);
+      _Level.checkType(second);
     }
     if (first === null && second === null) {
       return true;
     }
-    return this.intersection(first, second) !== null;
+    return _Level.intersection(first, second) !== null;
   }
   /**
    * Retrieve the union of two levels
+   * null u null => null
+   * null u 1 => null // Conception choice
+   * null u [1,2] => null // Conception choice
+   * 1 u 1 => 1
+   * 1 u 2 => [1,2]
+   * 1 u [1,2] => [1,2]
+   * 1 u [0,2] => [0,2]
+   * 1 u [2,3] => [1,3]
+   * [1,2] u [1,2] => [1,2]
+   * [1,2] u [2,3] => [1,3]
+   * [1,2] u [3,4] => [1,4]
    */
   static union(first, second) {
     if (_Level.VERIFY_TYPING) {
-      this.checkType(first);
-      this.checkType(second);
+      _Level.checkType(first);
+      _Level.checkType(second);
     }
     if (first === second) {
-      return this.clone(first);
+      return _Level.clone(first);
     }
     if (second === null) {
-      return this.clone(first);
+      return null;
     }
     if (first === null) {
-      return this.clone(second);
+      return null;
     }
     let low, up;
     if (!Array.isArray(first) && !Array.isArray(second)) {
@@ -232,7 +252,7 @@ const _Level = class _Level {
    */
   static multiplyBy(level, factor) {
     if (_Level.VERIFY_TYPING) {
-      this.checkType(level);
+      _Level.checkType(level);
     }
     if (level === null) {
       return null;
@@ -241,7 +261,7 @@ const _Level = class _Level {
   }
   static toString(level) {
     if (_Level.VERIFY_TYPING) {
-      this.checkType(level);
+      _Level.checkType(level);
     }
     if (level === null) {
       return null;
@@ -250,8 +270,8 @@ const _Level = class _Level {
   }
   static equals(first, second) {
     if (_Level.VERIFY_TYPING) {
-      this.checkType(first);
-      this.checkType(second);
+      _Level.checkType(first);
+      _Level.checkType(second);
     }
     if (first === second) {
       return true;
@@ -263,8 +283,8 @@ const _Level = class _Level {
   }
   static diff(first, second) {
     if (_Level.VERIFY_TYPING) {
-      this.checkType(first);
-      this.checkType(second);
+      _Level.checkType(first);
+      _Level.checkType(second);
     }
     if (first === null || second === null) {
       return null;
@@ -530,7 +550,7 @@ class Coordinates {
       poseCoordinates.lat,
       poseCoordinates.lng,
       alt,
-      Level.intersection(p1.level, p2.level)
+      Level.union(p1.level, p2.level)
     );
     if (Math.abs(p1.distanceTo(p2) - p1.distanceTo(projection) - p2.distanceTo(projection)) > EPS_MM) {
       return null;
@@ -567,26 +587,15 @@ class Coordinates {
       return [
         Number(this.lat.toFixed(8)),
         Number(this.lng.toFixed(8)),
-        this.alt === null ? null : Number(this.alt.toFixed(3)),
         this.level
       ];
     }
-    if (this.alt !== null) {
-      return [
-        Number(this.lat.toFixed(8)),
-        Number(this.lng.toFixed(8)),
-        Number(this.alt.toFixed(3))
-      ];
-    }
     return [Number(this.lat.toFixed(8)), Number(this.lng.toFixed(8))];
   }
   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];
+      coords.level = json[2];
     }
     return coords;
   }
@@ -802,9 +811,34 @@ function geolocationPositionToUserPosition(geolocationPosition) {
 function calcDistance(coords) {
   return coords.reduce((acc, coords2, idx, arr) => acc + (idx ? arr[idx - 1].distanceTo(coords2) : 0), 0);
 }
+function createSegmentsAtLevel(itineraryCoords, segmentsLevel, useMultiLevelSegments = true) {
+  const itineraryCoordsLength = itineraryCoords.length;
+  let previousLevelCorrespond = false;
+  const segments = [];
+  let coordinates = [];
+  for (let i = 0; i < itineraryCoordsLength; i++) {
+    const coords = itineraryCoords[i];
+    const levelCorrespond = Level.intersect(segmentsLevel, coords.level);
+    if (useMultiLevelSegments && !levelCorrespond && previousLevelCorrespond) {
+      coordinates.push(coords);
+    } else if (levelCorrespond) {
+      if (!previousLevelCorrespond) {
+        coordinates = [];
+        segments.push(coordinates);
+        if (useMultiLevelSegments && i !== 0) {
+          coordinates.push(itineraryCoords[i - 1]);
+        }
+      }
+      coordinates.push(coords);
+    }
+    previousLevelCorrespond = levelCorrespond;
+  }
+  return segments;
+}
 const Utils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   calcDistance,
+  createSegmentsAtLevel,
   geolocationPositionToUserPosition,
   sampleRoute,
   simplifyRoute,
@@ -1244,810 +1278,14 @@ class AbsoluteHeading {
     return new AbsoluteHeading(this.heading, this.time, this.accuracy);
   }
 }
-class GeoGraphEdge extends utils.GraphEdge {
-  constructor(vertex1, vertex2, params) {
-    super(vertex1, vertex2, params);
-    __publicField(this, "_level", null);
-    __publicField(this, "_bearing", null);
-    __publicField(this, "_length", null);
-    __publicField(this, "_computedSizeAndBearing", false);
-    __publicField(this, "isOneway", false);
-    Object.assign(this, params);
-  }
-  set vertex1(vertex) {
-    super.vertex1 = vertex;
-    this._computedSizeAndBearing = false;
-  }
-  get vertex1() {
-    return this._vertex1;
-  }
-  set vertex2(vertex) {
-    super.vertex2 = vertex;
-    this._computedSizeAndBearing = false;
-  }
-  get vertex2() {
-    return this._vertex2;
-  }
-  get level() {
-    return this._level;
-  }
-  set level(level) {
-    Level.checkType(level);
-    this._level = level;
-  }
-  /**
-   * Get edge bearing from vertex1 to vertex2
-   */
-  get bearing() {
-    if (!this._computedSizeAndBearing) {
-      this._computeSizeAndBearing();
-    }
-    return this._bearing;
-  }
-  /**
-   * get edge length
-   */
-  get length() {
-    if (!this._computedSizeAndBearing) {
-      this._computeSizeAndBearing();
-    }
-    return this._length;
-  }
-  _computeSizeAndBearing() {
-    this._length = this.vertex1.distanceTo(this.vertex2);
-    this._bearing = this.vertex1.bearingTo(this.vertex2);
-    this._computedSizeAndBearing = true;
-  }
-  static getEdgeByVertices(edges, vertex1, vertex2) {
-    return super.getEdgeByVertices(edges, vertex1, vertex2);
-  }
-}
-class GeoGraphVertex extends utils.GraphVertex {
-  constructor(coords, params) {
-    super(params);
-    __publicField(this, "coords");
-    __publicField(this, "io", false);
-    this.coords = coords;
-  }
-  distanceTo(other) {
-    return this.coords.distanceTo(other.coords);
-  }
-  bearingTo(other) {
-    return this.coords.bearingTo(other.coords);
-  }
-  /**
-   * Does not include "edges" property
-   */
-  toJson() {
-    return this.coords.toCompressedJson();
-  }
-  static fromJson(json) {
-    return new GeoGraphVertex(Coordinates.fromCompressedJson(json));
-  }
-  inferVertexLevelFromEdges() {
-    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 vertex level from adjacent ways: " + this.coords);
-          }
-        }
-      }
-    }
-    this.coords.level = tmpLevel;
-  }
-  /**
-   * We suppose inferVertexLevelFromEdges() was called before
-   */
-  inferVertexLevelByNeighboors() {
-    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 otherVertex = edge.vertex1 === this ? edge.vertex2 : edge.vertex1;
-      tmpLevel = Level.union(otherVertex.coords.level, tmpLevel);
-    }
-    if (tmpLevel === null || !Level.isRange(tmpLevel)) {
-      this.coords.level = tmpLevel === level[0] ? level[1] : level[0];
-    }
-    return true;
-  }
-  /**
-   * We suppose inferVertexLevelFromEdges() and inferVertexLevelByNeighboors() were called before
-   */
-  inferVertexLevelByRecursion() {
-    const { level } = this.coords;
-    if (level === null || !Level.isRange(level)) {
-      return;
-    }
-    if (this.edges.length > 1) {
-      return;
-    }
-    const lookForLevel = (vertex, visitedVertices) => {
-      visitedVertices.push(vertex);
-      if (vertex.coords.level === null) {
-        return null;
-      }
-      if (!Level.isRange(vertex.coords.level)) {
-        return vertex.coords.level;
-      }
-      let tmpLevel = null;
-      for (let i = 0; i < vertex.edges.length; i++) {
-        const edge = vertex.edges[i];
-        const otherVertex = edge.vertex1 === vertex ? edge.vertex2 : edge.vertex1;
-        if (!visitedVertices.includes(otherVertex)) {
-          tmpLevel = Level.union(lookForLevel(otherVertex, visitedVertices), 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");
-    }
-  }
-}
-class GeoGraph extends utils.Graph {
-  constructor(vertices, edges, generateVerticesLevels = false) {
-    super(vertices, edges);
-    generateVerticesLevels && this.generateVerticesLevels();
-  }
-  getVertexByCoords(coords) {
-    return GeoGraph.getVertexByCoords(this.vertices, coords);
-  }
-  static getVertexByCoords(vertices, coords) {
-    return vertices.find((vertex) => vertex.coords.equals(coords));
-  }
-  getVertexByName(name) {
-    return super.getVertexByName(name);
-  }
-  getEdgeByName(name) {
-    return super.getEdgeByName(name);
-  }
-  getBoundingBox(extendedMeasure) {
-    if (!this.vertices.length) {
-      return null;
-    }
-    const boundingBox = BoundingBox.fromCoordinates(this.vertices.map((vertex) => vertex.coords));
-    if (extendedMeasure) {
-      boundingBox.extendsWithMeasure(extendedMeasure);
-    }
-    return boundingBox;
-  }
-  toCompressedJson() {
-    const createEdgeExtras = (edge) => {
-      const extras = {};
-      if (edge.isOneway) {
-        extras.oneway = true;
-      }
-      return extras;
-    };
-    return {
-      vertices: this.vertices.map((vertex) => vertex.toJson()),
-      edges: this.edges.map((edge) => {
-        const vertex1Idx = this.vertices.indexOf(edge.vertex1);
-        const vertex2Idx = this.vertices.indexOf(edge.vertex2);
-        const edgeExtras = createEdgeExtras(edge);
-        if (Object.keys(edgeExtras).length > 0) {
-          return [vertex1Idx, vertex2Idx, edge.level, edgeExtras];
-        }
-        if (edge.level !== null) {
-          return [vertex1Idx, vertex2Idx, edge.level];
-        }
-        return [vertex1Idx, vertex2Idx];
-      })
-    };
-  }
-  static fromCompressedJson(json) {
-    const geograph = new GeoGraph();
-    geograph.vertices = json.vertices.map((vertex) => GeoGraphVertex.fromJson(vertex));
-    geograph.edges = json.edges.map((jsonEdge) => {
-      const edge = new GeoGraphEdge(
-        geograph.vertices[jsonEdge[0]],
-        geograph.vertices[jsonEdge[1]],
-        { level: jsonEdge.length > 2 ? jsonEdge[2] : null }
-      );
-      const extras = jsonEdge.length > 3 ? jsonEdge[3] : {};
-      if (typeof extras.oneway !== "undefined") {
-        edge.isOneway = extras.oneway;
-      }
-      return edge;
-    });
-    return geograph;
-  }
-  static fromCoordinates(segments) {
-    const geograph = new GeoGraph();
-    const getOrCreateVertex = (coords) => {
-      const vertex = geograph.vertices.find((otherVertex) => otherVertex.coords.equals(coords));
-      if (vertex) {
-        return vertex;
-      }
-      const newVertex = new GeoGraphVertex(coords);
-      geograph.vertices.push(newVertex);
-      return newVertex;
-    };
-    const createEdgeFromVertices = (vertex1, vertex2) => new GeoGraphEdge(
-      vertex1,
-      vertex2,
-      { level: Level.union(vertex1.coords.level, vertex2.coords.level) }
-    );
-    for (const segment of segments) {
-      let previousVertex = null;
-      for (const coords of segment) {
-        const currentVertex = getOrCreateVertex(coords);
-        if (previousVertex) {
-          const edge = createEdgeFromVertices(currentVertex, previousVertex);
-          geograph.edges.push(edge);
-        }
-        previousVertex = currentVertex;
-      }
-    }
-    return geograph;
-  }
-  /**
-   * Create edges From MultiLevel Itinerary for a given level
-   * @param useMultiLevelEdges use segments which intersect both levels (stairs, elevators...)
-   */
-  getEdgesAtLevel(targetLevel, useMultiLevelEdges = true) {
-    return this.edges.filter(
-      ({ level }) => useMultiLevelEdges ? Level.intersect(targetLevel, level) : Level.contains(targetLevel, level)
-    );
-  }
-  generateVerticesLevels() {
-    const { vertices } = this;
-    vertices.forEach((vertex) => vertex.inferVertexLevelFromEdges());
-    vertices.forEach((vertex) => vertex.inferVertexLevelByNeighboors());
-    vertices.forEach((vertex) => vertex.inferVertexLevelByRecursion());
-    vertices.forEach((vertex) => {
-      vertex.io = vertex.coords.level !== null && vertex.edges.some((edge) => edge.level === null);
-    });
-  }
-}
-class GeoGraphProjection {
-  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 _GeoGraphProjectionHandler = class _GeoGraphProjectionHandler {
-  constructor(graph = null) {
-    __publicField(this, "graph", null);
-    __publicField(this, "_maxDistance", Number.MAX_VALUE);
-    __publicField(this, "_maxAngleBearing", Math.PI);
-    this.graph = graph;
-  }
-  set maxAngleBearing(maxAngleBearing) {
-    this._maxAngleBearing = maxAngleBearing;
-  }
-  get maxAngleBearing() {
-    return this._maxAngleBearing;
-  }
-  set maxDistance(maxDistance) {
-    this._maxDistance = maxDistance;
-  }
-  get maxDistance() {
-    return this._maxDistance;
-  }
-  /**
-   * Check if the specified edge and its vertices can be used for projection
-   * @returns an array of two elements.
-   *  First is true if projection will be used on the specified edge, false otherwise.
-   *  Second is true if projection will be used on the vertices of the specified edge, false otherwise.
-   */
-  _shouldProjectOnEdgeAndVertices(edge, location, useBearing, useMultiLevelSegments, acceptEdgeFn) {
-    if (!acceptEdgeFn(edge)) {
-      return [false, false, false];
-    }
-    let checkEdge = Level.intersect(location.level, edge.level);
-    let checkVertex1 = Level.intersect(location.level, edge.vertex1.coords.level);
-    let checkVertex2 = Level.intersect(location.level, edge.vertex2.coords.level);
-    checkVertex1 = checkVertex1 || edge.vertex1.io && location.level === null;
-    checkVertex2 = checkVertex2 || edge.vertex2.io && location.level === null;
-    if (!useMultiLevelSegments) {
-      checkEdge = checkEdge && !Level.isRange(edge.level);
-      checkVertex1 = checkVertex1 && !Level.isRange(edge.vertex1.coords.level);
-      checkVertex2 = checkVertex2 && !Level.isRange(edge.vertex2.coords.level);
-    }
-    if (useBearing) {
-      if (checkEdge) {
-        const diffAngle = maths.diffAngleLines(edge.bearing, location.bearing);
-        if (diffAngle > this._maxAngleBearing) {
-          checkEdge = false;
-        }
-      }
-      checkVertex1 = false;
-      checkVertex2 = false;
-    }
-    return [checkEdge, checkVertex1, checkVertex2];
-  }
-  static _assignLatLngLevel(fromCoordinates, toCoordinates) {
-    toCoordinates.lat = fromCoordinates.lat;
-    toCoordinates.lng = fromCoordinates.lng;
-    toCoordinates.level = Level.clone(fromCoordinates.level);
-  }
-  /**
-   * IO Vertices are typical because they have a non-null level but projection car works on them.
-   * This function handles the case where the projection is on an IO vertex and a location with
-   * a null level is required.
-   */
-  static _handleLevelsWithIOVertices(projection, location, projectionVertex) {
-    if (location.level === null && projectionVertex.io) {
-      projection.level = null;
-    }
-  }
-  /**
-   * Main function for map-matching, the networks have to be set before calling this function
-   * The function will returns a GraphProjection object given a coordinates object and a set
-   * of options (useDistance, useBearing, useMultiLevelSegments, acceptEdgeFn).
-   */
-  getProjection(location, useDistance = false, useBearing = false, useMultiLevelSegments = true, acceptEdgeFn = () => true) {
-    if (this.graph === null) {
-      throw new Error("Graph has not been set yet");
-    }
-    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.graph.edges) {
-      const [checkEdge, checkVertex1, checkVertex2] = this._shouldProjectOnEdgeAndVertices(
-        edge,
-        location,
-        useBearing,
-        useMultiLevelSegments,
-        acceptEdgeFn
-      );
-      if (checkVertex1) {
-        const distVertex1 = location.distanceTo(edge.vertex1.coords);
-        if (isProjectionBetter(distVertex1) || distVertex1 <= EPS_MM) {
-          distanceFromNearestElement = distVertex1;
-          nearestElement = edge.vertex1;
-          _GeoGraphProjectionHandler._assignLatLngLevel(edge.vertex1.coords, projection);
-          _GeoGraphProjectionHandler._handleLevelsWithIOVertices(projection, location, edge.vertex1);
-          if (distVertex1 <= EPS_MM) {
-            break;
-          }
-        }
-      }
-      if (checkVertex2) {
-        const distVertex2 = location.distanceTo(edge.vertex2.coords);
-        if (isProjectionBetter(distVertex2) || distVertex2 <= EPS_MM) {
-          distanceFromNearestElement = distVertex2;
-          nearestElement = edge.vertex2;
-          _GeoGraphProjectionHandler._assignLatLngLevel(edge.vertex2.coords, projection);
-          _GeoGraphProjectionHandler._handleLevelsWithIOVertices(projection, location, edge.vertex2);
-          if (distVertex2 <= EPS_MM) {
-            break;
-          }
-        }
-      }
-      if (checkEdge) {
-        const segmentProjection = location.getSegmentProjection(edge.vertex1.coords, edge.vertex2.coords);
-        if (segmentProjection) {
-          const distEdge = location.distanceTo(segmentProjection);
-          if (isProjectionBetter(distEdge)) {
-            distanceFromNearestElement = distEdge;
-            nearestElement = edge;
-            _GeoGraphProjectionHandler._assignLatLngLevel(segmentProjection, projection);
-            _GeoGraphProjectionHandler._updateProjectionLevelFromEdge(edge, projection);
-          }
-        }
-      }
-    }
-    if (!nearestElement) {
-      return null;
-    }
-    if (projection instanceof UserPosition && projection.accuracy !== null) {
-      projection.accuracy += distanceFromNearestElement;
-    }
-    return new GeoGraphProjection(
-      location,
-      distanceFromNearestElement,
-      projection,
-      nearestElement
-    );
-  }
-};
-__publicField(_GeoGraphProjectionHandler, "_updateProjectionLevelFromEdge", (_edge, _projection) => {
-  _projection.level = Level.clone(_edge.level);
-});
-let GeoGraphProjectionHandler = _GeoGraphProjectionHandler;
-class GeoGraphItinerary extends GeoGraph {
-  constructor(start, end, vertices, edges, edgesWeights) {
-    super(vertices, edges);
-    this.start = start;
-    this.end = end;
-    this.edgesWeights = edgesWeights;
-  }
-  static fromGraphVertices(start, end, networkVertices, edgesWeights) {
-    const vertices = networkVertices.map((vertex) => {
-      return new GeoGraphVertex(
-        vertex.coords.clone(),
-        { name: vertex.name, id: vertex.id, data: vertex.data, io: vertex.io }
-      );
-    });
-    const edges = [];
-    networkVertices.forEach((vertex, idx, arr) => {
-      if (idx === 0) {
-        return;
-      }
-      const prevVertex = arr[idx - 1];
-      const edge = GeoGraphEdge.getEdgeByVertices(prevVertex.edges, prevVertex, vertex);
-      if (!edge) {
-        Logger.error("Cannot retrieve edge to create itinerary");
-        return;
-      }
-      edges.push(new GeoGraphEdge(
-        vertices[idx - 1],
-        vertices[idx],
-        { name: edge.name, id: edge.id, data: edge.data, level: edge.level, isOneway: edge.isOneway }
-      ));
-    });
-    return new GeoGraphItinerary(start, end, vertices, edges, edgesWeights);
-  }
-}
-class NoRouteFoundError extends Error {
-  constructor(start, end, details = null) {
-    super();
-    this.start = start;
-    this.end = end;
-    this.details = details;
-  }
-  get startStr() {
-    if (this.start instanceof GeoGraphVertex) {
-      return `GeoGraphVertex ${this.start.coords.toString()}`;
-    }
-    return this.start.toString();
-  }
-  get endStr() {
-    if (this.end instanceof GeoGraphVertex) {
-      return `GeoGraphVertex ${this.end.coords.toString()}`;
-    }
-    if (Array.isArray(this.end)) {
-      return this.end.map((p) => p instanceof GeoGraphVertex ? p.coords.toString() : p.toString()).join(",");
-    }
-    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;
-  }
-}
-const _GeoGraphRouter = class _GeoGraphRouter {
-  constructor(graph) {
-    __publicField(this, "_mapMatching");
-    __publicField(this, "_graph");
-    __publicField(this, "disabledEdges", /* @__PURE__ */ new Set());
-    this._graph = graph;
-    this._mapMatching = new GeoGraphProjectionHandler(graph);
-  }
-  getShortestPath(start, end, options = _GeoGraphRouter.DEFAULT_OPTIONS) {
-    const { acceptEdgeFn, weightEdgeFn, projectionMaxDistance } = options;
-    this._mapMatching.maxDistance = projectionMaxDistance;
-    const createdVertices = [];
-    const retrieveOrCreateNearestVertex = (point) => {
-      if (point instanceof GeoGraphVertex) {
-        return point;
-      }
-      const closeVertex = this._graph.getVertexByCoords(point);
-      if (closeVertex) {
-        return closeVertex;
-      }
-      const proj = this._mapMatching.getProjection(point, true, false, false, options.acceptEdgeFn);
-      if (!proj) {
-        let message = `Point ${point.toString()} is too far from the graph > ${this._mapMatching.maxDistance.toFixed(0)} meters.`;
-        if (point.level !== null) {
-          message += ` If it is a multi-level map, please verify if you have a graph at level ${Level.toString(point.level)}.`;
-        }
-        throw new NoRouteFoundError(start, end, message);
-      }
-      if (proj.nearestElement instanceof GeoGraphVertex) {
-        return proj.nearestElement;
-      }
-      const vertexCreated = this.createVertexInsideEdge(
-        proj.nearestElement,
-        proj.coords
-      );
-      createdVertices.push(vertexCreated);
-      return vertexCreated;
-    };
-    const removeCreatedVertices = () => {
-      while (createdVertices.length) {
-        this.removeVertexFromPreviouslyCreatedEdge(createdVertices.pop());
-      }
-    };
-    const startVertex = retrieveOrCreateNearestVertex(start);
-    const endVertex = retrieveOrCreateNearestVertex(end);
-    const startCoords = start instanceof GeoGraphVertex ? start.coords : start;
-    const endCoords = end instanceof GeoGraphVertex ? end.coords : end;
-    let graphItinerary;
-    if (startVertex === endVertex) {
-      graphItinerary = GeoGraphItinerary.fromGraphVertices(
-        startCoords,
-        endCoords,
-        [startVertex],
-        []
-      );
-    } else {
-      graphItinerary = this.getShortestPathBetweenGeoGraphVertices(
-        startVertex,
-        endVertex,
-        weightEdgeFn,
-        acceptEdgeFn
-      );
-    }
-    graphItinerary.start = startCoords;
-    graphItinerary.end = endCoords;
-    removeCreatedVertices();
-    if (!graphItinerary.vertices.length) {
-      throw new NoRouteFoundError(start, end);
-    }
-    return graphItinerary;
-  }
-  getShortestPaths(start, ends, options = _GeoGraphRouter.DEFAULT_OPTIONS) {
-    const { acceptEdgeFn, weightEdgeFn, projectionMaxDistance } = options;
-    this._mapMatching.maxDistance = projectionMaxDistance;
-    const createdVertices = [];
-    const retrieveOrCreateNearestVertex = (point, options2 = _GeoGraphRouter.DEFAULT_OPTIONS) => {
-      if (point instanceof GeoGraphVertex) {
-        return point;
-      }
-      const closeVertex = this._graph.getVertexByCoords(point);
-      if (closeVertex) {
-        return closeVertex;
-      }
-      const proj = this._mapMatching.getProjection(point, true, false, false, options2.acceptEdgeFn);
-      if (!proj) {
-        return null;
-      }
-      if (proj.nearestElement instanceof GeoGraphVertex) {
-        return proj.nearestElement;
-      }
-      const vertexCreated = this.createVertexInsideEdge(
-        proj.nearestElement,
-        proj.coords
-      );
-      createdVertices.push(vertexCreated);
-      return vertexCreated;
-    };
-    const removeCreatedVertices = () => {
-      while (createdVertices.length) {
-        this.removeVertexFromPreviouslyCreatedEdge(createdVertices.pop());
-      }
-    };
-    const startVertex = retrieveOrCreateNearestVertex(start);
-    const endsStruct = ends.map((e) => ({
-      input: e,
-      vertex: retrieveOrCreateNearestVertex(e),
-      itinerary: null
-    }));
-    const startCoords = start instanceof GeoGraphVertex ? start.coords : start;
-    if (!startVertex) {
-      let message = `Point ${startCoords.toString()} is too far from the graph > ${this._mapMatching.maxDistance.toFixed(0)} meters.`;
-      if (startCoords.level !== null) {
-        message += ` If it is a multi-level map, please verify if you have a graph at level ${Level.toString(startCoords.level)}.`;
-      }
-      throw new NoRouteFoundError(start, ends, message);
-    }
-    const endsStructFiltered = endsStruct.filter((v) => v.vertex != null);
-    const graphItineraries = this.getShortestPathsBetweenGeoGraphVertices(
-      startVertex,
-      endsStructFiltered.map((v) => v.vertex),
-      weightEdgeFn,
-      acceptEdgeFn
-    );
-    graphItineraries.forEach((itinerary, idx) => {
-      itinerary.start = startCoords;
-      const endStructFiltered = endsStructFiltered[idx];
-      endStructFiltered.itinerary = itinerary;
-    });
-    removeCreatedVertices();
-    endsStructFiltered.forEach((e) => {
-      if (e.itinerary !== null) {
-        e.itinerary.end = e.input instanceof GeoGraphVertex ? e.input.coords : e.input;
-      }
-    });
-    return endsStruct.map((end) => {
-      const endFiltered = endsStructFiltered.find((e) => e.input === end.input);
-      if (endFiltered)
-        return endFiltered.itinerary;
-      const endCoords = end.input instanceof GeoGraphVertex ? end.input.coords : end.input;
-      return GeoGraphItinerary.fromGraphVertices(startCoords, endCoords, [], []);
-    });
-  }
-  createVertexInsideEdge(edge, point) {
-    const a = edge.vertex1;
-    const b = edge.vertex2;
-    const m = new GeoGraphVertex(point, { name: `proj on ${edge.name || null} (tmp)` });
-    const newEdgesParams = { name: `splitted ${edge.name || null} (tmp)`, data: edge.data, isOneway: edge.isOneway, level: edge.level };
-    const u = new GeoGraphEdge(a, m, newEdgesParams);
-    const v = new GeoGraphEdge(m, b, newEdgesParams);
-    a.edges = a.edges.filter((_edge) => _edge !== edge);
-    b.edges = b.edges.filter((_edge) => _edge !== edge);
-    this._graph.vertices.push(m);
-    this._graph.edges.push(u, v);
-    this._graph.edges = this._graph.edges.filter(
-      (_edge) => _edge !== edge
-    );
-    return m;
-  }
-  removeVertexFromPreviouslyCreatedEdge(_vertex) {
-    const isUfirstEdge = _vertex.edges[0].vertex2 === _vertex;
-    const u = _vertex.edges[isUfirstEdge ? 0 : 1];
-    const v = _vertex.edges[isUfirstEdge ? 1 : 0];
-    u.vertex1.edges = u.vertex1.edges.filter((edge) => edge !== u);
-    v.vertex2.edges = v.vertex2.edges.filter((edge) => edge !== v);
-    const oldEdgeName = u.name.substring("splitted ".length, u.name.length - " (tmp)".length);
-    const oldEdgeParams = { name: oldEdgeName, data: u.data, isOneway: u.isOneway, level: u.level };
-    const oldEdge = new GeoGraphEdge(u.vertex1, v.vertex2, oldEdgeParams);
-    this._graph.edges.push(oldEdge);
-    this._graph.vertices = this._graph.vertices.filter((vertex) => vertex !== _vertex);
-    this._graph.edges = this._graph.edges.filter(
-      (edge) => edge !== u && edge !== v
-    );
-  }
-  getShortestPathBetweenGeoGraphVertices(start, end, weightFn, acceptEdgeFn) {
-    const distanceMap = {}, checking = {}, vertexList = {}, vertices = {}, parentVertices = {}, path = [];
-    this._graph.vertices.forEach((vertex) => {
-      vertices[vertex.id] = vertex;
-      distanceMap[vertex.id] = Infinity;
-      checking[vertex.id] = null;
-      vertexList[vertex.id] = true;
-    });
-    distanceMap[start.id] = 0;
-    while (Object.keys(vertexList).length > 0) {
-      const keys = Object.keys(vertexList).map(Number);
-      const current = Number(
-        keys.reduce((_checking, vertexId) => {
-          return distanceMap[_checking] > distanceMap[vertexId] ? vertexId : _checking;
-        }, keys[0])
-      );
-      this._graph.edges.filter((edge) => {
-        if (acceptEdgeFn && !acceptEdgeFn(edge) || this.disabledEdges.has(edge)) {
-          return false;
-        }
-        const from = edge.vertex1.id, to = edge.vertex2.id;
-        return from === current || to === current;
-      }).forEach((edge) => {
-        let to, from, reversed = false;
-        if (edge.vertex1.id === current) {
-          to = edge.vertex2.id;
-          from = edge.vertex1.id;
-        } else {
-          to = edge.vertex1.id;
-          from = edge.vertex2.id;
-          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 = end.id;
-    while (typeof parentVertices[endId] !== "undefined") {
-      path.unshift(vertices[endId]);
-      edgesWeights.unshift(distanceMap[endId] - distanceMap[parentVertices[endId]]);
-      endId = parentVertices[endId];
-    }
-    if (path.length !== 0) {
-      path.unshift(start);
-    }
-    return GeoGraphItinerary.fromGraphVertices(start.coords, end.coords, path, edgesWeights);
-  }
-  getShortestPathsBetweenGeoGraphVertices(start, ends, weightFn, acceptEdgeFn) {
-    const distanceMap = {}, checking = {}, vertexList = {}, vertices = {}, parentVertices = {};
-    this._graph.vertices.forEach((vertex) => {
-      vertices[vertex.id] = vertex;
-      distanceMap[vertex.id] = Infinity;
-      checking[vertex.id] = null;
-      vertexList[vertex.id] = true;
-    });
-    distanceMap[start.id] = 0;
-    while (Object.keys(vertexList).length > 0) {
-      const keys = Object.keys(vertexList).map(Number);
-      const current = Number(
-        keys.reduce((_checking, vertexId) => {
-          return distanceMap[_checking] > distanceMap[vertexId] ? vertexId : _checking;
-        }, keys[0])
-      );
-      this._graph.edges.filter((edge) => {
-        if (acceptEdgeFn && !acceptEdgeFn(edge) || this.disabledEdges.has(edge)) {
-          return false;
-        }
-        const from = edge.vertex1.id, to = edge.vertex2.id;
-        return from === current || to === current;
-      }).forEach((edge) => {
-        let to, from, reversed = false;
-        if (edge.vertex1.id === current) {
-          to = edge.vertex2.id;
-          from = edge.vertex1.id;
-        } else {
-          to = edge.vertex1.id;
-          from = edge.vertex2.id;
-          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];
-    }
-    return ends.map((end) => {
-      const edgesWeights = [];
-      const path = [];
-      let endId = end.id;
-      while (typeof parentVertices[endId] !== "undefined") {
-        path.unshift(vertices[endId]);
-        edgesWeights.unshift(distanceMap[endId] - distanceMap[parentVertices[endId]]);
-        endId = parentVertices[endId];
-      }
-      if (path.length !== 0) {
-        path.unshift(start);
-      }
-      return GeoGraphItinerary.fromGraphVertices(start.coords, end.coords, path, edgesWeights);
-    });
-  }
-};
-__publicField(_GeoGraphRouter, "DEFAULT_OPTIONS", {
-  projectionMaxDistance: 50,
-  weightEdgeFn: (edge) => edge.length
-});
-let GeoGraphRouter = _GeoGraphRouter;
 exports.AbsoluteHeading = AbsoluteHeading;
 exports.Attitude = Attitude;
 exports.BoundingBox = BoundingBox;
 exports.Constants = Constants;
 exports.Coordinates = Coordinates;
-exports.GeoGraph = GeoGraph;
-exports.GeoGraphEdge = GeoGraphEdge;
-exports.GeoGraphItinerary = GeoGraphItinerary;
-exports.GeoGraphProjection = GeoGraphProjection;
-exports.GeoGraphProjectionHandler = GeoGraphProjectionHandler;
-exports.GeoGraphRouter = GeoGraphRouter;
-exports.GeoGraphVertex = GeoGraphVertex;
 exports.GeoRef = GeoRef;
 exports.GeoRelativePosition = GeoRelativePosition;
 exports.Level = Level;
-exports.NoRouteFoundError = NoRouteFoundError;
 exports.RelativePosition = RelativePosition;
 exports.UserPosition = UserPosition;
 exports.Utils = Utils;