@wemap/routers 11.0.0-alpha.2 → 11.0.0-alpha.20

package/dist/index.js

@@ -1,68 +1,29 @@
+"use strict";
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import { Coordinates, Level, Utils, Network, GraphRouterOptions, GraphRouter, GraphUtils, NoRouteFoundError, MapMatching, GraphNode, GraphEdge } from "@wemap/geo";
-import { deg2rad, diffAngle, positiveMod, rad2deg } from "@wemap/maths";
-import { OsmNode, OsmWay, OsmParser, OsmNetworkUtils } 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 { polygon } from "@turf/helpers";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const geo = require("@wemap/geo");
+const maths = require("@wemap/maths");
+const salesman = require("@wemap/salesman.js");
+const osm = require("@wemap/osm");
+const Logger = require("@wemap/logger");
+const Polyline = require("@mapbox/polyline");
+const pointInPolygon = require("@turf/boolean-point-in-polygon");
+const convexHullFn = require("@turf/convex");
+const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
+const salesman__default = /* @__PURE__ */ _interopDefaultLegacy(salesman);
+const Logger__default = /* @__PURE__ */ _interopDefaultLegacy(Logger);
+const Polyline__default = /* @__PURE__ */ _interopDefaultLegacy(Polyline);
+const pointInPolygon__default = /* @__PURE__ */ _interopDefaultLegacy(pointInPolygon);
+const convexHullFn__default = /* @__PURE__ */ _interopDefaultLegacy(convexHullFn);
 function getDurationFromLength(length, speed = 5) {
   return length / (speed * 1e3 / 3600);
 }
-function areLevelChangeEquals(l1, l2) {
-  return l1 === l2 || l1.difference === l2.difference && l1.direction === l2.direction && l1.type === l2.type;
-}
-class StepInfo {
-  constructor({
-    coords,
-    distance,
-    name,
-    levelChange,
-    extras,
-    duration
-  }) {
-    __publicField(this, "coords");
-    __publicField(this, "name");
-    __publicField(this, "distance");
-    __publicField(this, "duration");
-    __publicField(this, "levelChange");
-    __publicField(this, "extras");
-    this.coords = coords;
-    this.name = name || null;
-    this.distance = typeof distance === "number" ? distance : null;
-    this.duration = typeof duration === "number" ? duration : null;
-    this.levelChange = levelChange || null;
-    this.extras = extras || null;
-  }
-  static equals(obj1, obj2) {
-    return obj1.coords.equals(obj2.coords) && obj1.distance === obj2.distance && obj1.duration === obj2.duration && obj1.name === obj2.name && (obj1.levelChange === obj2.levelChange || obj1.levelChange && obj2.levelChange && areLevelChangeEquals(obj1.levelChange, obj2.levelChange));
-  }
-  equals(obj) {
-    return StepInfo.equals(this, obj);
-  }
-  toJson() {
-    return {
-      coords: this.coords.toCompressedJson(),
-      ...this.distance !== null && { distance: this.distance },
-      ...this.duration !== null && { duration: this.duration },
-      ...this.name !== null && { name: this.name },
-      ...this.levelChange !== null && { levelChange: this.levelChange },
-      ...this.extras && Object.keys(this.extras).length !== 0 && { extras: this.extras }
-    };
-  }
-  static fromJson(json) {
-    return new StepInfo(Object.assign({}, json, {
-      coords: Coordinates.fromCompressedJson(json.coords)
-    }));
-  }
-}
-const SKIP_STEP_ANGLE_MAX = deg2rad(20);
+const SKIP_STEP_ANGLE_MAX = maths.deg2rad(20);
 function generateSteps(leg, rules) {
   const steps = [];
   const { from, to, coords: coordsArray } = leg;
@@ -72,32 +33,36 @@ function generateSteps(leg, rules) {
     const isFirstStep = i === 0;
     const currentCoords = coordsArray[i];
     const nextCoords = coordsArray[i + 1];
-    const edgeLevel = Level.union(currentCoords.level, nextCoords.level);
+    const edgeLevel = geo.Level.union(currentCoords.level, nextCoords.level);
     const nextBearing = currentCoords.bearingTo(nextCoords);
-    const angle = diffAngle(previousBearing, nextBearing + Math.PI);
-    let splitByAngle = Math.abs(diffAngle(Math.PI, angle)) >= SKIP_STEP_ANGLE_MAX;
-    const splitByLevel = Level.isRange(edgeLevel) && !Level.isRange(currentCoords.level);
-    splitByAngle = splitByAngle && !(currentCoords.level && Level.isRange(currentCoords.level));
-    const customRules = rules == null ? void 0 : rules(currentCoords, nextCoords);
+    const angle = maths.diffAngle(previousBearing, nextBearing + Math.PI);
+    let splitByAngle = Math.abs(maths.diffAngle(Math.PI, angle)) >= SKIP_STEP_ANGLE_MAX;
+    const splitByLevel = geo.Level.isRange(edgeLevel) && !geo.Level.isRange(currentCoords.level);
+    splitByAngle = splitByAngle && !(currentCoords.level && geo.Level.isRange(currentCoords.level));
+    const previousStep = steps.length ? steps[steps.length - 1] : null;
+    const customRules = rules == null ? void 0 : rules(currentCoords, nextCoords, previousStep);
     const splitStepCondition = splitByAngle || splitByLevel || (customRules == null ? void 0 : customRules.createNewStep);
     if (isFirstStep || splitStepCondition) {
       let levelChange;
-      if (splitByLevel) {
-        const difference = Level.diff(currentCoords.level, nextCoords.level);
-        const direction = difference > 0 ? "up" : "down";
+      if (splitByLevel || (customRules == null ? void 0 : customRules.levelChangeType)) {
+        const difference = geo.Level.diff(currentCoords.level, nextCoords.level) || 0;
+        let direction = difference > 0 ? "up" : "down";
+        if (difference === 0 && (customRules == null ? void 0 : customRules.levelChangeDirection)) {
+          direction = customRules.levelChangeDirection;
+        }
         levelChange = { difference, direction, type: customRules == null ? void 0 : customRules.levelChangeType };
       }
       if (currentStep && currentStep.duration === 0) {
-        currentStep.duration = null;
+        delete currentStep.duration;
       }
-      currentStep = new StepInfo({
+      currentStep = {
         coords: currentCoords,
         name: customRules == null ? void 0 : customRules.stepName,
         extras: customRules == null ? void 0 : customRules.stepExtras,
         levelChange,
         distance: 0,
         duration: 0
-      });
+      };
       steps.push(currentStep);
     }
     currentStep.distance += currentCoords.distanceTo(nextCoords);
@@ -107,8 +72,8 @@ function generateSteps(leg, rules) {
     previousBearing = nextBearing;
   }
   const lastCoords = coordsArray[coordsArray.length - 1];
-  if (!Coordinates.equals(lastCoords, to.coords)) {
-    steps.push(new StepInfo({ coords: lastCoords }));
+  if (!geo.Coordinates.equals(lastCoords, to.coords)) {
+    steps.push({ coords: lastCoords });
   }
   return steps;
 }
@@ -124,6 +89,36 @@ function isRoutingModePublicTransport(routingMode) {
     "TRAM"
   ].includes(routingMode);
 }
+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: geo.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 Leg {
   constructor({
     from,
@@ -144,7 +139,7 @@ class Leg {
     __publicField(this, "duration");
     __publicField(this, "startTime");
     __publicField(this, "endTime");
-    __publicField(this, "stepsInfo");
+    __publicField(this, "steps");
     __publicField(this, "transportInfo");
     this.from = {
       name: from.name || null,
@@ -156,22 +151,27 @@ class Leg {
     };
     this.coords = coords;
     this.mode = mode;
-    this.distance = Utils.calcDistance(coords);
+    this.distance = geo.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.stepsInfo = "stepsInfo" in otherParams ? otherParams.stepsInfo : generateSteps(this, otherParams.stepsGenerationRules);
+    if ("steps" in otherParams) {
+      this.steps = otherParams.steps;
+      return;
+    }
+    const minStepsInfo = "minStepsInfo" in otherParams ? otherParams.minStepsInfo : generateSteps(this, otherParams.stepsGenerationRules);
+    this.steps = Leg.generateStepsFromMinStepInfo(from.coords, to.coords, coords, minStepsInfo);
   }
   isPublicTransport() {
     return isRoutingModePublicTransport(this.mode);
   }
-  toNetwork() {
-    return Network.fromCoordinates([this.coords]);
+  toGraph() {
+    return geo.GeoGraph.fromCoordinates([this.coords]);
   }
   static equals(obj1, obj2) {
     var _a, _b;
-    const intermediate = obj1.mode === obj2.mode && obj1.duration === obj2.duration && obj1.startTime === obj2.startTime && obj1.endTime === obj2.endTime && obj1.from.name === obj2.from.name && obj1.from.coords.equals(obj2.from.coords) && obj1.to.name === obj2.to.name && obj1.to.coords.equals(obj2.to.coords) && obj1.coords.length === obj2.coords.length && (obj1.stepsInfo === obj2.stepsInfo || ((_a = obj1.stepsInfo) == null ? void 0 : _a.length) === ((_b = obj2.stepsInfo) == null ? void 0 : _b.length));
+    const intermediate = obj1.mode === obj2.mode && Math.abs(obj1.duration - obj2.duration) <= 0.05 && obj1.startTime === obj2.startTime && obj1.endTime === obj2.endTime && obj1.from.name === obj2.from.name && obj1.from.coords.equals(obj2.from.coords) && obj1.to.name === obj2.to.name && obj1.to.coords.equals(obj2.to.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;
     }
@@ -181,11 +181,9 @@ class Leg {
         return false;
       }
     }
-    if (obj1.stepsInfo && obj2.stepsInfo) {
-      for (i = 0; i < obj1.stepsInfo.length; i++) {
-        if (!obj1.stepsInfo[i].equals(obj2.stepsInfo[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) {
@@ -212,9 +210,9 @@ class Leg {
         coords: this.to.coords.toCompressedJson(),
         ...this.to.name && { name: this.to.name }
       },
-      duration: this.duration,
+      duration: Number(this.duration.toFixed(1)),
       coords: this.coords.map((coords) => coords.toCompressedJson()),
-      steps: this.stepsInfo.map((stepInfo) => stepInfo.toJson()),
+      steps: this.steps.map(stepToJson),
       ...this.startTime !== null && { startTime: this.startTime },
       ...this.endTime !== null && { endTime: this.endTime },
       ...this.transportInfo !== null && { transportInfo: this.transportInfo }
@@ -224,16 +222,15 @@ class Leg {
     var _a;
     const leg = new Leg(Object.assign({}, json, {
       from: {
-        coords: Coordinates.fromCompressedJson(json.from.coords),
+        coords: geo.Coordinates.fromCompressedJson(json.from.coords),
         name: json.from.name || null
       },
       to: {
-        coords: Coordinates.fromCompressedJson(json.to.coords),
+        coords: geo.Coordinates.fromCompressedJson(json.to.coords),
         name: json.to.name || null
       },
-      coords: json.coords.map(Coordinates.fromCompressedJson),
-      stepsInfo: ((_a = json.steps) == null ? void 0 : _a.map(StepInfo.fromJson)) || null,
-      stepsGenerationRules: void 0
+      coords: json.coords.map(geo.Coordinates.fromCompressedJson),
+      steps: ((_a = json.steps) == null ? void 0 : _a.map(jsonToStep)) || null
     }));
     return leg;
   }
@@ -241,24 +238,57 @@ class Leg {
     return new Leg({
       from: { coords: graphItinerary.start },
       to: { coords: graphItinerary.end },
-      coords: graphItinerary.nodes.map((node) => node.coords),
+      coords: graphItinerary.vertices.map((vertex) => vertex.coords),
       duration: graphItinerary.edgesWeights.reduce((acc, weight) => acc + weight, 0),
       mode,
       stepsGenerationRules
     });
   }
   multiplyLevel(levelFactor) {
-    this.from.coords.level = Level.multiplyBy(this.from.coords.level, levelFactor);
-    this.to.coords.level = Level.multiplyBy(this.to.coords.level, levelFactor);
+    this.from.coords.level = geo.Level.multiplyBy(this.from.coords.level, levelFactor);
+    this.to.coords.level = geo.Level.multiplyBy(this.to.coords.level, levelFactor);
     for (const coords of this.coords) {
-      coords.level = Level.multiplyBy(coords.level, levelFactor);
+      coords.level = geo.Level.multiplyBy(coords.level, levelFactor);
     }
-    this.stepsInfo.forEach((step) => {
-      step.coords.level = Level.multiplyBy(step.coords.level, levelFactor);
+    this.steps.forEach((step) => {
+      step.coords.level = geo.Level.multiplyBy(step.coords.level, levelFactor);
     });
   }
-  getSteps(itinerarySteps) {
-    return this.stepsInfo.map((stepInfo) => itinerarySteps.find((_step) => _step.coords.equals(stepInfo.coords)));
+  static generateStepsFromMinStepInfo(from, to, legCoords, stepsInfo) {
+    return stepsInfo.map((stepInfo, stepId) => {
+      const coordsId = legCoords.findIndex((coords) => coords.equals(stepInfo.coords));
+      if (coordsId === -1) {
+        throw new Error("Cannot find step coordinates in itinerary coordinates.");
+      }
+      const coordsBeforeStep = coordsId === 0 ? from : legCoords[coordsId - 1];
+      const coordsAfterStep = coordsId === legCoords.length - 1 ? to : legCoords[coordsId + 1];
+      const previousBearing = coordsBeforeStep.bearingTo(stepInfo.coords);
+      const nextBearing = stepInfo.coords.bearingTo(coordsAfterStep);
+      let distance = 0;
+      const coordsToStopCalculation = stepId !== stepsInfo.length - 1 ? stepsInfo[stepId + 1].coords : legCoords[legCoords.length - 1];
+      let currentCoordsId = coordsId;
+      while (!legCoords[currentCoordsId].equals(coordsToStopCalculation)) {
+        distance += legCoords[currentCoordsId].distanceTo(legCoords[currentCoordsId + 1]);
+        currentCoordsId++;
+      }
+      if (currentCoordsId === legCoords.length - 1) {
+        distance += legCoords[currentCoordsId].distanceTo(to);
+      }
+      return {
+        coords: stepInfo.coords,
+        name: stepInfo.name || null,
+        number: stepId + 1,
+        previousBearing,
+        nextBearing,
+        angle: maths.diffAngle(previousBearing, nextBearing + Math.PI),
+        firstStep: stepId === 0,
+        lastStep: stepId === stepsInfo.length - 1,
+        distance,
+        duration: stepInfo.duration || getDurationFromLength(distance),
+        levelChange: stepInfo.levelChange || null,
+        extras: stepInfo.extras || null
+      };
+    });
   }
 }
 class Itinerary {
@@ -278,7 +308,6 @@ class Itinerary {
     __publicField(this, "startTime");
     __publicField(this, "endTime");
     __publicField(this, "_coords", null);
-    __publicField(this, "_steps", null);
     __publicField(this, "_distance", null);
     this.from = from;
     this.to = to;
@@ -286,6 +315,7 @@ class Itinerary {
     this.duration = typeof duration === "number" ? 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.");
@@ -300,49 +330,7 @@ class Itinerary {
     throw new Error("Itinerary.step cannot be set. They are calculated from Itinerary.legs.");
   }
   get steps() {
-    if (this._steps) {
-      return this._steps;
-    }
-    const itineraryCoords = this.coords.filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equals(coords));
-    const stepsInfo = this.legs.map((leg) => leg.stepsInfo).flat();
-    const steps = stepsInfo.map((stepInfo, stepId) => {
-      const coordsId = itineraryCoords.findIndex((coords) => coords.equals(stepInfo.coords));
-      if (coordsId === -1) {
-        throw new Error("Cannot find step coordinates in itinerary coordinates.");
-      }
-      const coordsBeforeStep = coordsId === 0 ? this.from : itineraryCoords[coordsId - 1];
-      const coordsAfterStep = coordsId === itineraryCoords.length - 1 ? this.to : itineraryCoords[coordsId + 1];
-      const previousBearing = coordsBeforeStep.bearingTo(stepInfo.coords);
-      const nextBearing = stepInfo.coords.bearingTo(coordsAfterStep);
-      let distance = 0;
-      const coordsToStopCalculation = stepId !== stepsInfo.length - 1 ? stepsInfo[stepId + 1].coords : itineraryCoords[itineraryCoords.length - 1];
-      let currentCoordsId = coordsId;
-      while (!itineraryCoords[currentCoordsId].equals(coordsToStopCalculation)) {
-        distance += itineraryCoords[currentCoordsId].distanceTo(itineraryCoords[currentCoordsId + 1]);
-        currentCoordsId++;
-      }
-      if (currentCoordsId === itineraryCoords.length - 1) {
-        distance += itineraryCoords[currentCoordsId].distanceTo(this.to);
-      }
-      return {
-        ...stepInfo,
-        number: stepId + 1,
-        previousBearing,
-        nextBearing,
-        angle: diffAngle(previousBearing, nextBearing + Math.PI),
-        firstStep: stepId === 0,
-        lastStep: stepId === stepsInfo.length - 1,
-        distance,
-        duration: stepInfo.duration || getDurationFromLength(distance),
-        previousStep: null,
-        nextStep: null
-      };
-    });
-    for (let i = 0; i < steps.length; i++) {
-      steps[i].previousStep = i !== 0 ? steps[i - 1] : null;
-      steps[i].nextStep = i !== steps.length - 1 ? steps[i + 1] : null;
-    }
-    return steps;
+    return this.legs.map((leg) => leg.steps).flat();
   }
   set mode(_) {
     throw new Error("Itinerary.mode cannot be set. They are calculated from Itinerary.legs.");
@@ -374,12 +362,12 @@ class Itinerary {
   }
   get distance() {
     if (this._distance === null) {
-      this._distance = Utils.calcDistance(this.coords);
+      this._distance = geo.Utils.calcDistance(this.coords);
     }
     return this._distance;
   }
-  toNetwork() {
-    return Network.fromCoordinates([this.coords]);
+  toGraph() {
+    return geo.GeoGraph.fromCoordinates([this.coords]);
   }
   static fromItineraries(...itineraries) {
     let duration = 0;
@@ -396,7 +384,7 @@ class Itinerary {
     });
   }
   static fromOrderedPointsArray(points, start, end) {
-    const pointToCoordinates = (point) => new Coordinates(point[0], point[1], null, point[2]);
+    const pointToCoordinates = (point) => new geo.Coordinates(point[0], point[1], null, point[2]);
     return this.fromOrderedCoordinates(
       points.map(pointToCoordinates),
       pointToCoordinates(start),
@@ -413,7 +401,7 @@ class Itinerary {
     return new Itinerary({ from, to, legs: [leg] });
   }
   static equals(obj1, obj2) {
-    const intermediate = obj1.from.equals(obj2.from) && obj1.to.equals(obj2.to) && obj1.distance === obj2.distance && obj1.duration === obj2.duration && obj1.startTime === obj2.startTime && obj1.endTime === obj2.endTime && obj1.legs.length === obj2.legs.length;
+    const intermediate = obj1.from.equals(obj2.from) && obj1.to.equals(obj2.to) && 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;
     }
@@ -440,8 +428,8 @@ class Itinerary {
   }
   static fromJson(json) {
     return new Itinerary({
-      from: Coordinates.fromCompressedJson(json.from),
-      to: Coordinates.fromCompressedJson(json.to),
+      from: geo.Coordinates.fromCompressedJson(json.from),
+      to: geo.Coordinates.fromCompressedJson(json.to),
       duration: json.duration,
       legs: json.legs.map(Leg.fromJson),
       startTime: json.startTime,
@@ -458,8 +446,8 @@ class Itinerary {
     });
   }
   multiplyLevel(levelFactor) {
-    this.from.level = Level.multiplyBy(this.from.level, levelFactor);
-    this.to.level = Level.multiplyBy(this.to.level, levelFactor);
+    this.from.level = geo.Level.multiplyBy(this.from.level, levelFactor);
+    this.to.level = geo.Level.multiplyBy(this.to.level, levelFactor);
     this.legs.forEach((leg) => leg.multiplyLevel(levelFactor));
   }
   forceUnknownLevelTo0() {
@@ -471,8 +459,8 @@ class Itinerary {
       for (const coords of leg.coords) {
         coords.level = coords.level || 0;
       }
-      if (leg.stepsInfo) {
-        for (const step of leg.stepsInfo) {
+      if (leg.steps) {
+        for (const step of leg.steps) {
           step.coords.level = step.coords.level || 0;
         }
       }
@@ -493,6 +481,36 @@ class Itinerary {
       }
     };
   }
+  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.from : itineraryCoords[coordsId - 1];
+      const coordsAfterStep = coordsId === itineraryCoords.length - 1 ? this.to : itineraryCoords[coordsId + 1];
+      step.previousBearing = coordsBeforeStep.bearingTo(step.coords);
+      step.nextBearing = step.coords.bearingTo(coordsAfterStep);
+      step.angle = maths.diffAngle(step.previousBearing, step.nextBearing + Math.PI);
+      const stepDistanceBefore = step.distance;
+      step.distance = 0;
+      const coordsToStopCalculation = stepId !== steps.length - 1 ? steps[stepId + 1].coords : itineraryCoords[itineraryCoords.length - 1];
+      let currentCoordsId = coordsId;
+      while (!itineraryCoords[currentCoordsId].equals(coordsToStopCalculation)) {
+        step.distance += itineraryCoords[currentCoordsId].distanceTo(itineraryCoords[currentCoordsId + 1]);
+        currentCoordsId++;
+      }
+      if (currentCoordsId === itineraryCoords.length - 1) {
+        step.distance += itineraryCoords[currentCoordsId].distanceTo(this.to);
+      }
+      step.number = stepId + 1;
+      step.firstStep = stepId === 0;
+      step.lastStep = stepId === steps.length - 1;
+      step.duration += getDurationFromLength(step.distance - stepDistanceBefore);
+    });
+  }
 }
 class RouterResponse {
   constructor({
@@ -541,85 +559,260 @@ class RouterResponse {
     var _a;
     return new RouterResponse({
       routerName: json.routerName,
-      from: Coordinates.fromCompressedJson(json.from),
-      to: Coordinates.fromCompressedJson(json.to),
+      from: geo.Coordinates.fromCompressedJson(json.from),
+      to: geo.Coordinates.fromCompressedJson(json.to),
       itineraries: (_a = json.itineraries) == null ? void 0 : _a.map(Itinerary.fromJson),
       error: json.error
     });
   }
   multiplyLevel(levelFactor) {
-    this.from.level = Level.multiplyBy(this.from.level, levelFactor);
-    this.to.level = Level.multiplyBy(this.to.level, levelFactor);
+    this.from.level = geo.Level.multiplyBy(this.from.level, levelFactor);
+    this.to.level = geo.Level.multiplyBy(this.to.level, levelFactor);
     for (const itinerary of this.itineraries) {
       itinerary.multiplyLevel(levelFactor);
     }
   }
 }
-const _WemapOsmRouterOptions = class extends GraphRouterOptions {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "weightEdgeFn", (edge) => edge.builtFrom instanceof OsmNode && edge.builtFrom.isElevator ? 30 : getDurationFromLength(edge.length));
-  }
-  static get WITHOUT_STAIRS() {
-    const options = new _WemapOsmRouterOptions();
-    options.acceptEdgeFn = (edge) => {
-      var _a;
-      return ((_a = edge.builtFrom) == null ? void 0 : _a.tags.highway) !== "steps";
+const HIGHWAYS_PEDESTRIANS = ["footway", "steps", "pedestrian", "living_street", "path", "track", "sidewalk", "elevator"];
+const DEFAULT_WAY_SELECTOR = (way) => {
+  return HIGHWAYS_PEDESTRIANS.includes(way.tags.highway) || way.tags.footway === "sidewalk" || way.tags.public_transport === "platform" || way.tags.railway === "platform";
+};
+class OsmGraph extends geo.GeoGraph {
+  getVertexByCoords(coords) {
+    return geo.GeoGraph.getVertexByCoords(this.vertices, coords);
+  }
+  getVertexByName(name) {
+    return super.getVertexByName(name);
+  }
+  getEdgeByName(name) {
+    return super.getEdgeByName(name);
+  }
+  static fromOsmModel(osmModel, waySelectionFilter = DEFAULT_WAY_SELECTOR) {
+    const nodes = [];
+    const edges = [];
+    const nodesCreated = {};
+    const elevatorNodes = [];
+    const getOrCreateNode = (osmNode) => {
+      let node = nodesCreated[osmNode.id];
+      if (!node) {
+        node = new geo.GeoGraphVertex(osmNode.coords, { data: osmNode, name: osmNode.tags.name });
+        nodesCreated[osmNode.id] = node;
+        nodes.push(node);
+        if (osmNode.tags.highway === "elevator") {
+          elevatorNodes.push(node);
+        }
+      }
+      return node;
+    };
+    osmModel.ways.forEach((way) => {
+      if (!waySelectionFilter(way)) {
+        return;
+      }
+      let firstNode = getOrCreateNode(way.nodes[0]);
+      for (let i = 1; i < way.nodes.length; i++) {
+        const secondNode = getOrCreateNode(way.nodes[i]);
+        const edge = new geo.GeoGraphEdge(
+          firstNode,
+          secondNode,
+          { data: way, name: way.tags.name, level: way.level }
+        );
+        OsmGraph.manageOneWay(edge, way);
+        edges.push(edge);
+        firstNode = secondNode;
+      }
+    });
+    elevatorNodes.forEach((node) => {
+      OsmGraph.createNodesAndEdgesFromElevator(nodes, edges, node);
+    });
+    return new OsmGraph(nodes, edges, true);
+  }
+  static manageOneWay(edge, way) {
+    const { highway, oneway, conveying } = way.tags;
+    edge.isOneway = Boolean(oneway === "yes" || oneway === "true" || oneway === "1" || conveying && highway && ["forward", "backward"].includes(conveying));
+    if (edge.isOneway && conveying === "backward") {
+      const tmpNode = edge.vertex1;
+      edge.vertex1 = edge.vertex2;
+      edge.vertex2 = tmpNode;
+    }
+  }
+  static createNodesAndEdgesFromElevator(nodes, edges, elevatorNode) {
+    const createdNodes = [];
+    const getOrCreateLevelVertex = (level) => {
+      let levelVertex = createdNodes.find(({ coords }) => geo.Level.equals(level, coords.level));
+      if (!levelVertex) {
+        levelVertex = new geo.GeoGraphVertex(elevatorNode.coords.clone(), {
+          data: elevatorNode.data,
+          name: `${elevatorNode.name} (elevator lvl: ${level})`
+        });
+        levelVertex.coords.level = level;
+        createdNodes.push(levelVertex);
+        nodes.push(levelVertex);
+      }
+      return levelVertex;
     };
-    return options;
+    elevatorNode.edges.forEach((edge) => {
+      if (geo.Level.isRange(edge.level)) {
+        throw new Error("Cannot handle this elevator edge due to ambiguity");
+      }
+      const levelVertex = getOrCreateLevelVertex(edge.level);
+      if (edge.vertex1 === elevatorNode) {
+        edge.vertex1 = levelVertex;
+      } else {
+        edge.vertex2 = levelVertex;
+      }
+      levelVertex.edges.push(edge);
+    });
+    for (let i = 0; i < createdNodes.length; i++) {
+      for (let j = i + 1; j < createdNodes.length; j++) {
+        const createdNode1 = createdNodes[i];
+        const createdNode2 = createdNodes[j];
+        if (createdNode1.coords.level === null || createdNode2.coords.level === null) {
+          continue;
+        }
+        const minLevel = Math.min(createdNode1.coords.level, createdNode2.coords.level);
+        const maxLevel = Math.max(createdNode1.coords.level, createdNode2.coords.level);
+        const newEdge = new geo.GeoGraphEdge(
+          createdNode1,
+          createdNode2,
+          { data: elevatorNode.data, name: elevatorNode.name, level: [minLevel, maxLevel] }
+        );
+        edges.push(newEdge);
+      }
+    }
+    const elevatorNodeIndex = nodes.indexOf(elevatorNode);
+    if (elevatorNodeIndex > -1) {
+      nodes.splice(elevatorNodeIndex, 1);
+    }
   }
-};
-let WemapOsmRouterOptions = _WemapOsmRouterOptions;
-__publicField(WemapOsmRouterOptions, "DEFAULT", new _WemapOsmRouterOptions());
-const buildStepsRules = (graphItinerary) => (currentCoords, nextCoords) => {
+}
+const DEFAULT_OPTIONS = Object.assign({}, geo.GeoGraphRouter.DEFAULT_OPTIONS, {
+  weightEdgeFn: (edge) => edge.data instanceof osm.OsmNode && edge.data.isElevator ? 30 : getDurationFromLength(edge.length)
+});
+const WITHOUT_STAIRS_OPTIONS = Object.assign({}, DEFAULT_OPTIONS, {
+  acceptEdgeFn: (edge) => edge.data.tags.highway !== "steps"
+});
+const buildStepsRules = (graphItinerary) => (currentCoords, nextCoords, previousStep) => {
   var _a, _b, _c, _d, _e;
   const edges = graphItinerary.edges;
-  const nodes = graphItinerary.nodes;
-  const node = GraphUtils.getNodeByCoords(nodes, currentCoords);
-  const nextNode = GraphUtils.getNodeByCoords(nodes, nextCoords);
-  if (!node || !nextNode)
+  const vertices = graphItinerary.vertices;
+  const vertex = geo.GeoGraph.getVertexByCoords(vertices, currentCoords);
+  const nextVertex = geo.GeoGraph.getVertexByCoords(vertices, nextCoords);
+  if (!vertex || !nextVertex)
     return {};
-  const edge = GraphUtils.getEdgeByNodes(edges, node, nextNode);
+  const edge = geo.GeoGraphEdge.getEdgeByVertices(edges, vertex, nextVertex);
   if (!edge)
     return {};
   const edgeId = edges.findIndex((_edge) => _edge === edge);
-  const isSubwayEntrance = node ? ((_a = node.builtFrom) == null ? void 0 : _a.tags.railway) === "subway_entrance" : false;
-  const isGate = node ? ((_b = node.builtFrom) == null ? void 0 : _b.tags.barrier) === "gate" || ((_c = node.builtFrom) == null ? void 0 : _c.tags.aeroway) === "gate" : false;
+  const isSubwayEntrance = vertex ? ((_a = vertex.data) == null ? void 0 : _a.tags.railway) === "subway_entrance" : false;
+  const isGate = vertex ? ((_b = vertex.data) == null ? void 0 : _b.tags.barrier) === "gate" || ((_c = vertex.data) == null ? void 0 : _c.tags.aeroway) === "gate" : false;
   let levelChangeType = null;
-  if (edge.builtFrom instanceof OsmNode && edge.builtFrom.isElevator) {
+  if (edge.data.isElevator) {
     levelChangeType = "elevator";
-  } else if (edge.builtFrom instanceof OsmNode || edge.builtFrom instanceof OsmWay && edge.builtFrom.isConveying) {
+  } else if (edge.data.isConveying) {
     levelChangeType = "conveyor";
-  } else if (edge.builtFrom instanceof OsmWay && edge.builtFrom.areStairs) {
+  } else if (edge.data instanceof osm.OsmWay && edge.data.areStairs) {
     levelChangeType = "stairs";
   }
+  const edgeTags = edge.data.tags || {};
+  let levelChangeDirection = null;
+  if (edge.data instanceof osm.OsmWay && edge.data.areStairs && ["up", "down"].includes(edgeTags.incline) && !(previousStep == null ? void 0 : previousStep.levelChange)) {
+    levelChangeDirection = edgeTags.incline;
+    for (const n of edge.data.nodes) {
+      if (n !== vertex.data)
+        continue;
+    }
+    const isReversed = edge.data.nodes.reduce((acc, n, idx, arr) => {
+      if (n !== vertex.data)
+        return acc;
+      acc = !(idx + 1 < arr.length && arr[idx + 1] === nextVertex.data);
+      return acc;
+    }, null);
+    if (isReversed) {
+      levelChangeDirection = levelChangeDirection === "up" ? "down" : "up";
+    }
+  }
+  const createNewStep = isSubwayEntrance || levelChangeDirection;
   return {
-    createNewStep: isSubwayEntrance,
-    stepName: (_d = edge.builtFrom) == null ? void 0 : _d.tags.name,
+    createNewStep,
+    stepName: (_d = edge.data) == null ? void 0 : _d.tags.name,
     duration: graphItinerary.edgesWeights[edgeId],
     stepExtras: {
       ...isSubwayEntrance && { isSubwayEntrance: true },
-      ...isSubwayEntrance && ((_e = node.builtFrom) == null ? void 0 : _e.tags.ref) && { subwayEntranceRef: node.builtFrom.tags.ref },
+      ...isSubwayEntrance && ((_e = vertex.data) == null ? void 0 : _e.tags.ref) && { subwayEntranceRef: vertex.data.tags.ref },
       ...isGate && { isGate: true }
     },
-    ...levelChangeType && { levelChangeType }
+    ...levelChangeType && { levelChangeType },
+    ...levelChangeDirection && { levelChangeDirection }
   };
 };
-class WemapOsmRouter extends GraphRouter {
-  constructor(network) {
-    super(network);
+class WemapOsmRouter extends geo.GeoGraphRouter {
+  constructor(graph) {
+    super(graph);
   }
   static get rname() {
-    return "wemap";
+    return "wemap-osm";
   }
-  getShortestPath(start, end, options = new WemapOsmRouterOptions()) {
+  getShortestPath(start, end, options = DEFAULT_OPTIONS) {
     return super.getShortestPath(start, end, options);
   }
-  getItinerary(start, end, options = new WemapOsmRouterOptions()) {
+  getItinerary(start, end, options = DEFAULT_OPTIONS) {
     const graphItinerary = this.getShortestPath(start, end, options);
     return Itinerary.fromGraphItinerary(graphItinerary, "WALK", buildStepsRules(graphItinerary));
   }
+  static getTurnInfoFromAngle(_angle) {
+    let direction, directionExtra;
+    const directionAngle = maths.rad2deg(maths.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 };
+  }
+  getShortestTrip(waypoints, options = DEFAULT_OPTIONS) {
+    const points = waypoints.map((waypoint) => {
+      const point = new salesman__default.default.Point(0, 0);
+      point.coords = waypoint;
+      return point;
+    });
+    const cache = [];
+    const solution = salesman__default.default.solve(points, 0.9, void 0, (p, q) => {
+      const osmItinerary = this.getShortestPath(
+        p.coords,
+        q.coords,
+        options
+      );
+      cache.push(osmItinerary);
+      return osmItinerary.edgesWeights.reduce((acc, weight) => acc + weight, 0);
+    });
+    const orderedPoints = solution.map((i) => points[i]);
+    const orderedItineraries = [];
+    for (let i = 0; i < orderedPoints.length - 1; i++) {
+      const p = orderedPoints[i];
+      const q = orderedPoints[i + 1];
+      orderedItineraries.push(
+        cache.find((itinerary) => itinerary.start === p.coords && itinerary.end === q.coords || itinerary.end === p.coords && itinerary.start === q.coords)
+      );
+    }
+    return orderedItineraries;
+  }
+  getTripItinerary(waypoints, options = DEFAULT_OPTIONS) {
+    const shortestTrip = this.getShortestTrip(waypoints, options);
+    return new Itinerary({
+      from: shortestTrip[0].start,
+      to: shortestTrip[shortestTrip.length - 1].end,
+      legs: shortestTrip.map((graphItinerary) => Leg.fromGraphItinerary(graphItinerary))
+    });
+  }
 }
+__publicField(WemapOsmRouter, "DEFAULT_OPTIONS", DEFAULT_OPTIONS);
+__publicField(WemapOsmRouter, "WITHOUT_STAIRS_OPTIONS", WITHOUT_STAIRS_OPTIONS);
 class RemoteRouter {
 }
 class RemoteRouterServerUnreachable extends Error {
@@ -643,10 +836,10 @@ function dateWithTimeZone(year, month, day, hour, minute, second, timeZone = "Eu
   return date;
 }
 function isRoutingError(e) {
-  return e instanceof RemoteRouterServerUnreachable || e instanceof RoutingModeCorrespondanceNotFound || e instanceof NoRouteFoundError;
+  return e instanceof RemoteRouterServerUnreachable || e instanceof RoutingModeCorrespondanceNotFound || e instanceof geo.NoRouteFoundError;
 }
 function jsonToCoordinates$2(json) {
-  return new Coordinates(json.Lat, json.Long);
+  return new geo.Coordinates(json.Lat, json.Long);
 }
 function jsonDateToTimestamp(jsonDate) {
   const [dateStr, timeStr] = jsonDate.split(" ");
@@ -711,11 +904,11 @@ function parseWKTGeometry(wktGeometry) {
   const tmpCoordsPt = wktGeometry.match(/POINT ?\((.*)\)/i);
   if (tmpCoordsPt) {
     const [lng, lat] = tmpCoordsPt[1].split(" ");
-    return [new Coordinates(Number(lat), Number(lng))];
+    return [new geo.Coordinates(Number(lat), Number(lng))];
   }
   return tmpCoordsStr[1].split(",").map((str) => {
     const sp = str.trim().split(" ");
-    return new Coordinates(Number(sp[1]), Number(sp[0]));
+    return new geo.Coordinates(Number(sp[1]), Number(sp[0]));
   });
 }
 class CitywayRemoteRouter extends RemoteRouter {
@@ -738,7 +931,7 @@ class CitywayRemoteRouter extends RemoteRouter {
       throw new RoutingModeCorrespondanceNotFound(this.rname, mode);
     }
     if (waypoints.length > 2) {
-      Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+      Logger__default.default.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
     }
     const fromPlace = `DepartureLatitude=${waypoints[0].latitude}&DepartureLongitude=${waypoints[0].longitude}`;
     const toPlace = `ArrivalLatitude=${waypoints[1].latitude}&ArrivalLongitude=${waypoints[1].longitude}`;
@@ -771,7 +964,7 @@ class CitywayRemoteRouter extends RemoteRouter {
           const legCoords = [];
           let legFrom, legTo;
           let transportInfo;
-          let stepsInfo;
+          let minStepsInfo;
           if (legMode === "UNKNOWN") {
             continue itineraryLoop;
           }
@@ -784,7 +977,7 @@ class CitywayRemoteRouter extends RemoteRouter {
               name: jsonLeg.Arrival.Site.Name,
               coords: jsonToCoordinates$2(jsonLeg.Arrival.Site.Position)
             };
-            stepsInfo = [];
+            minStepsInfo = [];
             for (const jsonPathLink of jsonLeg.pathLinks.PathLink) {
               let stepCoords;
               if (jsonPathLink.Geometry && jsonPathLink.Geometry !== "Null") {
@@ -797,11 +990,11 @@ class CitywayRemoteRouter extends RemoteRouter {
                   legCoords.push(coords);
                 }
               });
-              stepsInfo.push(new StepInfo({
+              minStepsInfo.push({
                 coords: stepCoords[0],
                 distance: jsonPathLink.Distance,
                 name: jsonPathLink.Departure.Site.Name
-              }));
+              });
             }
           } else if (isRoutingModePublicTransport(legMode)) {
             legFrom = {
@@ -830,13 +1023,13 @@ class CitywayRemoteRouter extends RemoteRouter {
                 }
               });
             }
-            stepsInfo = [new StepInfo({
+            minStepsInfo = [{
               coords: legCoords[0],
               name: jsonLeg.Line.Name,
               distance: jsonLeg.Distance
-            })];
+            }];
           } else {
-            Logger.warn(`[CitywayParser] Unknown leg mode: ${jsonLeg.TransportMode}`);
+            Logger__default.default.warn(`[CitywayParser] Unknown leg mode: ${jsonLeg.TransportMode}`);
             continue;
           }
           const leg = new Leg({
@@ -847,7 +1040,8 @@ class CitywayRemoteRouter extends RemoteRouter {
             coords: legCoords,
             from: legFrom,
             to: legTo,
-            transportInfo
+            transportInfo,
+            minStepsInfo
           });
           legs.push(leg);
         }
@@ -895,7 +1089,7 @@ class DeutscheBahnRemoteRouter extends RemoteRouter {
     let url = endpointUrl + "/route/v1/walking/";
     url += waypoints.map((waypoint) => {
       if (waypoint.level !== null) {
-        const altitude = Level.isRange(waypoint.level) ? waypoint.level[0] : waypoint.level;
+        const altitude = geo.Level.isRange(waypoint.level) ? waypoint.level[0] : waypoint.level;
         return waypoint.longitude + "," + waypoint.latitude + "," + altitude;
       }
       return waypoint.longitude + "," + waypoint.latitude;
@@ -909,9 +1103,9 @@ class DeutscheBahnRemoteRouter extends RemoteRouter {
       return routerResponse;
     }
     const legs = json.segments.map((segment) => {
-      const level = Level.union(segment.fromLevel, segment.toLevel);
+      const level = geo.Level.union(segment.fromLevel, segment.toLevel);
       const coords = segment.polyline.map(
-        ({ lon, lat }) => new Coordinates(lat, lon, null, level)
+        ({ lon, lat }) => new geo.Coordinates(lat, lon, null, level)
       );
       return new Leg({
         mode: "WALK",
@@ -968,7 +1162,7 @@ const TRANSPORT_IDS = [
 ];
 const apiKey = "qWHj6ax6DMttG8DX6tH9CQARaiTgQ1Di";
 function jsonToCoordinates$1(json) {
-  return new Coordinates(Number(json.lat), Number(json.lon));
+  return new geo.Coordinates(Number(json.lat), Number(json.lon));
 }
 function last(array) {
   return array[array.length - 1];
@@ -1017,7 +1211,7 @@ class IdfmRemoteRouter extends RemoteRouter {
   }
   getURL(endpointUrl, mode, waypoints) {
     if (waypoints.length > 2) {
-      Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+      Logger__default.default.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
     }
     const fromPlace = `from=${waypoints[0].longitude};${waypoints[0].latitude}`;
     const toPlace = `to=${waypoints[1].longitude};${waypoints[1].latitude}`;
@@ -1082,7 +1276,7 @@ class IdfmRemoteRouter extends RemoteRouter {
         newCoords = duplicatedCoords[0];
         coords[_idCoordsInLeg] = newCoords;
       } else {
-        const result = Utils.trimRoute(duplicatedCoords, duplicatedCoords[0], previousStep.distance);
+        const result = geo.Utils.trimRoute(duplicatedCoords, duplicatedCoords[0], previousStep.distance);
         accumulatedIndex += result.length - 1;
         duplicatedCoords.splice(0, result.length - 1);
         _idCoordsInLeg = accumulatedIndex;
@@ -1098,7 +1292,6 @@ class IdfmRemoteRouter extends RemoteRouter {
     return outputSteps;
   }
   createRouterResponseFromJson(json, from, to) {
-    var _a;
     const routerResponse = new RouterResponse({ routerName: this.rname, from, to });
     if (!json || !json.journeys) {
       return routerResponse;
@@ -1115,11 +1308,13 @@ class IdfmRemoteRouter extends RemoteRouter {
         const legCoords = jsonSection.geojson.coordinates.reduce((acc, [lon, lat]) => {
           if (!existingCoords.includes(`${lon}-${lat}`)) {
             existingCoords = existingCoords.concat(`${lon}-${lat}`);
-            acc.push(new Coordinates(lat, lon));
+            acc.push(new geo.Coordinates(lat, lon));
           }
           return acc;
         }, []);
-        let stepsInfo;
+        let minStepsInfo;
+        let transportInfo;
+        let mode = routingModeCorrespondance.get(jsonSection.mode);
         if (jsonSection.path) {
           const idfmIntermediateSteps = [];
           for (const jsonPathLink of jsonSection.path) {
@@ -1128,10 +1323,25 @@ class IdfmRemoteRouter extends RemoteRouter {
               distance: jsonPathLink.length
             });
           }
-          stepsInfo = this.findStepsCoord(legCoords, idfmIntermediateSteps);
+          minStepsInfo = this.findStepsCoord(legCoords, idfmIntermediateSteps);
+        }
+        if (jsonSection.type === "public_transport") {
+          transportInfo = {
+            name: jsonSection.display_informations.code,
+            routeColor: jsonSection.display_informations.color,
+            routeTextColor: jsonSection.display_informations.text_color,
+            directionName: jsonSection.display_informations.direction
+          };
+          mode = routingModeCorrespondance.get(jsonSection.display_informations.physical_mode);
+          const legStep = {
+            coords: legCoords[0],
+            name: transportInfo.directionName,
+            distance: jsonSection.geojson.properties[0].length
+          };
+          minStepsInfo = [legStep];
         }
         const leg = new Leg({
-          mode: routingModeCorrespondance.get(jsonSection.mode),
+          mode,
           duration: jsonSection.duration,
           startTime: dateStringToTimestamp(jsonSection.departure_date_time, timeZone),
           endTime: dateStringToTimestamp(jsonSection.arrival_date_time, timeZone),
@@ -1144,23 +1354,9 @@ class IdfmRemoteRouter extends RemoteRouter {
             coords: toSection
           },
           coords: legCoords,
-          stepsInfo
+          transportInfo,
+          minStepsInfo
         });
-        if (jsonSection.type === "public_transport") {
-          leg.transportInfo = {
-            name: jsonSection.display_informations.code,
-            routeColor: jsonSection.display_informations.color,
-            routeTextColor: jsonSection.display_informations.text_color,
-            directionName: jsonSection.display_informations.direction
-          };
-          leg.mode = routingModeCorrespondance.get(jsonSection.display_informations.physical_mode);
-          const legStep = new StepInfo({
-            coords: leg.coords[0],
-            name: (_a = leg.transportInfo) == null ? void 0 : _a.directionName,
-            distance: jsonSection.geojson.properties[0].length
-          });
-          leg.stepsInfo = [legStep];
-        }
         legs.push(leg);
       }
       const itinerary = new Itinerary({
@@ -1213,20 +1409,20 @@ class OsrmRemoteRouter extends RemoteRouter {
     if (level === null) {
       return [lng, lat];
     }
-    if (Level.isRange(level)) {
+    if (geo.Level.isRange(level)) {
       return [lng, lat, level[0]];
     }
     return [lng, lat, level];
   }
   jsonToCoordinates(json) {
-    const coords = new Coordinates(json[1], json[0]);
+    const coords = new geo.Coordinates(json[1], json[0]);
     if (json.length > 2) {
       coords.level = json[2];
     }
     return coords;
   }
   getModifierFromAngle(_angle) {
-    const angle = positiveMod(rad2deg(_angle), 360);
+    const angle = maths.positiveMod(maths.rad2deg(_angle), 360);
     if (angle > 0 && angle < 60) {
       return "sharp right";
     }
@@ -1281,8 +1477,8 @@ class OsrmRemoteRouter extends RemoteRouter {
             duration: step.duration || 0,
             ...step.name && { name: step.name },
             maneuver: {
-              bearing_before: rad2deg(step.previousBearing),
-              bearing_after: rad2deg(step.nextBearing),
+              bearing_before: maths.rad2deg(step.previousBearing),
+              bearing_after: maths.rad2deg(step.nextBearing),
               location: this.coordinatesToJson(step.coords),
               modifier: this.getModifierFromAngle(step.angle),
               type
@@ -1325,19 +1521,19 @@ class OsrmRemoteRouter extends RemoteRouter {
       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 stepsInfo = (_a = jsonLeg.steps) == null ? void 0 : _a.map(({ maneuver, name, distance, duration }) => {
+        const minStepsInfo = (_a = jsonLeg.steps) == null ? void 0 : _a.map(({ 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");
           }
-          return new StepInfo({
+          return {
             coords: stepCoords,
             name,
             distance,
             duration
-          });
+          };
         });
         return new Leg({
           mode,
@@ -1349,7 +1545,7 @@ class OsrmRemoteRouter extends RemoteRouter {
           to: {
             coords: legCoords[legCoords.length - 1]
           },
-          stepsInfo
+          minStepsInfo
         });
       });
       return new Itinerary({
@@ -1367,7 +1563,7 @@ function isLegPT(leg) {
   return leg.mode === "BUS" || leg.mode === "TRAM";
 }
 function jsonToCoordinates(json) {
-  return new Coordinates(json.lat, json.lon);
+  return new geo.Coordinates(json.lat, json.lon);
 }
 const inputModeCorrespondance = /* @__PURE__ */ new Map();
 inputModeCorrespondance.set("CAR", "CAR");
@@ -1395,7 +1591,7 @@ class OtpRemoteRouter extends RemoteRouter {
       throw new RoutingModeCorrespondanceNotFound(this.rname, mode);
     }
     if (waypoints.length > 2) {
-      Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+      Logger__default.default.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
     }
     const fromPlace = `fromPlace=${waypoints[0].latitude},${waypoints[0].longitude}`;
     const toPlace = `toPlace=${waypoints[1].latitude},${waypoints[1].longitude}`;
@@ -1416,9 +1612,9 @@ class OtpRemoteRouter extends RemoteRouter {
     for (const jsonItinerary of jsonPlan.itineraries) {
       const legs = [];
       for (const jsonLeg of jsonItinerary.legs) {
-        const legCoords = Polyline.decode(jsonLeg.legGeometry.points).map(([lat, lon]) => new Coordinates(lat, lon));
+        const legCoords = Polyline__default.default.decode(jsonLeg.legGeometry.points).map(([lat, lon]) => new geo.Coordinates(lat, lon));
         let transportInfo;
-        let stepsInfo;
+        let minStepsInfo;
         if (isLegPT(jsonLeg)) {
           transportInfo = {
             name: jsonLeg.routeShortName,
@@ -1426,21 +1622,21 @@ class OtpRemoteRouter extends RemoteRouter {
             routeTextColor: jsonLeg.routeTextColor,
             directionName: jsonLeg.headsign
           };
-          stepsInfo = [new StepInfo({
+          minStepsInfo = [{
             coords: legCoords[0],
             name: jsonLeg.headsign
-          })];
+          }];
         } else {
-          stepsInfo = jsonLeg.steps.map((jsonStep) => {
+          minStepsInfo = jsonLeg.steps.map((jsonStep) => {
             const distances = legCoords.map((coords) => coords.distanceTo(jsonToCoordinates(jsonStep)));
             const idStepCoordsInLeg = distances.indexOf(Math.min(...distances));
             if (idStepCoordsInLeg < 0) {
               throw new Error("OTP Parser: Cannot find closest step");
             }
-            return new StepInfo({
+            return {
               coords: legCoords[idStepCoordsInLeg],
               name: jsonStep.streetName
-            });
+            };
           });
         }
         const leg = new Leg({
@@ -1458,7 +1654,7 @@ class OtpRemoteRouter extends RemoteRouter {
           },
           coords: legCoords,
           transportInfo,
-          stepsInfo
+          minStepsInfo
         });
         legs.push(leg);
       }
@@ -1491,7 +1687,7 @@ class WemapMultiRemoteRouterPayload {
   }
   static fromJson(json) {
     return new WemapMultiRemoteRouterPayload(
-      json.waypoints.map(Coordinates.fromCompressedJson),
+      json.waypoints.map(geo.Coordinates.fromCompressedJson),
       json.mode,
       json.options
     );
@@ -1499,7 +1695,7 @@ class WemapMultiRemoteRouterPayload {
 }
 class WemapMultiRemoteRouter extends RemoteRouter {
   get rname() {
-    return "wemap-meta";
+    return "wemap-multi";
   }
   async getItineraries(endpointUrl, mode, waypoints, options) {
     const payload = new WemapMultiRemoteRouterPayload(
@@ -1524,19 +1720,17 @@ class WemapMultiRemoteRouter extends RemoteRouter {
   }
 }
 const WemapMultiRemoteRouter$1 = new WemapMultiRemoteRouter();
+const remoteRouters = [
+  CitywayRemoteRouter$1,
+  DeutscheBahnRemoteRouter$1,
+  IdfmRemoteRouter$1,
+  OsrmRemoteRouter$1,
+  OtpRemoteRouter$1,
+  WemapMultiRemoteRouter$1
+];
 class RemoteRouterManager {
-  constructor() {
-    __publicField(this, "remoteRouters", [
-      CitywayRemoteRouter$1,
-      DeutscheBahnRemoteRouter$1,
-      IdfmRemoteRouter$1,
-      OsrmRemoteRouter$1,
-      OtpRemoteRouter$1,
-      WemapMultiRemoteRouter$1
-    ]);
-  }
   getRouterByName(name) {
-    return this.remoteRouters.find((remoteRouter) => remoteRouter.rname === name);
+    return remoteRouters.find((remoteRouter) => remoteRouter.rname === name);
   }
   async getItineraries(name, endpointUrl, mode, waypoints, options) {
     const router = this.getRouterByName(name);
@@ -1545,9 +1739,9 @@ class RemoteRouterManager {
     }
     return router.getItineraries(endpointUrl, mode, waypoints, options);
   }
-  async getItinerariesWithFallback(remoteRouters, mode, waypoints, options) {
+  async getItinerariesWithFallback(remoteRouters2, mode, waypoints, options) {
     let routerResponse;
-    for (const { name, endpointUrl } of remoteRouters) {
+    for (const { name, endpointUrl } of remoteRouters2) {
       routerResponse = await this.getItineraries(name, endpointUrl, mode, waypoints, options);
       if (routerResponse.itineraries.length) {
         return routerResponse;
@@ -1555,7 +1749,7 @@ class RemoteRouterManager {
     }
     if (!routerResponse) {
       routerResponse = new RouterResponse({
-        routerName: remoteRouters.map((rr) => rr.name),
+        routerName: remoteRouters2.map((rr) => rr.name),
         from: waypoints[0],
         to: waypoints[waypoints.length]
       });
@@ -1570,7 +1764,7 @@ class WemapMultiRouter {
     __publicField(this, "maps", []);
   }
   get rname() {
-    return "wemap-meta";
+    return "wemap-multi";
   }
   addIOMap(customNetworkMap) {
     this.maps.push(customNetworkMap);
@@ -1578,10 +1772,10 @@ class WemapMultiRouter {
   removeIOMap(customNetworkMap) {
     this.maps = this.maps.filter((map) => map !== customNetworkMap);
   }
-  async getItineraries(mode, waypoints, options) {
+  async getItineraries(mode, waypoints, options = null) {
     var _a;
     if (waypoints.length > 2) {
-      Logger.warn(`WemapMultiRouter uses only the first 2 waypoints (asked ${waypoints.length})`);
+      Logger__default.default.warn(`WemapMultiRouter uses only the first 2 waypoints (asked ${waypoints.length})`);
     }
     const start = waypoints[0];
     const end = waypoints[1];
@@ -1590,22 +1784,22 @@ class WemapMultiRouter {
       from: start,
       to: end
     });
-    const remoteRouters = ((_a = options.remoteRouters) == null ? void 0 : _a.filter(({ name }) => name !== WemapMultiRemoteRouter$1.rname)) || [];
+    const remoteRouters2 = ((_a = options == null ? void 0 : options.remoteRouters) == null ? void 0 : _a.filter(({ name }) => name !== WemapMultiRemoteRouter$1.rname)) || [];
     let ioMapsToTest = this.maps;
-    const { targetMaps } = options;
+    const targetMaps = options == null ? void 0 : options.targetMaps;
     if (targetMaps) {
       ioMapsToTest = this.maps.filter((map) => map.name && targetMaps.includes(map.name));
       if (ioMapsToTest.length !== targetMaps.length) {
         ioMapsToTest.forEach((map) => {
           if (map.name && !targetMaps.includes(map.name)) {
-            Logger.warn(`CustomNetworkMap "${map.name}" not found in WemapMultiRouter`);
+            Logger__default.default.warn(`CustomNetworkMap "${map.name}" not found in WemapMultiRouter`);
           }
         });
       }
     }
     if (!ioMapsToTest.length) {
       try {
-        return await RemoteRouterManager$1.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+        return await RemoteRouterManager$1.getItinerariesWithFallback(remoteRouters2, mode, waypoints);
       } catch (e) {
         if (!isRoutingError(e)) {
           throw e;
@@ -1616,7 +1810,7 @@ class WemapMultiRouter {
     }
     let ioMapItinerary;
     const mapWithStart = ioMapsToTest.find((map) => map.isPointInside(start));
-    const wemapOsmRouterOptions = !("useStairs" in options) && options.useStairs ? WemapOsmRouterOptions.DEFAULT : WemapOsmRouterOptions.WITHOUT_STAIRS;
+    const wemapOsmRouterOptions = !options || !("useStairs" in options) || options.useStairs ? WemapOsmRouter.DEFAULT_OPTIONS : WemapOsmRouter.WITHOUT_STAIRS_OPTIONS;
     if (mapWithStart && mapWithStart.isPointInside(end)) {
       try {
         ioMapItinerary = mapWithStart.getItineraryInsideMap(start, end, wemapOsmRouterOptions);
@@ -1635,7 +1829,7 @@ class WemapMultiRouter {
     let remoteRouterResponse;
     if (!mapWithStart && !mapWithEnd) {
       try {
-        return await RemoteRouterManager$1.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+        return await RemoteRouterManager$1.getItinerariesWithFallback(remoteRouters2, mode, waypoints);
       } catch (e) {
         if (!isRoutingError(e)) {
           throw e;
@@ -1653,18 +1847,18 @@ class WemapMultiRouter {
       try {
         ioMapItinerary = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapOsmRouterOptions);
         remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
-          remoteRouters,
+          remoteRouters2,
           mode,
           [ioMapItinerary.to, end]
         );
         if (!remoteRouterResponse.itineraries.length) {
-          throw new NoRouteFoundError(ioMapItinerary.to, end, remoteRouterResponse.error);
+          throw new geo.NoRouteFoundError(ioMapItinerary.to, end, remoteRouterResponse.error);
         }
       } catch (e) {
         if (!isRoutingError(e)) {
           throw e;
         }
-        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" using wemap router on local map "${mapWithStart.name}" and an itinerary from  "entrypoints" to "end" using remote routers (${remoteRouters.map((r) => r.name).join(", ")}), but failed. Details: ${e.message}.`;
+        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" using wemap router on local map "${mapWithStart.name}" and an itinerary from  "entrypoints" to "end" using remote routers (${remoteRouters2.map((r) => r.name).join(", ")}), but failed. Details: ${e.message}.`;
         return routerResponse;
       }
       routerResponse.itineraries = remoteRouterResponse.itineraries.map(
@@ -1682,18 +1876,18 @@ class WemapMultiRouter {
       try {
         ioMapItinerary = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapOsmRouterOptions);
         remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
-          remoteRouters,
+          remoteRouters2,
           mode,
           [start, ioMapItinerary.from]
         );
         if (!remoteRouterResponse.itineraries.length) {
-          throw new NoRouteFoundError(start, ioMapItinerary.from, remoteRouterResponse.error);
+          throw new geo.NoRouteFoundError(start, ioMapItinerary.from, remoteRouterResponse.error);
         }
       } catch (e) {
         if (!isRoutingError(e)) {
           throw e;
         }
-        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" using remote routers (${remoteRouters.map((r) => r.name).join(", ")}) and an itinerary from "entrypoints" to "end" using wemap router on local map "${mapWithEnd.name}", but failed. Details: ${e.message}.`;
+        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" using remote routers (${remoteRouters2.map((r) => r.name).join(", ")}) and an itinerary from "entrypoints" to "end" using wemap router on local map "${mapWithEnd.name}", but failed. Details: ${e.message}.`;
         return routerResponse;
       }
       routerResponse.itineraries = remoteRouterResponse.itineraries.map(
@@ -1720,18 +1914,18 @@ class WemapMultiRouter {
         ioMapItinerary1 = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapOsmRouterOptions);
         ioMapItinerary2 = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapOsmRouterOptions);
         remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
-          remoteRouters,
+          remoteRouters2,
           mode,
           [ioMapItinerary1.to, ioMapItinerary2.from]
         );
         if (!remoteRouterResponse.itineraries.length) {
-          throw new NoRouteFoundError(ioMapItinerary1.to, ioMapItinerary2.from, remoteRouterResponse.error);
+          throw new geo.NoRouteFoundError(ioMapItinerary1.to, ioMapItinerary2.from, remoteRouterResponse.error);
         }
       } catch (e) {
         if (!isRoutingError(e)) {
           throw e;
         }
-        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints1" using wemap router on local map  "${mapWithStart.name}", an itinerary from "entrypoints1" to "entrypoints2" using remote routers (${remoteRouters.map((r) => r.name).join(", ")}) and an itinerary from "entrypoints2" to "end" using wemap router on local map "${mapWithEnd.name}", but failed. Details: ${e.message}.`;
+        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints1" using wemap router on local map  "${mapWithStart.name}", an itinerary from "entrypoints1" to "entrypoints2" using remote routers (${remoteRouters2.map((r) => r.name).join(", ")}) and an itinerary from "entrypoints2" to "end" using wemap router on local map "${mapWithEnd.name}", but failed. Details: ${e.message}.`;
         return routerResponse;
       }
       routerResponse.itineraries = remoteRouterResponse.itineraries.map(
@@ -1748,49 +1942,66 @@ class WemapMultiRouter {
   }
 }
 class CustomNetworkMap {
-  constructor(network, entryPoints, bounds = null, name = null) {
+  constructor(graph, entryPoints, bounds = null, name = null) {
     __publicField(this, "name");
-    __publicField(this, "network");
+    __publicField(this, "graph");
     __publicField(this, "router");
     __publicField(this, "bounds");
     __publicField(this, "entryPoints");
     __publicField(this, "disabledWays", /* @__PURE__ */ new Set());
     this.name = name;
-    this.network = network;
-    this.router = new WemapOsmRouter(network);
+    this.graph = graph;
+    this.router = new WemapOsmRouter(graph);
     entryPoints.forEach((entryPoint) => {
-      if (!network.nodes.includes(entryPoint)) {
+      if (!graph.vertices.includes(entryPoint)) {
         throw new Error(`Cannot find entry point ${entryPoint.coords.toString()} in network "${name}"`);
       }
     });
     this.entryPoints = entryPoints;
     if (bounds) {
-      this.bounds = polygon([bounds.map((coords) => [coords.lng, coords.lat])]);
+      this.bounds = bounds;
     } else {
-      const polygon2 = [network.nodes.map((node) => [node.coords.lng, node.coords.lat])];
-      const convexHull = convexHullFn({ type: "polygon", coordinates: polygon2 });
+      const polygon = [graph.vertices.map((vertex) => [vertex.coords.lng, vertex.coords.lat])];
+      const convexHull = convexHullFn__default.default({ type: "polygon", coordinates: polygon });
       if (!convexHull) {
         throw new Error(`Cannot calculate convexHull of network "${name}"`);
       }
-      this.bounds = convexHull;
+      this.bounds = {
+        type: "MultiPolygon",
+        coordinates: [convexHull.geometry.coordinates]
+      };
     }
   }
   static fromOsmXml(osmXmlString, name = null) {
-    const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-    const network = OsmNetworkUtils.createNetworkFromOsmModel(osmModel);
-    const entryPoints = osmModel.nodes.filter(({ tags }) => tags && tags["wemap:routing-io"]).map((osmNode) => network.getNodeByCoords(osmNode.coords));
+    const osmModel = osm.OsmParser.parseOsmXmlString(osmXmlString);
+    const graph = OsmGraph.fromOsmModel(osmModel);
+    const entryPoints = graph.vertices.filter(({ data: { tags } }) => tags && tags["wemap:routing-io"]);
     if (entryPoints.some((el) => el === null) || new Set(entryPoints).size !== entryPoints.length) {
       throw new Error("Cannot parse wemap:routing-io correctly");
     }
-    const wayBounds = osmModel.ways.find(({ tags }) => tags["wemap:routing-bounds"]);
-    if (!wayBounds) {
+    const bounds = {
+      type: "MultiPolygon",
+      coordinates: []
+    };
+    osmModel.ways.filter(({ tags }) => tags["wemap:routing-bounds"]).forEach((way) => {
+      bounds.coordinates.push([
+        way.nodes.reduce((acc, node) => {
+          acc.push([node.coords.lng, node.coords.lat]);
+          return acc;
+        }, [])
+      ]);
+    });
+    osmModel.relations.filter((rel) => rel.tags["wemap:routing-bounds"] && rel.isMultipolygon()).forEach((rel) => {
+      const polygon = rel.getGeoJsonPolygon();
+      polygon && bounds.coordinates.push(polygon.coordinates);
+    });
+    if (!bounds.coordinates.length) {
       throw new Error('Search bounds is undefined. Please use OSM tag : "wemap:routing-bounds=yes"');
     }
-    const bounds = wayBounds.nodes.map((node) => node.coords);
-    return new CustomNetworkMap(network, entryPoints, bounds, name);
+    return new CustomNetworkMap(graph, entryPoints, bounds, name);
   }
   isPointInside(coordinates) {
-    return pointInPolygon([coordinates.lng, coordinates.lat], this.bounds);
+    return pointInPolygon__default.default([coordinates.lng, coordinates.lat], this.bounds);
   }
   getOrderedEntryPointsSortedByDistance(start, end) {
     const entryPointsCopy = [...this.entryPoints];
@@ -1806,7 +2017,7 @@ class CustomNetworkMap {
         return itinerary;
       }
     }
-    throw new NoRouteFoundError(
+    throw new geo.NoRouteFoundError(
       start,
       end,
       `No route found from entry points to ${end.toString()} in map: ${this.name}`
@@ -1820,7 +2031,7 @@ class CustomNetworkMap {
         return itinerary;
       }
     }
-    throw new NoRouteFoundError(
+    throw new geo.NoRouteFoundError(
       start,
       end,
       `No route found from ${start.toString()} to entry points in map: ${this.name}`
@@ -1830,44 +2041,18 @@ class CustomNetworkMap {
     return this.router.getItinerary(start, end, options);
   }
   enableWay(osmId) {
-    this.network.edges.filter((edge) => {
-      var _a;
-      return ((_a = edge.builtFrom) == null ? void 0 : _a.id) === osmId;
-    }).forEach((e) => this.router.disabledEdges.delete(e));
+    this.graph.edges.filter((edge) => edge.data.id === osmId).forEach((e) => this.router.disabledEdges.delete(e));
     this.disabledWays.delete(osmId);
   }
   disableWay(osmId) {
-    this.network.edges.filter((edge) => {
-      var _a;
-      return ((_a = edge.builtFrom) == null ? void 0 : _a.id) === osmId;
-    }).forEach((e) => this.router.disabledEdges.add(e));
+    this.graph.edges.filter((edge) => edge.data.id === osmId).forEach((e) => this.router.disabledEdges.add(e));
     this.disabledWays.add(osmId);
   }
 }
-function 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 };
-}
-const WemapOsmRouterUtils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  getTurnInfoFromAngle
-}, Symbol.toStringTag, { value: "Module" }));
 class ItineraryInfoManager {
   constructor(itinerary = null) {
     __publicField(this, "_itinerary", null);
-    __publicField(this, "_mapMatching", null);
+    __publicField(this, "_geoGraphProjectionHandler", null);
     __publicField(this, "_steps", []);
     __publicField(this, "_coordsNextStep", []);
     __publicField(this, "_coordsPreviousStep", []);
@@ -1885,8 +2070,8 @@ class ItineraryInfoManager {
     }
     this._itinerary = itinerary;
     this._steps = itinerary.steps;
-    const network = itinerary.toNetwork();
-    this._mapMatching = new MapMatching(network);
+    const graph = itinerary.toGraph();
+    this._geoGraphProjectionHandler = new geo.GeoGraphProjectionHandler(graph);
     this._coordsNextStep = new Array(itinerary.coords.length);
     this._coordsPreviousStep = new Array(itinerary.coords.length);
     this._coordsDistanceTraveled = new Array(itinerary.coords.length);
@@ -1911,15 +2096,15 @@ class ItineraryInfoManager {
     });
   }
   getInfo(position) {
-    if (!this._itinerary || !this._mapMatching) {
+    if (!this._itinerary || !this._geoGraphProjectionHandler) {
       return null;
     }
-    const projection = this._mapMatching.getProjection(position);
+    const projection = this._geoGraphProjectionHandler.getProjection(position);
     if (!projection) {
       return null;
     }
     let itineraryInfo = null;
-    if (projection.nearestElement instanceof GraphNode) {
+    if (projection.nearestElement instanceof geo.GeoGraphVertex) {
       const idx = this._itinerary.coords.findIndex(
         (coords) => projection.nearestElement.coords === coords
       );
@@ -1938,14 +2123,14 @@ class ItineraryInfoManager {
         traveledPercentage: traveledDistance / this._itinerary.distance,
         remainingPercentage: remainingDistance / this._itinerary.distance
       };
-    } else if (projection.nearestElement instanceof GraphEdge) {
-      let firstNode = projection.nearestElement.node1.coords;
+    } else if (projection.nearestElement instanceof geo.GeoGraphEdge) {
+      let firstNode = projection.nearestElement.vertex1.coords;
       let idx = this._itinerary.coords.findIndex((coords) => firstNode === coords);
       if (idx === -1) {
         throw new Error("ItineraryInfoManager: could not find projection in itinerary (Edge)");
       }
-      if (idx === this._itinerary.coords.length - 1 || this._itinerary.coords[idx + 1] !== projection.nearestElement.node2.coords) {
-        firstNode = projection.nearestElement.node2.coords;
+      if (idx === this._itinerary.coords.length - 1 || this._itinerary.coords[idx + 1] !== projection.nearestElement.vertex2.coords) {
+        firstNode = projection.nearestElement.vertex2.coords;
         idx--;
       }
       const traveledDistance = this._coordsDistanceTraveled[idx] + projection.coords.distanceTo(firstNode);
@@ -1964,26 +2149,22 @@ class ItineraryInfoManager {
     return itineraryInfo;
   }
 }
-export {
-  CitywayRemoteRouter$1 as CitywayRemoteRouter,
-  DeutscheBahnRemoteRouter$1 as DeutscheBahnRemoteRouter,
-  IdfmRemoteRouter$1 as IdfmRemoteRouter,
-  Itinerary,
-  ItineraryInfoManager,
-  Leg,
-  OsrmRemoteRouter$1 as OsrmRemoteRouter,
-  OtpRemoteRouter$1 as OtpRemoteRouter,
-  RemoteRouterManager$1 as RemoteRouterManager,
-  RemoteRouterServerUnreachable,
-  RouterResponse,
-  StepInfo,
-  CustomNetworkMap as WemapMetaRouterIOMap,
-  WemapMultiRemoteRouter$1 as WemapMultiRemoteRouter,
-  WemapMultiRemoteRouterPayload,
-  WemapMultiRouter,
-  WemapOsmRouter,
-  WemapOsmRouterOptions,
-  WemapOsmRouterUtils,
-  getDurationFromLength
-};
+exports.CitywayRemoteRouter = CitywayRemoteRouter$1;
+exports.CustomNetworkMap = CustomNetworkMap;
+exports.DeutscheBahnRemoteRouter = DeutscheBahnRemoteRouter$1;
+exports.IdfmRemoteRouter = IdfmRemoteRouter$1;
+exports.Itinerary = Itinerary;
+exports.ItineraryInfoManager = ItineraryInfoManager;
+exports.Leg = Leg;
+exports.OsmGraph = OsmGraph;
+exports.OsmRouter = WemapOsmRouter;
+exports.OsrmRemoteRouter = OsrmRemoteRouter$1;
+exports.OtpRemoteRouter = OtpRemoteRouter$1;
+exports.RemoteRouterManager = RemoteRouterManager$1;
+exports.RemoteRouterServerUnreachable = RemoteRouterServerUnreachable;
+exports.RouterResponse = RouterResponse;
+exports.WemapMultiRemoteRouter = WemapMultiRemoteRouter$1;
+exports.WemapMultiRemoteRouterPayload = WemapMultiRemoteRouterPayload;
+exports.WemapMultiRouter = WemapMultiRouter;
+exports.getDurationFromLength = getDurationFromLength;
 //# sourceMappingURL=index.js.map