@wemap/routers 12.11.2 → 12.11.4

package/dist/index.mjs

@@ -4,14 +4,16 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import { Level, Coordinates, BoundingBox, UserPosition, Constants, Utils } from "@wemap/geo";
-import { diffAngleLines, deg2rad, diffAngle, positiveMod, rad2deg, roundFactor } from "@wemap/maths";
-import Logger from "@wemap/logger";
+import { g as getDurationFromLength, E as Edge, G as GraphRoute, V as Vertex, a as Graph, R as RemoteRouter, b as RemoteRoutingError, i as isTransitModePublicTransport, L as Leg, I as Itinerary, S as StepsBuilder, c as areTransitAndTravelModeConsistent, O as OsrmRemoteRouter, W as WemapMultiRoutingError } from "./OsrmRemoteRouter-e0076e4a.js";
+import { d, e, f } from "./OsrmRemoteRouter-e0076e4a.js";
 import salesman from "@wemap/salesman.js";
+import { Level, Coordinates, Utils } from "@wemap/geo";
 import { OsmNode, OsmParser } from "@wemap/osm";
+import Logger from "@wemap/logger";
 import polyline from "@mapbox/polyline";
 import pointInPolygon from "@turf/boolean-point-in-polygon";
 import convexHullFn from "@turf/convex";
+import "@wemap/maths";
 function routerRequestToJson(routerRequest) {
   const { origin, destination, waypoints, ...rest } = routerRequest;
   return {
@@ -21,921 +23,6 @@ function routerRequestToJson(routerRequest) {
     ...rest
   };
 }
-const _Edge = class _Edge {
-  constructor(vertex1, vertex2, properties = {}, id = _Edge.currentUniqueId++) {
-    __publicField(this, "level");
-    /** Edge bearing from vertex1 to vertex2 */
-    __publicField(this, "bearing");
-    __publicField(this, "length");
-    this.vertex1 = vertex1;
-    this.vertex2 = vertex2;
-    this.properties = properties;
-    this.id = id;
-    this.level = Level.union(vertex1.coords.level, vertex2.coords.level);
-    this.length = this.vertex1.distanceTo(this.vertex2);
-    this.bearing = this.vertex1.bearingTo(this.vertex2);
-  }
-  static getEdgeByVertices(edges, vertex1, vertex2) {
-    return edges.find(
-      (edge) => vertex1 === edge.vertex1 && vertex2 === edge.vertex2 || vertex2 === edge.vertex1 && vertex1 === edge.vertex2
-    );
-  }
-  reverseProperties() {
-    const { properties } = this;
-    if (properties.incline) {
-      properties.incline = properties.incline === "up" ? "down" : "up";
-    }
-    if (properties.isOneway) {
-      properties.isOneway = false;
-    }
-  }
-};
-__publicField(_Edge, "currentUniqueId", 0);
-let Edge = _Edge;
-class GraphProjection {
-  constructor(origin, distanceFromNearestElement, coords, nearestElement) {
-    this.origin = origin;
-    this.distanceFromNearestElement = distanceFromNearestElement;
-    this.coords = coords;
-    this.nearestElement = nearestElement;
-  }
-}
-class Vertex {
-  constructor(coords, properties = {}) {
-    __publicField(this, "id", -1);
-    this.coords = coords;
-    this.properties = properties;
-  }
-  distanceTo(other) {
-    return this.coords.distanceTo(other.coords);
-  }
-  bearingTo(other) {
-    return this.coords.bearingTo(other.coords);
-  }
-  toJson() {
-    return {
-      id: this.id,
-      coords: this.coords.toCompressedJson(),
-      ...Object.keys(this.properties).length > 0 && { properties: this.properties }
-    };
-  }
-  static fromJson(json) {
-    const v = new Vertex(
-      Coordinates.fromCompressedJson(json.coords),
-      json.properties
-    );
-    v.id = json.id;
-    return v;
-  }
-}
-class Graph {
-  constructor(vertices, edges) {
-    /**
-     * exitVertices are vertices that have at least one indoor edge and one outdoor edge
-     * They are stored because the Level model cannot handle an indoor and outdoor state like [null, 1] or [null, [1,2]]
-     * This vertices are used to cover the projection case:
-     * - if projection origin is null, an exit vertex can be used
-     * - if projection origin is not null, the intersection level with an exit vertex can be used
-     */
-    __publicField(this, "exitVertices");
-    this.vertices = vertices;
-    this.edges = edges;
-    const nullVertices = edges.filter((e) => e.level === null).map((e) => [e.vertex1, e.vertex2]).flat();
-    const levelVertices = edges.filter((e) => e.level !== null).map((e) => [e.vertex1, e.vertex2]).flat();
-    this.exitVertices = new Set(nullVertices.filter((v1) => levelVertices.includes(v1)));
-  }
-  getEdgeByVertices(vertex1, vertex2) {
-    return Edge.getEdgeByVertices(this.edges, vertex1, vertex2);
-  }
-  getVertexByCoords(coords) {
-    return Graph.getVertexByCoords(this.vertices, coords);
-  }
-  static getVertexByCoords(vertices, coords) {
-    return vertices.find((vertex) => vertex.coords.equals(coords));
-  }
-  getVertexByName(name) {
-    return this.vertices.find((vertex) => vertex.properties.name === name);
-  }
-  getEdgeByName(name) {
-    return this.edges.find((edge) => edge.properties.name === 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;
-  }
-  getProjection(origin, options = {}) {
-    const useMaxDistance = "maxDistance" in options;
-    const maxDistance = options.maxDistance;
-    const useMaxBearingAngle = "maxBearingAngle" in options;
-    if (useMaxBearingAngle && (!(origin instanceof UserPosition) || origin.bearing === null))
-      return null;
-    const maxBearingAngle = options.maxBearingAngle;
-    const useAcceptEdgeFn = "acceptEdgeFn" in options;
-    const useMultiLevelSegments = !("useMultiLevelSegments" in options) || options.useMultiLevelSegments;
-    let bestProjection = null;
-    const adaptProjectionCoords = (projCoords) => {
-      if (!(origin instanceof UserPosition))
-        return projCoords;
-      const p = origin.clone();
-      p.lat = projCoords.lat;
-      p.lng = projCoords.lng;
-      p.level = projCoords.level;
-      p.alt = projCoords.alt;
-      p.heightFromFloor = projCoords.heightFromFloor;
-      p.heightFromGround = projCoords.heightFromGround;
-      return p;
-    };
-    this.edges.forEach((edge) => {
-      if (useAcceptEdgeFn && !options.acceptEdgeFn(edge))
-        return;
-      if (!useMultiLevelSegments && Level.isRange(edge.level))
-        return;
-      if (!Level.intersect(edge.level, origin.level))
-        return;
-      if (useMaxBearingAngle) {
-        if (diffAngleLines(edge.bearing, origin.bearing) > maxBearingAngle)
-          return;
-      }
-      const segmentProjection = origin.getSegmentProjection(edge.vertex1.coords, edge.vertex2.coords);
-      if (!segmentProjection)
-        return;
-      const distanceToSegment = segmentProjection.distanceTo(origin);
-      if (useMaxDistance && distanceToSegment > maxDistance)
-        return;
-      if (distanceToSegment < ((bestProjection == null ? void 0 : bestProjection.distanceFromNearestElement) ?? Number.MAX_VALUE)) {
-        bestProjection = new GraphProjection(origin, distanceToSegment, adaptProjectionCoords(segmentProjection), edge);
-      }
-    });
-    if (useMaxBearingAngle) {
-      return bestProjection;
-    }
-    this.vertices.forEach((vertex) => {
-      let vertexCoords = vertex.coords;
-      if (this.exitVertices.has(vertex) && origin.level === null) {
-        vertexCoords = vertex.coords.clone();
-        vertexCoords.level = null;
-      }
-      if (!useMultiLevelSegments && Level.isRange(vertexCoords.level))
-        return;
-      if (!Level.intersect(vertexCoords.level, origin.level))
-        return;
-      const distanceToVertex = vertexCoords.distanceTo(origin);
-      if (distanceToVertex < Constants.EPS_MM) {
-        bestProjection = new GraphProjection(origin, 0, adaptProjectionCoords(vertexCoords), vertex);
-        return;
-      }
-      if (useMaxDistance && distanceToVertex > maxDistance)
-        return;
-      if (distanceToVertex < ((bestProjection == null ? void 0 : bestProjection.distanceFromNearestElement) ?? Number.MAX_VALUE)) {
-        bestProjection = new GraphProjection(origin, distanceToVertex, adaptProjectionCoords(vertexCoords), vertex);
-      }
-    });
-    return bestProjection;
-  }
-  toJson() {
-    return {
-      vertices: this.vertices.map((vertex) => vertex.toJson()),
-      edges: this.edges.map((edge) => ({
-        id: edge.id,
-        vertex1Idx: this.vertices.indexOf(edge.vertex1),
-        vertex2Idx: this.vertices.indexOf(edge.vertex2),
-        ...Object.keys(edge.properties).length > 0 && { properties: edge.properties }
-      }))
-    };
-  }
-  static fromJson(json) {
-    const vertices = json.vertices.map((vertex) => Vertex.fromJson(vertex));
-    const edges = json.edges.map((jsonEdge) => new Edge(
-      vertices[jsonEdge.vertex1Idx],
-      vertices[jsonEdge.vertex2Idx],
-      jsonEdge.properties,
-      jsonEdge.id
-    ));
-    return new Graph(vertices, edges);
-  }
-  /** @deprecated */
-  toCompressedJson() {
-    return {
-      vertices: this.vertices.map((vertex) => vertex.coords.toCompressedJson()),
-      verticesIds: this.vertices.map((vertex) => vertex.id),
-      edges: this.edges.map((edge) => {
-        const vertex1Idx = this.vertices.indexOf(edge.vertex1);
-        const vertex2Idx = this.vertices.indexOf(edge.vertex2);
-        const edgeExtras = edge.properties;
-        if (Object.keys(edgeExtras).length > 0) {
-          return [vertex1Idx, vertex2Idx, edgeExtras];
-        }
-        return [vertex1Idx, vertex2Idx];
-      })
-    };
-  }
-  /** @deprecated */
-  static fromCompressedJson(json) {
-    const vertices = json.vertices.map((vertex) => new Vertex(Coordinates.fromCompressedJson(vertex)));
-    const edges = json.edges.map((jsonEdge) => new Edge(
-      vertices[jsonEdge[0]],
-      vertices[jsonEdge[1]],
-      jsonEdge.length > 2 ? jsonEdge[2] : {}
-    ));
-    return new Graph(vertices, edges);
-  }
-  static fromCoordinatesSegments(segments) {
-    const vertices = [];
-    const edges = [];
-    const getOrCreateVertex = (coords) => {
-      const vertex = vertices.find((otherVertex) => otherVertex.coords.equals(coords));
-      if (vertex) {
-        return vertex;
-      }
-      const newVertex = new Vertex(coords);
-      vertices.push(newVertex);
-      return newVertex;
-    };
-    for (const segment of segments) {
-      let previousVertex = null;
-      for (const coords of segment) {
-        const currentVertex = getOrCreateVertex(coords);
-        if (previousVertex) {
-          edges.push(new Edge(currentVertex, previousVertex));
-        }
-        previousVertex = currentVertex;
-      }
-    }
-    return new Graph(vertices, edges);
-  }
-  /**
-   * 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)
-    );
-  }
-  toDetailedString() {
-    let output = `--- Network ---
-Vertices: ${this.vertices.length}
-Edges: ${this.edges.length}
----
-Vertices
-`;
-    this.vertices.forEach((vertex) => {
-      output += vertex.id;
-      const vertexProps = vertex.properties;
-      if (Object.keys(vertexProps).length !== 0) {
-        output += ` ${vertexProps}`;
-      }
-    });
-    output += "---\nEdges\n";
-    this.edges.forEach((edge) => {
-      output += `${edge.id} - [v1: ${edge.vertex1.id}, v2: ${edge.vertex2.id}]`;
-      const edgeProps = edge.properties;
-      if (Object.keys(edgeProps).length !== 0) {
-        output += ` ${edgeProps}`;
-      }
-    });
-    output += "---";
-    return output;
-  }
-}
-function getDurationFromLength(length, speed = 5) {
-  return length / (speed * 1e3 / 3600);
-}
-function isTransitModePublicTransport(transitMode) {
-  return [
-    "AIRPLANE",
-    "BOAT",
-    "BUS",
-    "FERRY",
-    "FUNICULAR",
-    "METRO",
-    "MULTI",
-    "TRAIN",
-    "TRAM"
-  ].includes(transitMode);
-}
-function areTransitAndTravelModeConsistent(transitMode, travelMode) {
-  return transitMode === travelMode || isTransitModePublicTransport(transitMode) && travelMode === "TRANSIT" || transitMode === "WALK" && travelMode === "TRANSIT";
-}
-function stepToJson(step) {
-  return {
-    ...step.firstStep && { firstStep: true },
-    ...step.lastStep && { lastStep: true },
-    number: step.number,
-    coords: step.coords.toCompressedJson(),
-    ...step.name !== null && { name: step.name },
-    angle: Number(step.angle.toFixed(2)),
-    previousBearing: Number(step.previousBearing.toFixed(2)),
-    nextBearing: Number(step.nextBearing.toFixed(2)),
-    distance: Number(step.distance.toFixed(1)),
-    duration: Number(step.duration.toFixed(1)),
-    ...step.levelChange !== null && { levelChange: step.levelChange },
-    ...step.extras && Object.keys(step.extras).length !== 0 && { extras: step.extras }
-  };
-}
-function jsonToStep(json) {
-  return Object.assign({}, json, {
-    coords: Coordinates.fromCompressedJson(json.coords),
-    firstStep: Boolean(json.firstStep),
-    lastStep: Boolean(json.lastStep),
-    name: json.name || null,
-    levelChange: json.levelChange || null,
-    extras: json.extras || null
-  });
-}
-function stepEquals(step1, step2) {
-  var _a, _b, _c, _d, _e, _f;
-  return step1.coords.equals(step2.coords) && Math.abs(step1.angle - step2.angle) <= 5e-3 && Math.abs(step1.distance - step2.distance) <= 0.05 && Math.abs(step1.duration - step2.duration) <= 0.05 && step1.firstStep === step2.firstStep && step1.lastStep === step2.lastStep && ((_a = step1.levelChange) == null ? void 0 : _a.difference) === ((_b = step2.levelChange) == null ? void 0 : _b.difference) && ((_c = step1.levelChange) == null ? void 0 : _c.direction) === ((_d = step2.levelChange) == null ? void 0 : _d.direction) && ((_e = step1.levelChange) == null ? void 0 : _e.type) === ((_f = step2.levelChange) == null ? void 0 : _f.type) && step1.name === step2.name && Math.abs(step1.nextBearing - step2.nextBearing) <= 5e-3 && step1.number === step2.number && Math.abs(step1.previousBearing - step2.previousBearing) <= 5e-3;
-}
-class GraphRoute extends Graph {
-  constructor(start, end, vertices, edges, edgesWeights) {
-    super(vertices, edges);
-    this.start = start;
-    this.end = end;
-    this.vertices = vertices;
-    this.edges = edges;
-    this.edgesWeights = edgesWeights;
-  }
-  // /!\ Does not clone vertices
-  // /!\ Create new Edges but does not deep clone properties
-  // /!\ Does not revert edge oneway property
-  reverse() {
-    const vertices = this.vertices.slice().reverse();
-    const edges = this.edges.slice().reverse();
-    const edgesWeights = this.edgesWeights.slice().reverse();
-    edges.map((oldEdge) => new Edge(oldEdge.vertex2, oldEdge.vertex1, oldEdge.properties));
-    return new GraphRoute(this.start, this.end, vertices, edges, edgesWeights);
-  }
-  static fromCoordinates(start, end, coordinates) {
-    const graph = Graph.fromCoordinatesSegments([coordinates]);
-    const edgesWeights = graph.edges.map((e) => getDurationFromLength(e.length));
-    return new GraphRoute(start, end, graph.vertices, graph.edges, edgesWeights);
-  }
-  get hasRoute() {
-    return Boolean(this.vertices.length);
-  }
-}
-const SKIP_STEP_ANGLE_MAX = deg2rad(20);
-class StepsBuilder {
-  constructor() {
-    __publicField(this, "start", null);
-    __publicField(this, "end", null);
-    __publicField(this, "pathCoords", null);
-    __publicField(this, "stepsInfo", []);
-  }
-  setStart(start) {
-    this.start = start;
-    return this;
-  }
-  setEnd(end) {
-    this.end = end;
-    return this;
-  }
-  setPathCoords(pathCoords) {
-    this.pathCoords = pathCoords;
-    return this;
-  }
-  setStepsInfo(stepsInfo) {
-    this.stepsInfo = stepsInfo;
-    return this;
-  }
-  addStepInfo(stepInfo) {
-    this.stepsInfo.push(stepInfo);
-    return this;
-  }
-  setGraphRoute(graphRoute) {
-    const stepsInfo = [];
-    const { start, end } = graphRoute;
-    if (!graphRoute.hasRoute) {
-      return this;
-    }
-    let currentStep = null;
-    let previousBearing = start.bearingTo(graphRoute.vertices[0].coords);
-    for (let i = 0; i < graphRoute.vertices.length - 1; i++) {
-      const isFirstStep = i === 0;
-      const vertex = graphRoute.vertices[i];
-      const currentCoords = vertex.coords;
-      const nextVertex = graphRoute.vertices[i + 1];
-      const nextCoords = nextVertex.coords;
-      const edge = graphRoute.edges[i];
-      const nextBearing = vertex.bearingTo(nextVertex);
-      const angle = diffAngle(previousBearing, nextBearing + Math.PI);
-      const previousStep = stepsInfo.length ? stepsInfo[stepsInfo.length - 1] : null;
-      const { isSubwayEntrance, isGate, subwayEntranceRef } = vertex.properties;
-      const { isElevator, areEscalators, areStairs, isMovingWalkway, incline } = edge.properties;
-      let levelChangeType = null;
-      if (isElevator) {
-        levelChangeType = "elevator";
-      } else if (areEscalators) {
-        levelChangeType = "escalator";
-      } else if (areStairs) {
-        levelChangeType = "stairs";
-      } else if (isMovingWalkway) {
-        levelChangeType = "moving walkway";
-      } else {
-        levelChangeType = "incline plane";
-      }
-      let forceLevelChange;
-      if ((areStairs || isElevator) && incline && !(previousStep == null ? void 0 : previousStep.levelChange)) {
-        forceLevelChange = incline;
-      }
-      const previousEdge = i > 0 ? graphRoute.edges[i - 1] : null;
-      const previousEdgeProperties = (previousEdge == null ? void 0 : previousEdge.properties) || {};
-      const forceEndOfLevelChange = Boolean(
-        previousEdgeProperties.incline && previousEdgeProperties.areStairs && (!incline || !areStairs)
-      );
-      const isEntrance = vertex.properties.isSubwayEntrance;
-      const stepName = edge.properties.name || null;
-      const duration = graphRoute.edgesWeights[i];
-      const stepExtras = {
-        ...isSubwayEntrance && { isSubwayEntrance },
-        ...subwayEntranceRef && { subwayEntranceRef },
-        ...isGate && { isGate }
-      };
-      let splitByAngle = Math.abs(diffAngle(Math.PI, angle)) >= SKIP_STEP_ANGLE_MAX;
-      const splitByLevel = Level.isRange(edge.level) && !Level.isRange(currentCoords.level) || forceLevelChange;
-      splitByAngle = splitByAngle && !(currentCoords.level && Level.isRange(currentCoords.level));
-      const splitByEndOfLevelChange = (previousStep == null ? void 0 : previousStep.levelChange) && !Level.isRange(currentCoords.level) || forceEndOfLevelChange;
-      const splitStepCondition = splitByAngle || splitByLevel || splitByEndOfLevelChange || isEntrance;
-      if (isFirstStep || splitStepCondition) {
-        let levelChange;
-        if (splitByLevel) {
-          const difference = Level.diff(currentCoords.level, nextCoords.level) || 0;
-          let direction = difference > 0 ? "up" : "down";
-          if (forceLevelChange) {
-            direction = forceLevelChange;
-          }
-          levelChange = {
-            difference,
-            direction,
-            ...levelChangeType && { type: levelChangeType }
-          };
-        }
-        currentStep = {
-          coords: currentCoords,
-          ...stepName && { name: stepName },
-          extras: stepExtras,
-          levelChange,
-          distance: 0,
-          duration: 0
-        };
-        stepsInfo.push(currentStep);
-      }
-      currentStep.distance += currentCoords.distanceTo(nextCoords);
-      currentStep.duration += duration;
-      previousBearing = nextBearing;
-    }
-    const lastCoords = graphRoute.vertices[graphRoute.vertices.length - 1].coords;
-    if (!Coordinates.equals(lastCoords, end)) {
-      stepsInfo.push({ coords: lastCoords });
-    }
-    this.setStart(start);
-    this.setEnd(end);
-    this.setPathCoords(graphRoute.vertices.map((v) => v.coords));
-    this.setStepsInfo(stepsInfo);
-    return this;
-  }
-  build() {
-    const { pathCoords, start, end } = this;
-    if (!pathCoords) {
-      Logger.warn(`StepsBuilder: Missing "pathCoords" property to build steps`);
-      return [];
-    }
-    if (!start) {
-      Logger.warn(`StepsBuilder: Missing "from" property to build steps`);
-      return [];
-    }
-    if (!end) {
-      Logger.warn(`StepsBuilder: Missing "to" property to build steps`);
-      return [];
-    }
-    if (this.stepsInfo.length === 0) {
-      this.setGraphRoute(GraphRoute.fromCoordinates(start, end, pathCoords));
-    }
-    const { stepsInfo } = this;
-    return stepsInfo.map((stepInfo, stepId) => {
-      const coordsId = pathCoords.findIndex((coords) => coords.equals(stepInfo.coords));
-      if (coordsId === -1) {
-        throw new Error("Cannot find step coordinates in itinerary coordinates.");
-      }
-      const coordsBeforeStep = coordsId === 0 ? start : pathCoords[coordsId - 1];
-      const coordsAfterStep = coordsId === pathCoords.length - 1 ? end : pathCoords[coordsId + 1];
-      const previousBearing = coordsBeforeStep.bearingTo(stepInfo.coords);
-      const nextBearing = stepInfo.coords.bearingTo(coordsAfterStep);
-      let distance = 0;
-      const isLastStep = stepId === stepsInfo.length - 1;
-      const coordsToStopCalculation = isLastStep ? pathCoords[pathCoords.length - 1] : stepsInfo[stepId + 1].coords;
-      let currentCoordsId = coordsId;
-      while (!pathCoords[currentCoordsId].equals(coordsToStopCalculation)) {
-        distance += pathCoords[currentCoordsId].distanceTo(pathCoords[currentCoordsId + 1]);
-        currentCoordsId++;
-      }
-      return {
-        coords: stepInfo.coords,
-        name: stepInfo.name || null,
-        number: stepId + 1,
-        previousBearing,
-        nextBearing,
-        angle: diffAngle(previousBearing, nextBearing + Math.PI),
-        firstStep: stepId === 0,
-        lastStep: isLastStep,
-        distance,
-        // stepInfo.distance is overwritten
-        duration: stepInfo.duration || getDurationFromLength(distance),
-        levelChange: stepInfo.levelChange || null,
-        extras: stepInfo.extras || null
-      };
-    });
-  }
-}
-class Leg {
-  constructor({
-    start,
-    end,
-    coords,
-    transitMode,
-    duration,
-    startTime,
-    endTime,
-    transportInfo,
-    steps
-  }) {
-    __publicField(this, "start");
-    __publicField(this, "end");
-    __publicField(this, "coords");
-    __publicField(this, "distance");
-    __publicField(this, "transitMode");
-    __publicField(this, "duration");
-    __publicField(this, "startTime");
-    __publicField(this, "endTime");
-    __publicField(this, "steps");
-    __publicField(this, "transportInfo");
-    this.start = {
-      name: start.name || null,
-      coords: start.coords
-    };
-    this.end = {
-      name: end.name || null,
-      coords: end.coords
-    };
-    this.coords = coords;
-    this.transitMode = transitMode;
-    this.distance = Utils.calcDistance(coords);
-    this.duration = typeof duration === "number" ? duration : getDurationFromLength(this.distance);
-    this.startTime = typeof startTime === "number" ? startTime : null;
-    this.endTime = typeof endTime === "number" ? endTime : null;
-    this.transportInfo = transportInfo || null;
-    this.steps = Array.isArray(steps) ? steps : new StepsBuilder().setStart(start.coords).setEnd(end.coords).setPathCoords(coords).build();
-  }
-  isPublicTransport() {
-    return isTransitModePublicTransport(this.transitMode);
-  }
-  toGraph() {
-    return Graph.fromCoordinatesSegments([this.coords]);
-  }
-  static equals(obj1, obj2) {
-    var _a, _b;
-    const intermediate = obj1.transitMode === obj2.transitMode && Math.abs(obj1.duration - obj2.duration) <= 0.05 && obj1.startTime === obj2.startTime && obj1.endTime === obj2.endTime && obj1.start.name === obj2.start.name && obj1.start.coords.equals(obj2.start.coords) && obj1.end.name === obj2.end.name && obj1.end.coords.equals(obj2.end.coords) && obj1.coords.length === obj2.coords.length && (obj1.steps === obj2.steps || ((_a = obj1.steps) == null ? void 0 : _a.length) === ((_b = obj2.steps) == null ? void 0 : _b.length));
-    if (!intermediate) {
-      return false;
-    }
-    let i;
-    for (i = 0; i < obj1.coords.length; i++) {
-      if (!obj1.coords[i].equals(obj2.coords[i])) {
-        return false;
-      }
-    }
-    for (i = 0; i < obj1.steps.length; i++) {
-      if (!stepEquals(obj1.steps[i], obj2.steps[i])) {
-        return false;
-      }
-    }
-    if (obj1.transportInfo !== obj2.transportInfo) {
-      if (obj1.transportInfo === null || obj2.transportInfo === null) {
-        return false;
-      }
-      if (obj1.transportInfo.name !== obj2.transportInfo.name || obj1.transportInfo.routeColor !== obj2.transportInfo.routeColor || obj1.transportInfo.routeTextColor !== obj2.transportInfo.routeTextColor || obj1.transportInfo.directionName !== obj2.transportInfo.directionName) {
-        return false;
-      }
-    }
-    return true;
-  }
-  equals(obj) {
-    return Leg.equals(this, obj);
-  }
-  toJson() {
-    return {
-      transitMode: this.transitMode,
-      start: {
-        coords: this.start.coords.toCompressedJson(),
-        ...this.start.name && { name: this.start.name }
-      },
-      end: {
-        coords: this.end.coords.toCompressedJson(),
-        ...this.end.name && { name: this.end.name }
-      },
-      distance: Number(this.distance.toFixed(1)),
-      duration: Number(this.duration.toFixed(1)),
-      coords: this.coords.map((coords) => coords.toCompressedJson()),
-      steps: this.steps.map(stepToJson),
-      ...this.startTime !== null && { startTime: this.startTime },
-      ...this.endTime !== null && { endTime: this.endTime },
-      ...this.transportInfo !== null && { transportInfo: this.transportInfo }
-    };
-  }
-  static fromJson(json) {
-    var _a;
-    const leg = new Leg(Object.assign({}, json, {
-      start: {
-        coords: Coordinates.fromCompressedJson(json.start.coords),
-        name: json.start.name || null
-      },
-      end: {
-        coords: Coordinates.fromCompressedJson(json.end.coords),
-        name: json.end.name || null
-      },
-      coords: json.coords.map(Coordinates.fromCompressedJson),
-      steps: ((_a = json.steps) == null ? void 0 : _a.map(jsonToStep)) || null
-    }));
-    return leg;
-  }
-  static fromGraphRoute(graphRoute, transitMode = "WALK") {
-    return new Leg({
-      start: { coords: graphRoute.start },
-      end: { coords: graphRoute.end },
-      coords: graphRoute.vertices.map((vertex) => vertex.coords),
-      duration: graphRoute.edgesWeights.reduce((acc, weight) => acc + weight, 0),
-      transitMode,
-      steps: new StepsBuilder().setGraphRoute(graphRoute).build()
-    });
-  }
-  // TODO: Remove when possible...
-  // Livemap specific
-  multiplyLevel(levelFactor) {
-    this.start.coords.level = Level.multiplyBy(this.start.coords.level, levelFactor);
-    this.end.coords.level = Level.multiplyBy(this.end.coords.level, levelFactor);
-    for (const coords of this.coords) {
-      coords.level = Level.multiplyBy(coords.level, levelFactor);
-    }
-    this.steps.forEach((step) => {
-      step.coords.level = Level.multiplyBy(step.coords.level, levelFactor);
-    });
-  }
-}
-class Itinerary {
-  constructor({
-    origin,
-    destination,
-    duration,
-    legs,
-    startTime,
-    endTime
-  }) {
-    __publicField(this, "origin");
-    __publicField(this, "destination");
-    __publicField(this, "duration");
-    __publicField(this, "legs");
-    __publicField(this, "_transitMode", null);
-    __publicField(this, "startTime");
-    __publicField(this, "endTime");
-    __publicField(this, "_coords", null);
-    __publicField(this, "_distance", null);
-    this.origin = origin;
-    this.destination = destination;
-    this.legs = legs;
-    if (typeof duration === "number") {
-      this.duration = duration;
-    } else {
-      this.duration = this.legs.reduce((dur, leg) => dur + leg.duration, 0);
-    }
-    this.startTime = typeof startTime === "number" ? startTime : null;
-    this.endTime = typeof endTime === "number" ? endTime : null;
-    this.updateStepsFromLegs();
-  }
-  set coords(_) {
-    throw new Error("Itinerary.coords cannot be set. They are calculated from Itinerary.legs.");
-  }
-  get coords() {
-    if (!this._coords) {
-      this._coords = this.legs.map((leg) => leg.coords).flat().filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equals(coords));
-    }
-    return this._coords;
-  }
-  set steps(_) {
-    throw new Error("Itinerary.step cannot be set. They are calculated from Itinerary.legs.");
-  }
-  get steps() {
-    return this.legs.map((leg) => leg.steps).flat();
-  }
-  set transitMode(_) {
-    throw new Error("Itinerary.transitMode cannot be set. They are calculated from Itinerary.legs.");
-  }
-  // Transit mode will return MULTI if there are several transit modes except WALK
-  // Else it will return the only transit mode
-  // fallback to WALK if no transit mode
-  get transitMode() {
-    if (!this._transitMode) {
-      const legTransitModes = new Set(this.legs.map((leg) => leg.transitMode));
-      legTransitModes.delete("WALK");
-      if (legTransitModes.size > 1) {
-        this._transitMode = "MULTI";
-        return this._transitMode;
-      }
-      if (legTransitModes.size === 1) {
-        this._transitMode = legTransitModes.values().next().value;
-        return this._transitMode;
-      }
-      this._transitMode = "WALK";
-    }
-    return this._transitMode;
-  }
-  set distance(_) {
-    throw new Error("Itinerary.distance cannot be set. They are calculated from Itinerary.legs.");
-  }
-  get distance() {
-    if (this._distance === null) {
-      this._distance = Utils.calcDistance(this.coords);
-    }
-    return this._distance;
-  }
-  toGraph() {
-    return Graph.fromCoordinatesSegments([this.coords]);
-  }
-  static fromItineraries(...itineraries) {
-    return new Itinerary({
-      origin: itineraries[0].origin,
-      destination: itineraries[itineraries.length - 1].destination,
-      legs: itineraries.map((itinerary) => itinerary.legs).flat()
-    });
-  }
-  /**
-   * Convert lat/lng/level? points to Itinerary
-   */
-  static fromOrderedPointsArray(points, start, end) {
-    const pointToCoordinates = (point) => new Coordinates(point[0], point[1], null, point[2]);
-    return this.fromOrderedCoordinates(
-      points.map(pointToCoordinates),
-      pointToCoordinates(start),
-      pointToCoordinates(end)
-    );
-  }
-  /**
-   * Convert ordered Coordinates to Itinerary
-   */
-  static fromOrderedCoordinates(coords, origin, destination, transitMode = "WALK") {
-    const steps = new StepsBuilder().setPathCoords(coords).setStart(origin).setEnd(destination).build();
-    const leg = new Leg({
-      start: { coords: origin },
-      end: { coords: destination },
-      coords,
-      transitMode,
-      steps
-    });
-    return new Itinerary({ origin, destination, legs: [leg] });
-  }
-  static equals(obj1, obj2) {
-    const intermediate = obj1.origin.equals(obj2.origin) && obj1.destination.equals(obj2.destination) && Math.abs(obj1.distance - obj2.distance) <= 0.05 && Math.abs(obj1.duration - obj2.duration) <= 0.05 && obj1.startTime === obj2.startTime && obj1.endTime === obj2.endTime && obj1.legs.length === obj2.legs.length;
-    if (!intermediate) {
-      return false;
-    }
-    for (let i = 0; i < obj1.legs.length; i++) {
-      if (!obj1.legs[i].equals(obj2.legs[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  equals(obj) {
-    return Itinerary.equals(this, obj);
-  }
-  toJson() {
-    return {
-      origin: this.origin.toJson(),
-      destination: this.destination.toJson(),
-      distance: Number(this.distance.toFixed(1)),
-      duration: Number(this.duration.toFixed(1)),
-      transitMode: this.transitMode,
-      legs: this.legs.map((leg) => leg.toJson()),
-      ...this.startTime !== null && { startTime: this.startTime },
-      ...this.endTime !== null && { endTime: this.endTime }
-    };
-  }
-  static fromJson(json) {
-    return new Itinerary({
-      origin: Coordinates.fromJson(json.origin),
-      destination: Coordinates.fromJson(json.destination),
-      duration: json.duration,
-      legs: json.legs.map(Leg.fromJson),
-      startTime: json.startTime,
-      endTime: json.endTime
-    });
-  }
-  static fromGraphRoute(graphRoute, transitMode = "WALK") {
-    const leg = Leg.fromGraphRoute(graphRoute, transitMode);
-    return new Itinerary({
-      origin: graphRoute.start,
-      destination: graphRoute.end,
-      legs: [leg]
-    });
-  }
-  // TODO: Remove when possible...
-  // Livemap specific
-  multiplyLevel(levelFactor) {
-    this.origin.level = Level.multiplyBy(this.origin.level, levelFactor);
-    this.destination.level = Level.multiplyBy(this.destination.level, levelFactor);
-    this.legs.forEach((leg) => leg.multiplyLevel(levelFactor));
-  }
-  // TODO: Remove when possible...
-  // Livemap specific
-  forceUnknownLevelTo0() {
-    this.origin.level = this.origin.level || 0;
-    this.destination.level = this.destination.level || 0;
-    for (const leg of this.legs) {
-      leg.start.coords.level = leg.start.coords.level || 0;
-      leg.end.coords.level = leg.end.coords.level || 0;
-      for (const coords of leg.coords) {
-        coords.level = coords.level || 0;
-      }
-      if (leg.steps) {
-        for (const step of leg.steps) {
-          step.coords.level = step.coords.level || 0;
-        }
-      }
-    }
-    if (this._coords) {
-      for (const coords of this._coords) {
-        coords.level = coords.level || 0;
-      }
-    }
-  }
-  toGeoJson() {
-    const transformToPoint = (point, name, type) => ({
-      type: "Feature",
-      properties: { name, level: point.level, ...type && { type } },
-      geometry: {
-        type: "Point",
-        coordinates: [point.lng, point.lat]
-      }
-    });
-    const transformToMultiLineStrings = (segments, level) => ({
-      type: "Feature",
-      properties: { level, name: level == null ? void 0 : level.toString() },
-      geometry: {
-        type: "MultiLineString",
-        coordinates: segments.map((s) => s.map(({ lat, lng }) => [lng, lat]))
-      }
-    });
-    const levelsOfItinerary = [...new Set(this.coords.map((c) => Level.toString(c.level)))].map(Level.fromString);
-    const segmentsSplitted = levelsOfItinerary.map((loi) => [loi, Utils.createSegmentsAtLevel(this.coords, loi, true)]);
-    const multiLineStrings = segmentsSplitted.map(([loi, segments]) => transformToMultiLineStrings(segments, loi));
-    const legsStarts = this.legs.map((leg, idx) => transformToPoint(leg.start.coords, `Leg ${idx} start`, "leg-start"));
-    const legsEnds = this.legs.map((leg, idx) => transformToPoint(leg.end.coords, `Leg ${idx} end`, "leg-end"));
-    const steps = this.steps.map((step) => transformToPoint(step.coords, `Step ${step.number}`, "step"));
-    return {
-      type: "FeatureCollection",
-      features: [
-        transformToPoint(this.origin, "origin", "origin"),
-        transformToPoint(this.destination, "destination", "destination"),
-        ...multiLineStrings,
-        ...legsStarts,
-        ...legsEnds,
-        ...steps
-      ]
-    };
-  }
-  /**
-   * TODO: Remove it in router v3
-   * Update steps info thanks to the coordinates of the whole itinerary.
-   * This method will update:
-   * - all steps number
-   * - first/last steps
-   * - previousBearing/nextBearing/angle of first and last step of each leg
-   */
-  updateStepsFromLegs() {
-    const itineraryCoords = this.coords.filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equals(coords));
-    const steps = this.legs.map((leg) => leg.steps).flat();
-    steps.map((step, stepId) => {
-      const coordsId = itineraryCoords.findIndex((coords) => coords.equals(step.coords));
-      if (coordsId === -1) {
-        throw new Error("Cannot find step coordinates in itinerary coordinates.");
-      }
-      const coordsBeforeStep = coordsId === 0 ? this.origin : itineraryCoords[coordsId - 1];
-      const coordsAfterStep = coordsId === itineraryCoords.length - 1 ? this.destination : itineraryCoords[coordsId + 1];
-      step.previousBearing = coordsBeforeStep.bearingTo(step.coords);
-      step.nextBearing = step.coords.bearingTo(coordsAfterStep);
-      step.angle = diffAngle(step.previousBearing, step.nextBearing + Math.PI);
-      step.number = stepId + 1;
-      step.firstStep = stepId === 0;
-      step.lastStep = stepId === steps.length - 1;
-    });
-  }
-}
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 var uaParser = { exports: {} };
 (function(module, exports) {
@@ -2492,20 +1579,20 @@ class GraphRouterEngineResults {
             }
           };
         }),
-        ...graph.edges.map((e) => {
-          const level = e.level;
+        ...graph.edges.map((e2) => {
+          const level = e2.level;
           return {
             type: "Feature",
             properties: {
-              id: e.id,
+              id: e2.id,
               ...level !== null && { level },
-              ...e.properties
+              ...e2.properties
             },
             geometry: {
               type: "LineString",
               coordinates: [
-                [e.vertex1.coords.lng, e.vertex1.coords.lat],
-                [e.vertex2.coords.lng, e.vertex2.coords.lat]
+                [e2.vertex1.coords.lng, e2.vertex1.coords.lat],
+                [e2.vertex2.coords.lng, e2.vertex2.coords.lat]
               ]
             }
           };
@@ -2525,9 +1612,9 @@ class GraphRouterEngine {
     const q = new Set(inputVertices);
     const dist = Array(q.size).fill(Number.MAX_VALUE);
     const prev = new Array(q.size).fill(null);
-    const edges = inputEdges.filter((e) => {
+    const edges = inputEdges.filter((e2) => {
       var _a;
-      return (((_a = options.acceptEdgeFn) == null ? void 0 : _a.call(options, e)) ?? true) && !this.disabledEdges.has(e);
+      return (((_a = options.acceptEdgeFn) == null ? void 0 : _a.call(options, e2)) ?? true) && !this.disabledEdges.has(e2);
     });
     const weightEdgeFn = options.weightEdgeFn || ((edge) => edge.length);
     const getVertexWithMinDistance = (vertices) => {
@@ -2611,9 +1698,9 @@ class GraphRouterEngine {
         "type": "Feature",
         "geometry": {
           "type": "MultiLineString",
-          "coordinates": edges.map((e) => [
-            [e.vertex1.coords.lng, e.vertex1.coords.lat],
-            [e.vertex2.coords.lng, e.vertex2.coords.lat]
+          "coordinates": edges.map((e2) => [
+            [e2.vertex1.coords.lng, e2.vertex1.coords.lat],
+            [e2.vertex2.coords.lng, e2.vertex2.coords.lat]
           ])
         },
         "properties": {
@@ -2937,7 +2024,7 @@ const _OsmGraphUtils = class _OsmGraphUtils {
       }
       if (verticesOfEachLevel.length === 1 && verticesOfEachLevel[0].coords.level === null) {
         const vertex = verticesOfEachLevel[0];
-        const vertexEdges = edges.filter((e) => e.vertex1 === vertex || e.vertex2 === vertex);
+        const vertexEdges = edges.filter((e2) => e2.vertex1 === vertex || e2.vertex2 === vertex);
         if (vertexEdges.length > 1) {
           const elevatorVertices2 = [vertex];
           for (let i = 1; i < vertexEdges.length; i++) {
@@ -2974,64 +2061,6 @@ __publicField(_OsmGraphUtils, "DEFAULT_WAY_SELECTOR", (way) => {
   return way.tags.highway && !_OsmGraphUtils.RESTRICTED_PEDESTRIANS_HIGHWAYS.includes(way.tags.highway) && !isElevatorArea || way.tags.footway === "sidewalk" || way.tags.public_transport === "platform" || way.tags.railway === "platform";
 });
 let OsmGraphUtils = _OsmGraphUtils;
-class RemoteRouter {
-}
-var StatusCode = /* @__PURE__ */ ((StatusCode2) => {
-  StatusCode2[StatusCode2["OK"] = 0] = "OK";
-  StatusCode2[StatusCode2["CANCELLED"] = 1] = "CANCELLED";
-  StatusCode2[StatusCode2["UNKNOWN"] = 2] = "UNKNOWN";
-  StatusCode2[StatusCode2["INVALID_ARGUMENT"] = 3] = "INVALID_ARGUMENT";
-  StatusCode2[StatusCode2["NOT_FOUND"] = 5] = "NOT_FOUND";
-  StatusCode2[StatusCode2["UNIMPLEMENTED"] = 12] = "UNIMPLEMENTED";
-  StatusCode2[StatusCode2["INTERNAL"] = 13] = "INTERNAL";
-  StatusCode2[StatusCode2["UNAVAILABLE"] = 14] = "UNAVAILABLE";
-  StatusCode2[StatusCode2["UNAUTHENTICATED"] = 16] = "UNAUTHENTICATED";
-  return StatusCode2;
-})(StatusCode || {});
-class RoutingError extends Error {
-  constructor(code = StatusCode.UNKNOWN, message) {
-    super(message);
-    __publicField(this, "customMapName");
-    this.code = code;
-  }
-  static notFound(details) {
-    return new RoutingError(StatusCode.NOT_FOUND, `Cannot found an itinerary. Details: ${details}`);
-  }
-}
-class WemapMultiRoutingError extends RoutingError {
-  constructor(code = StatusCode.UNKNOWN, mapName, message) {
-    super(code, message);
-    this.code = code;
-    this.mapName = mapName;
-    this.mapName = mapName;
-  }
-  static notFound(mapName, details) {
-    return new WemapMultiRoutingError(StatusCode.NOT_FOUND, mapName, `Cannot found an itinerary in map ${mapName}. Details: ${details || "No details"}`);
-  }
-}
-class RemoteRoutingError extends RoutingError {
-  constructor(code = StatusCode.UNKNOWN, routerName, message) {
-    super(code, message);
-    this.code = code;
-    this.routerName = routerName;
-    this.routerName = routerName;
-  }
-  static notFound(routerName, details) {
-    return new RemoteRoutingError(StatusCode.NOT_FOUND, routerName, `Cannot found an itinerary with ${routerName}. Details: ${details || "No details"}`);
-  }
-  static missingApiKey(routerName, details) {
-    return new RemoteRoutingError(StatusCode.UNAUTHENTICATED, routerName, `API key is missing for ${routerName}. Details: ${details}`);
-  }
-  static unreachableServer(routerName, url) {
-    return new RemoteRoutingError(StatusCode.NOT_FOUND, routerName, `Remote router server ${routerName} is unreachable. URL: ${url}`);
-  }
-  static responseNotParsing(routerName, url) {
-    return new RemoteRoutingError(StatusCode.NOT_FOUND, routerName, `Remote router server response ${routerName} cannot be parsed. URL: ${url}`);
-  }
-  static travelModeUnimplemented(routerName, travelMode) {
-    return new RemoteRoutingError(StatusCode.UNIMPLEMENTED, routerName, `Travel mode "${travelMode}" is not implemented for ${routerName}`);
-  }
-}
 function dateWithTimeZone(year, month, day, hour, minute, second, timeZone = "Europe/Paris") {
   const date = new Date(Date.UTC(year, month, day, hour, minute, second));
   const utcDate = new Date(date.toLocaleString("en-US", { timeZone: "UTC" }));
@@ -4149,218 +3178,6 @@ class IdfmRemoteRouter extends RemoteRouter {
   }
 }
 const IdfmRemoteRouter$1 = new IdfmRemoteRouter();
-const outputModeCorrespondance = /* @__PURE__ */ new Map();
-outputModeCorrespondance.set("CAR", "CAR");
-outputModeCorrespondance.set("WALK", "WALK");
-outputModeCorrespondance.set("BIKE", "BIKE");
-class OsrmRemoteRouter extends RemoteRouter {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "inputModeCorrespondance", (routerRequest) => {
-      var _a;
-      const { travelMode, travelModePreference: preference } = routerRequest;
-      if (travelMode === "WALK" && ((_a = routerRequest.itineraryModifiers) == null ? void 0 : _a.isWheelchair))
-        return "pmr";
-      if (travelMode === "WALK")
-        return "walking";
-      if (travelMode === "BIKE") {
-        if (preference === "FASTEST")
-          return "bike-fastest";
-        if (preference === "SAFEST")
-          return "bike-safest";
-        if (preference === "TOURISM")
-          return "bike-safest";
-        return "bike-safest";
-      }
-      if (travelMode === "CAR")
-        return "driving";
-      throw RemoteRoutingError.travelModeUnimplemented(this.rname, travelMode);
-    });
-  }
-  get rname() {
-    return "osrm";
-  }
-  async getItineraries(endpointUrl, routerRequest) {
-    const url = this.getURL(endpointUrl, routerRequest);
-    const res = await fetch(url).catch(() => {
-      throw RemoteRoutingError.unreachableServer(this.rname, url);
-    });
-    const jsonResponse = await res.json().catch(() => {
-      throw RemoteRoutingError.responseNotParsing(this.rname, url);
-    });
-    return this.parseResponse(jsonResponse, routerRequest.origin, routerRequest.destination, routerRequest.travelMode);
-  }
-  /**
-   * @throws {TravelModeCorrespondanceNotFound}
-   */
-  getURL(endpointUrl, routerRequest) {
-    const { origin, destination } = routerRequest;
-    const osrmMode = this.inputModeCorrespondance(routerRequest);
-    const waypoints = [origin, ...routerRequest.waypoints || [], destination];
-    let url = endpointUrl + "/route/v1/" + osrmMode + "/";
-    url += waypoints.map((waypoint) => [waypoint.longitude + "," + waypoint.latitude]).join(";");
-    url += "?geometries=geojson&overview=full&steps=true";
-    routerRequest.provideItineraryAlternatives && (url += "&alternatives=true");
-    return url;
-  }
-  coordinatesToJson({ lat, lng, level }) {
-    if (level === null) {
-      return [lng, lat];
-    }
-    if (Level.isRange(level)) {
-      return [lng, lat, level[0]];
-    }
-    return [lng, lat, level];
-  }
-  /**
-   * @param {object} json
-   * @returns {Coordinates}
-   */
-  jsonToCoordinates(json) {
-    const coords = new Coordinates(json[1], json[0]);
-    if (json.length > 2) {
-      coords.level = json[2];
-    }
-    return coords;
-  }
-  getModifierFromAngle(_angle) {
-    const angle = positiveMod(rad2deg(_angle), 360);
-    if (angle > 0 && angle < 60) {
-      return "sharp right";
-    }
-    if (angle >= 60 && angle < 140) {
-      return "right";
-    }
-    if (angle >= 140 && angle < 160) {
-      return "slight right";
-    }
-    if (angle >= 160 && angle <= 200) {
-      return "straight";
-    }
-    if (angle > 200 && angle <= 220) {
-      return "slight left";
-    }
-    if (angle > 220 && angle <= 300) {
-      return "left";
-    }
-    if (angle > 300 && angle < 360) {
-      return "sharp left";
-    }
-    return "u turn";
-  }
-  noRouteFoundJson(message) {
-    return {
-      "code": "NoRoute",
-      message
-    };
-  }
-  /**
-   * @deprecated
-   */
-  itineraryToOsrmJson(itinerary) {
-    const lastLegId = itinerary.legs.length - 1;
-    const itinerarySteps = itinerary.steps;
-    const jsonLegs = itinerary.legs.map(({ distance, duration, coords }, idLeg) => {
-      const legSteps = itinerarySteps.filter(
-        (step) => coords.find((_coords) => _coords.equals(step.coords))
-      );
-      const lastStepId = legSteps.length - 1;
-      return {
-        distance,
-        duration: duration || 0,
-        steps: legSteps.map((step, idStep, arr) => {
-          let type = idStep === 0 && idLeg === 0 ? "depart" : "turn";
-          type = idStep === lastStepId && idLeg === lastLegId ? "arrive" : type;
-          const stepCoordsIdx = coords.findIndex((p) => p.equals(step.coords));
-          const nextStepCoordsIdx = idStep === lastStepId ? stepCoordsIdx : coords.findIndex((p) => p.equals(arr[idStep + 1].coords));
-          const osrmStep = {
-            geometry: {
-              type: "LineString",
-              coordinates: coords.slice(stepCoordsIdx, nextStepCoordsIdx + 1).map(this.coordinatesToJson)
-            },
-            distance: step.distance,
-            duration: step.duration || 0,
-            ...step.name && { name: step.name },
-            maneuver: {
-              bearing_before: rad2deg(step.previousBearing),
-              bearing_after: rad2deg(step.nextBearing),
-              location: this.coordinatesToJson(step.coords),
-              modifier: this.getModifierFromAngle(step.angle),
-              type
-            }
-          };
-          return osrmStep;
-        })
-      };
-    });
-    return {
-      "code": "Ok",
-      "routes": [
-        {
-          "geometry": {
-            "type": "LineString",
-            "coordinates": itinerary.coords.map(this.coordinatesToJson)
-          },
-          "legs": jsonLegs,
-          "distance": itinerary.distance,
-          "duration": itinerary.duration,
-          "weight_name": "routability",
-          "weight": 0
-        }
-      ],
-      "waypoints": []
-    };
-  }
-  parseResponse(json, origin, destination, travelMode) {
-    const transitMode = outputModeCorrespondance.get(travelMode);
-    const { routes: jsonRoutes } = json;
-    if (!jsonRoutes) {
-      throw RemoteRoutingError.notFound(this.rname, json.message);
-    }
-    return jsonRoutes.map((jsonItinerary) => {
-      const legs = jsonItinerary.legs.map((jsonLeg) => {
-        var _a;
-        const legCoords = jsonLeg.steps.map((step) => step.geometry.coordinates.map(this.jsonToCoordinates)).flat().filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equals(coords));
-        const startCoords = legCoords[0];
-        const endCoords = legCoords[legCoords.length - 1];
-        const stepsBuilder = new StepsBuilder().setPathCoords(legCoords).setStart(startCoords).setEnd(endCoords);
-        (_a = jsonLeg.steps) == null ? void 0 : _a.forEach(({ maneuver, name, distance, duration }) => {
-          const stepCoords = this.jsonToCoordinates(maneuver.location);
-          const distances = legCoords.map((coords) => coords.distanceTo(stepCoords));
-          const idStepCoordsInLeg = distances.indexOf(Math.min(...distances));
-          if (idStepCoordsInLeg < 0) {
-            throw new Error("Osrm Parser: Cannot find step coords in leg coordinates");
-          }
-          stepsBuilder.addStepInfo({
-            coords: legCoords[idStepCoordsInLeg],
-            name,
-            distance,
-            duration
-          });
-        });
-        return new Leg({
-          transitMode,
-          duration: jsonLeg.duration,
-          coords: legCoords,
-          start: {
-            coords: startCoords
-          },
-          end: {
-            coords: endCoords
-          },
-          steps: stepsBuilder.build()
-        });
-      });
-      return new Itinerary({
-        duration: jsonItinerary.duration,
-        origin,
-        destination,
-        legs
-      });
-    });
-  }
-}
-const OsrmRemoteRouter$1 = new OsrmRemoteRouter();
 function isLegPT(leg) {
   return leg.mode === "BUS" || leg.mode === "TRAM";
 }
@@ -4516,7 +3333,7 @@ const remoteRouters = [
   NavitiaRemoteRouter$1,
   DeutscheBahnRemoteRouter$1,
   IdfmRemoteRouter$1,
-  OsrmRemoteRouter$1,
+  OsrmRemoteRouter,
   OtpRemoteRouter$1,
   WemapMultiRemoteRouter$1
 ];
@@ -4622,11 +3439,11 @@ class WemapMultiRouter {
       };
       try {
         remoteRouterItineraries = await RemoteRouterManager$1.getItinerariesWithFallback(newRouterRequest, fallbackStrategy);
-      } catch (e) {
-        if (e instanceof RemoteRoutingError) {
-          e.message = customError(e.message);
+      } catch (e2) {
+        if (e2 instanceof RemoteRoutingError) {
+          e2.message = customError(e2.message);
         }
-        throw e;
+        throw e2;
       }
       ioMapItinerary = Itinerary.fromGraphRoute(ioMapRoute);
       return remoteRouterItineraries.map(
@@ -4655,11 +3472,11 @@ class WemapMultiRouter {
       };
       try {
         remoteRouterItineraries = await RemoteRouterManager$1.getItinerariesWithFallback(newRouterRequest, fallbackStrategy);
-      } catch (e) {
-        if (e instanceof RemoteRoutingError) {
-          e.message = customError(e.message);
+      } catch (e2) {
+        if (e2 instanceof RemoteRoutingError) {
+          e2.message = customError(e2.message);
         }
-        throw e;
+        throw e2;
       }
       ioMapItinerary = Itinerary.fromGraphRoute(ioMapRoute);
       return remoteRouterItineraries.map(
@@ -4702,11 +3519,11 @@ class WemapMultiRouter {
       };
       try {
         remoteRouterItineraries = await RemoteRouterManager$1.getItinerariesWithFallback(newRouterRequest, fallbackStrategy);
-      } catch (e) {
-        if (e instanceof RemoteRoutingError) {
-          e.message = customError(e.message);
+      } catch (e2) {
+        if (e2 instanceof RemoteRoutingError) {
+          e2.message = customError(e2.message);
         }
-        throw e;
+        throw e2;
       }
       return remoteRouterItineraries.map(
         (remoteRouterItinerary) => Itinerary.fromItineraries(
@@ -4757,8 +3574,8 @@ class CustomGraphMap {
     let osmModel;
     try {
       osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-    } catch (e) {
-      errors.couldNotParseFile = e instanceof Error ? e.message : "Unknown error";
+    } catch (e2) {
+      errors.couldNotParseFile = e2 instanceof Error ? e2.message : "Unknown error";
       callbackErrors == null ? void 0 : callbackErrors(errors);
       return;
     }
@@ -4876,7 +3693,7 @@ class CustomGraphMapTester {
   static createReport(osmXmlString) {
     var _a;
     let customGraphMapErrors;
-    const customGraphMap = CustomGraphMap.fromOsmXml(osmXmlString, null, (e) => customGraphMapErrors = e);
+    const customGraphMap = CustomGraphMap.fromOsmXml(osmXmlString, null, (e2) => customGraphMapErrors = e2);
     const errors = [];
     if ((customGraphMapErrors == null ? void 0 : customGraphMapErrors.couldNotParseFile) || !customGraphMap) {
       errors.push({
@@ -5032,233 +3849,6 @@ class ItineraryInfoManager {
     return itineraryInfo;
   }
 }
-const _InstructionManager = class _InstructionManager {
-  static getTurnInfoFromAngle(_angle) {
-    let direction, directionExtra;
-    const directionAngle = rad2deg(diffAngle(_angle, Math.PI));
-    const directionAngleAbs = Math.abs(directionAngle);
-    if (directionAngleAbs <= 20) {
-      direction = "straight";
-    } else {
-      direction = directionAngle > 0 ? "left" : "right";
-      if (directionAngleAbs < 55) {
-        directionExtra = "slight";
-      } else if (directionAngleAbs > 120) {
-        directionExtra = "sharp";
-      }
-    }
-    return { direction, directionExtra };
-  }
-  static getInfoFromStep(step) {
-    let type, direction, directionExtra, levelChange;
-    if (step.levelChange) {
-      type = "level-change";
-      levelChange = step.levelChange;
-    } else {
-      type = "turn";
-      const turnInfo = _InstructionManager.getTurnInfoFromAngle(step.angle);
-      direction = turnInfo.direction;
-      directionExtra = turnInfo.directionExtra;
-    }
-    return {
-      type,
-      direction,
-      directionExtra,
-      levelChange,
-      name: step.name,
-      indoor: step.coords.level !== null
-    };
-  }
-  // eslint-disable-next-line max-statements, complexity
-  static getInstructionFromStep(step) {
-    var _a, _b;
-    const { direction, directionExtra } = _InstructionManager.getTurnInfoFromAngle(step.angle);
-    const isTurn = direction !== "straight";
-    if (step.lastStep) {
-      if (isTurn && direction === "left") {
-        return "Your destination is on your left";
-      } else if (isTurn && direction === "right") {
-        return "Your destination is on your right";
-      }
-    }
-    let suffix = "";
-    if ((_a = step.extras) == null ? void 0 : _a.isGate) {
-      suffix = ` on gate ${step.name}`;
-    } else if (step.name) {
-      suffix = ` on ${step.name}`;
-    }
-    if (step.levelChange) {
-      if (step.levelChange.direction === "up") {
-        if (step.levelChange.type === "stairs") {
-          return "Go up the stairs";
-        }
-        if (step.levelChange.type === "escalator") {
-          return "Go up the escalator";
-        }
-        if (step.levelChange.type === "elevator") {
-          return "Go up the elevator";
-        }
-        if (step.levelChange.type === "moving walkway") {
-          return "Go up the moving walkway";
-        }
-        if (step.levelChange.type === "incline plane") {
-          return "Go up the incline plane";
-        }
-        return "Go up" + suffix;
-      }
-      if (step.levelChange.direction === "down") {
-        if (step.levelChange.type === "stairs") {
-          return "Go down the stairs";
-        }
-        if (step.levelChange.type === "escalator") {
-          return "Go down the escalator";
-        }
-        if (step.levelChange.type === "elevator") {
-          return "Go down the elevator";
-        }
-        if (step.levelChange.type === "moving walkway") {
-          return "Go down the moving walkway";
-        }
-        if (step.levelChange.type === "incline plane") {
-          return "Go down the incline plane";
-        }
-        return "Go down" + suffix;
-      }
-      if ((_b = step.extras) == null ? void 0 : _b.subwayEntrance) {
-        return `Take exit ${step.extras.subwayEntranceRef}`;
-      }
-    }
-    if (isTurn) {
-      if (direction === "left") {
-        if (directionExtra === "slight") {
-          return "Turn slightly left" + suffix;
-        }
-        return "Turn left" + suffix;
-      }
-      if (direction === "right") {
-        if (directionExtra === "slight") {
-          return "Turn slightly right" + suffix;
-        }
-        return "Turn right" + suffix;
-      }
-    }
-    return "Continue straight";
-  }
-  static getInstructionFromPosition(itineraryInfoManager, position) {
-    const itineraryInfo = itineraryInfoManager.getInfo(position);
-    if (!itineraryInfo) {
-      return null;
-    }
-    if (this.useProposals && itineraryInfo.projection.distanceFromNearestElement > 15) {
-      return "It seems that we are a little bit lost, please start again the localization process";
-    }
-    const { nextStep } = itineraryInfo;
-    if (!nextStep) {
-      return "You are arrived";
-    }
-    const distNextStep = position.distanceTo(nextStep.coords);
-    const distRounded = roundFactor(distNextStep, 5);
-    if (this.useProposals && distNextStep > 10) {
-      return `Continue straight for ${distRounded}m`;
-    }
-    let instruction = _InstructionManager.getInstructionFromStep(nextStep);
-    const stepWithImportantInfo = itineraryInfoManager._steps.find(
-      (step) => step.levelChange && step.number > nextStep.number && step.coords.distanceTo(nextStep.coords) < 10
-    ) || null;
-    if (stepWithImportantInfo && stepWithImportantInfo.levelChange) {
-      const nextBearing = nextStep.coords.bearingTo(stepWithImportantInfo.coords);
-      const { direction } = _InstructionManager.getTurnInfoFromAngle(nextBearing - nextStep.previousBearing);
-      instruction = direction === "straight" ? "Continue straight" : `Turn ${direction}`;
-      const { direction: levelDirection, type: levelType } = stepWithImportantInfo.levelChange;
-      instruction += ` and take the ${levelType} going ${levelDirection}`;
-    }
-    if (distNextStep >= 5) {
-      instruction += ` in ${distRounded}m`;
-    }
-    return instruction;
-  }
-};
-__publicField(_InstructionManager, "useProposals", false);
-let InstructionManager = _InstructionManager;
-class InstructionManagerV1 {
-  // eslint-disable-next-line max-statements, complexity
-  static getInstructionFromStep(step) {
-    var _a;
-    const modifier = OsrmRemoteRouter$1.getModifierFromAngle(step.angle);
-    let direction, directionExtra;
-    if (modifier.includes("left")) {
-      direction = "left";
-    } else if (modifier.includes("right")) {
-      direction = "right";
-    }
-    if (modifier.includes("slight")) {
-      directionExtra = "slight";
-    }
-    const isTurn = modifier !== "straight";
-    if (step.lastStep) {
-      if (isTurn && direction === "left") {
-        return "Your destination is on your left";
-      } else if (isTurn && direction === "right") {
-        return "Your destination is on your right";
-      }
-    }
-    const suffix = step.name ? ` on ${step.name}` : "";
-    if (step.levelChange) {
-      if (step.levelChange.direction === "up") {
-        if (step.levelChange.type === "escalator") {
-          return "Go up the escalator";
-        }
-        if (step.levelChange.type === "stairs") {
-          return "Go up the stairs";
-        }
-        return "Go up" + suffix;
-      }
-      if (step.levelChange.direction === "down") {
-        if (step.levelChange.type === "escalator") {
-          return "Go down the escalator";
-        }
-        if (step.levelChange.type === "stairs") {
-          return "Go down the stairs";
-        }
-        return "Go down" + suffix;
-      }
-      if ((_a = step.extras) == null ? void 0 : _a.subwayEntrance) {
-        return `Take exit ${step.extras.subwayEntranceRef}`;
-      }
-    }
-    if (isTurn) {
-      if (direction === "left") {
-        if (directionExtra === "slight") {
-          return "Turn slightly left" + suffix;
-        }
-        return "Turn left" + suffix;
-      }
-      if (direction === "right") {
-        if (directionExtra === "slight") {
-          return "Turn slightly right" + suffix;
-        }
-        return "Turn right" + suffix;
-      }
-    }
-    return "";
-  }
-  static getInstructionFromPosition(itineraryInfoManager, position) {
-    const itineraryInfo = itineraryInfoManager.getInfo(position);
-    if (!itineraryInfo) {
-      return null;
-    }
-    const { nextStep } = itineraryInfo;
-    if (!nextStep) {
-      return null;
-    }
-    const distNextStep = position.distanceTo(nextStep.coords);
-    const nextStep2 = itineraryInfoManager._steps.find((step) => step.number > nextStep.number);
-    if (distNextStep < 3 && nextStep2) {
-      return InstructionManagerV1.getInstructionFromStep(nextStep2);
-    }
-    return InstructionManagerV1.getInstructionFromStep(nextStep);
-  }
-}
 export {
   CitywayRemoteRouter$1 as CitywayRemoteRouter,
   CustomGraphMap,
@@ -5267,25 +3857,23 @@ export {
   Edge,
   GeoveloRemoteRouter$1 as GeoveloRemoteRouter,
   Graph,
-  GraphProjection,
+  d as GraphProjection,
   GraphRoute,
   GraphRouter,
   GraphRouterOptionsBuilder,
   IdfmRemoteRouter$1 as IdfmRemoteRouter,
-  InstructionManager,
-  InstructionManagerV1,
   Itinerary,
   ItineraryInfoManager,
   Leg,
   NavitiaRemoteRouter$1 as NavitiaRemoteRouter,
   NoRouteFoundError,
   OsmGraphUtils,
-  OsrmRemoteRouter$1 as OsrmRemoteRouter,
+  OsrmRemoteRouter,
   OtpRemoteRouter$1 as OtpRemoteRouter,
   RemoteRouterManager$1 as RemoteRouterManager,
   RemoteRoutingError,
-  RoutingError,
-  StatusCode,
+  e as RoutingError,
+  f as StatusCode,
   Vertex,
   WemapMultiRemoteRouter$1 as WemapMultiRemoteRouter,
   WemapMultiRouter,