@wemap/routers 12.11.3 → 12.11.4

package/dist/OsrmRemoteRouter-e0076e4a.js

@@ -0,0 +1,1214 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { Level, Coordinates, BoundingBox, UserPosition, Constants, Utils } from "@wemap/geo";
+import { diffAngleLines, deg2rad, diffAngle, positiveMod, rad2deg } from "@wemap/maths";
+import Logger from "@wemap/logger";
+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;
+    });
+  }
+}
+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}`);
+  }
+}
+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();
+export {
+  Edge as E,
+  GraphRoute as G,
+  Itinerary as I,
+  Leg as L,
+  OsrmRemoteRouter$1 as O,
+  RemoteRouter as R,
+  StepsBuilder as S,
+  Vertex as V,
+  WemapMultiRoutingError as W,
+  Graph as a,
+  RemoteRoutingError as b,
+  areTransitAndTravelModeConsistent as c,
+  GraphProjection as d,
+  RoutingError as e,
+  StatusCode as f,
+  getDurationFromLength as g,
+  isTransitModePublicTransport as i
+};
+//# sourceMappingURL=OsrmRemoteRouter-e0076e4a.js.map