@wemap/routers 11.0.0-alpha.8 → 11.0.1

package/dist/index.js

@@ -8,13 +8,14 @@ var __publicField = (obj, key, value) => {
 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 helpers = require("@turf/helpers");
 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);
@@ -22,53 +23,6 @@ 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: geo.Coordinates.fromCompressedJson(json.coords)
-    }));
-  }
-}
 const SKIP_STEP_ANGLE_MAX = maths.deg2rad(20);
 function generateSteps(leg, rules) {
   const steps = [];
@@ -85,26 +39,30 @@ function generateSteps(leg, rules) {
     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 customRules = rules == null ? void 0 : rules(currentCoords, nextCoords);
+    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 = geo.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);
@@ -115,7 +73,7 @@ function generateSteps(leg, rules) {
   }
   const lastCoords = coordsArray[coordsArray.length - 1];
   if (!geo.Coordinates.equals(lastCoords, to.coords)) {
-    steps.push(new StepInfo({ coords: lastCoords }));
+    steps.push({ coords: lastCoords });
   }
   return steps;
 }
@@ -131,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,
@@ -151,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,
@@ -168,17 +156,22 @@ class Leg {
     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 geo.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;
     }
@@ -188,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) {
@@ -219,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 }
@@ -239,8 +230,7 @@ class Leg {
         name: json.to.name || null
       },
       coords: json.coords.map(geo.Coordinates.fromCompressedJson),
-      stepsInfo: ((_a = json.steps) == null ? void 0 : _a.map(StepInfo.fromJson)) || null,
-      stepsGenerationRules: void 0
+      steps: ((_a = json.steps) == null ? void 0 : _a.map(jsonToStep)) || null
     }));
     return leg;
   }
@@ -248,7 +238,7 @@ 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
@@ -260,12 +250,45 @@ class Leg {
     for (const coords of this.coords) {
       coords.level = geo.Level.multiplyBy(coords.level, levelFactor);
     }
-    this.stepsInfo.forEach((step) => {
+    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 {
@@ -285,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;
@@ -293,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.");
@@ -307,45 +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: maths.diffAngle(previousBearing, nextBearing + Math.PI),
-        firstStep: stepId === 0,
-        lastStep: stepId === stepsInfo.length - 1,
-        distance,
-        duration: stepInfo.duration || getDurationFromLength(distance),
-        previousStep: null,
-        nextStep: 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.");
@@ -381,8 +366,8 @@ class Itinerary {
     }
     return this._distance;
   }
-  toNetwork() {
-    return geo.Network.fromCoordinates([this.coords]);
+  toGraph() {
+    return geo.GeoGraph.fromCoordinates([this.coords]);
   }
   static fromItineraries(...itineraries) {
     let duration = 0;
@@ -416,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;
     }
@@ -434,7 +419,7 @@ class Itinerary {
     return {
       from: this.from.toCompressedJson(),
       to: this.to.toCompressedJson(),
-      duration: this.duration,
+      duration: Number(this.duration.toFixed(1)),
       mode: this.mode,
       legs: this.legs.map((leg) => leg.toJson()),
       ...this.startTime !== null && { startTime: this.startTime },
@@ -474,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;
         }
       }
@@ -496,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({
@@ -558,71 +573,267 @@ class RouterResponse {
     }
   }
 }
-const _WemapOsmRouterOptions = class extends osm.OsmGraphRouterOptions {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "weightEdgeFn", (edge) => edge.builtFrom instanceof osm.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) => {
+  const isElevatorArea = way.tags.highway === "elevator" && way.isArea;
+  return HIGHWAYS_PEDESTRIANS.includes(way.tags.highway) && !isElevatorArea && !["no", "private"].includes(way.tags.access) || way.tags.footway === "sidewalk" || way.tags.public_transport === "platform" || way.tags.railway === "platform";
+};
+const _OsmGraph = class 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;
+      }
+    });
+    osmModel.ways.filter((way) => way.isElevator).forEach((way) => {
+      way.nodes.forEach((node) => {
+        const connectedWays = node.ways.filter((otherWay) => otherWay != way);
+        if (connectedWays.length) {
+          const graphVertex = getOrCreateNode(node);
+          graphVertex.data.tags.highway = "elevator";
+          elevatorNodes.push(graphVertex);
+        }
+      });
+    });
+    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) => {
-  var _a, _b, _c, _d, _e, _f;
+let OsmGraph = _OsmGraph;
+__publicField(OsmGraph, "HIGHWAYS_PEDESTRIANS", HIGHWAYS_PEDESTRIANS);
+__publicField(OsmGraph, "DEFAULT_WAY_SELECTOR", DEFAULT_WAY_SELECTOR);
+const DEFAULT_OPTIONS = Object.assign({}, geo.GeoGraphRouter.DEFAULT_OPTIONS, {
+  weightEdgeFn: (edge) => edge.data instanceof osm.OsmNode && edge.data.isElevator ? 90 : 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 = geo.GraphUtils.getNodeByCoords(nodes, currentCoords);
-  const nextNode = geo.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 = geo.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 ((_d = edge.builtFrom) == null ? void 0 : _d.isElevator) {
+  if (edge.data.isElevator) {
     levelChangeType = "elevator";
-  } else if (edge.builtFrom instanceof osm.OsmNode || edge.builtFrom instanceof osm.OsmWay && edge.builtFrom.isConveying) {
+  } else if (edge.data.isConveying) {
     levelChangeType = "conveyor";
-  } else if (edge.builtFrom instanceof osm.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: (_e = edge.builtFrom) == null ? void 0 : _e.tags.name,
+    createNewStep,
+    stepName: (_d = edge.data) == null ? void 0 : _d.tags.name,
     duration: graphItinerary.edgesWeights[edgeId],
     stepExtras: {
       ...isSubwayEntrance && { isSubwayEntrance: true },
-      ...isSubwayEntrance && ((_f = node.builtFrom) == null ? void 0 : _f.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 osm.OsmGraphRouter {
-  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];
+      let cachedItinerary = cache.find((itinerary) => itinerary.start === p.coords && itinerary.end === q.coords || itinerary.end === p.coords && itinerary.start === q.coords);
+      if (cachedItinerary.end === p.coords) {
+        cachedItinerary = geo.GeoGraphItinerary.fromGraphVertices(
+          cachedItinerary.end,
+          cachedItinerary.start,
+          cachedItinerary.vertices.reverse(),
+          cachedItinerary.edgesWeights
+        );
+      }
+      orderedItineraries.push(cachedItinerary);
+    }
+    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 {
@@ -774,7 +985,7 @@ class CitywayRemoteRouter extends RemoteRouter {
           const legCoords = [];
           let legFrom, legTo;
           let transportInfo;
-          let stepsInfo;
+          let minStepsInfo;
           if (legMode === "UNKNOWN") {
             continue itineraryLoop;
           }
@@ -787,7 +998,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") {
@@ -800,11 +1011,16 @@ class CitywayRemoteRouter extends RemoteRouter {
                   legCoords.push(coords);
                 }
               });
-              stepsInfo.push(new StepInfo({
+              minStepsInfo.push({
                 coords: stepCoords[0],
                 distance: jsonPathLink.Distance,
                 name: jsonPathLink.Departure.Site.Name
-              }));
+              });
+            }
+            if (jsonSection === trip.sections.Section[trip.sections.Section.length - 1]) {
+              minStepsInfo.push({
+                coords: legCoords[legCoords.length - 1]
+              });
             }
           } else if (isRoutingModePublicTransport(legMode)) {
             legFrom = {
@@ -833,11 +1049,11 @@ class CitywayRemoteRouter extends RemoteRouter {
                 }
               });
             }
-            stepsInfo = [new StepInfo({
+            minStepsInfo = [{
               coords: legCoords[0],
               name: jsonLeg.Line.Name,
               distance: jsonLeg.Distance
-            })];
+            }];
           } else {
             Logger__default.default.warn(`[CitywayParser] Unknown leg mode: ${jsonLeg.TransportMode}`);
             continue;
@@ -851,7 +1067,7 @@ class CitywayRemoteRouter extends RemoteRouter {
             from: legFrom,
             to: legTo,
             transportInfo,
-            stepsInfo
+            minStepsInfo
           });
           legs.push(leg);
         }
@@ -1093,16 +1309,15 @@ class IdfmRemoteRouter extends RemoteRouter {
         newCoords = last(result);
         coords[_idCoordsInLeg] = newCoords;
       }
-      outputSteps.push(new StepInfo({
+      outputSteps.push({
         ...step,
         coords: newCoords
-      }));
+      });
       previousStep = step;
     }
     return outputSteps;
   }
   createRouterResponseFromJson(json, from, to) {
-    var _a;
     const routerResponse = new RouterResponse({ routerName: this.rname, from, to });
     if (!json || !json.journeys) {
       return routerResponse;
@@ -1123,7 +1338,9 @@ class IdfmRemoteRouter extends RemoteRouter {
           }
           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) {
@@ -1132,10 +1349,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),
@@ -1148,23 +1380,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({
@@ -1329,19 +1547,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,
@@ -1353,7 +1571,7 @@ class OsrmRemoteRouter extends RemoteRouter {
           to: {
             coords: legCoords[legCoords.length - 1]
           },
-          stepsInfo
+          minStepsInfo
         });
       });
       return new Itinerary({
@@ -1422,7 +1640,7 @@ class OtpRemoteRouter extends RemoteRouter {
       for (const jsonLeg of jsonItinerary.legs) {
         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,
@@ -1430,21 +1648,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({
@@ -1462,7 +1680,7 @@ class OtpRemoteRouter extends RemoteRouter {
           },
           coords: legCoords,
           transportInfo,
-          stepsInfo
+          minStepsInfo
         });
         legs.push(leg);
       }
@@ -1503,7 +1721,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(
@@ -1528,19 +1746,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);
@@ -1549,9 +1765,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;
@@ -1559,7 +1775,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]
       });
@@ -1574,7 +1790,7 @@ class WemapMultiRouter {
     __publicField(this, "maps", []);
   }
   get rname() {
-    return "wemap-meta";
+    return "wemap-multi";
   }
   addIOMap(customNetworkMap) {
     this.maps.push(customNetworkMap);
@@ -1582,21 +1798,9 @@ class WemapMultiRouter {
   removeIOMap(customNetworkMap) {
     this.maps = this.maps.filter((map) => map !== customNetworkMap);
   }
-  async getItineraries(mode, waypoints, options) {
-    var _a;
-    if (waypoints.length > 2) {
-      Logger__default.default.warn(`WemapMultiRouter uses only the first 2 waypoints (asked ${waypoints.length})`);
-    }
-    const start = waypoints[0];
-    const end = waypoints[1];
-    const routerResponse = new RouterResponse({
-      routerName: this.rname,
-      from: start,
-      to: end
-    });
-    const remoteRouters = ((_a = options.remoteRouters) == null ? void 0 : _a.filter(({ name }) => name !== WemapMultiRemoteRouter$1.rname)) || [];
+  getIoMapsFromOptions(options) {
     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) {
@@ -1607,9 +1811,55 @@ class WemapMultiRouter {
         });
       }
     }
+    return ioMapsToTest;
+  }
+  convertOptionsToWemapOsmOptions(options) {
+    return !options || !("useStairs" in options) || options.useStairs ? WemapOsmRouter.DEFAULT_OPTIONS : WemapOsmRouter.WITHOUT_STAIRS_OPTIONS;
+  }
+  async getTrip(mode, waypoints, options = null) {
+    const ioMapsToTest = this.getIoMapsFromOptions(options);
+    if (waypoints.length < 2) {
+      throw Error(`Cannot retrieve a trip itinerary. Two points or more are necessary`);
+    }
+    if (mode !== "WALK") {
+      throw Error(`Cannot calculate trip itinerary for mode "${mode}". Only "WALK" is implemented.`);
+    }
+    const mapOfWaypoints = waypoints.reduce((map, waypoint) => {
+      const mapOfThisWaypoint = ioMapsToTest.find((map2) => map2.isPointInside(waypoint));
+      if (!mapOfThisWaypoint) {
+        throw Error(`Cannot find a network for this trip waypoint (${waypoint.toString()}). Outdoor trips are not implemented.`);
+      }
+      if (map && mapOfThisWaypoint !== map) {
+        throw Error(`Cannot handle this trip, because two waypoints are on different maps (${mapOfThisWaypoint} and ${mapOfWaypoints}). Multi-map trips are not implemented.`);
+      }
+      return mapOfThisWaypoint;
+    }, null);
+    const wemapOsmRouterOptions = this.convertOptionsToWemapOsmOptions(options);
+    const tripItinerary = mapOfWaypoints.getTripInsideMap(waypoints, wemapOsmRouterOptions);
+    return new RouterResponse({
+      routerName: this.rname,
+      from: tripItinerary.from,
+      to: tripItinerary.to,
+      itineraries: [tripItinerary]
+    });
+  }
+  async getItineraries(mode, waypoints, options = null) {
+    var _a;
+    if (waypoints.length > 2) {
+      Logger__default.default.warn(`WemapMultiRouter uses only the first 2 waypoints (asked ${waypoints.length})`);
+    }
+    const start = waypoints[0];
+    const end = waypoints[1];
+    const routerResponse = new RouterResponse({
+      routerName: this.rname,
+      from: start,
+      to: end
+    });
+    const remoteRouters2 = ((_a = options == null ? void 0 : options.remoteRouters) == null ? void 0 : _a.filter(({ name }) => name !== WemapMultiRemoteRouter$1.rname)) || [];
+    const ioMapsToTest = this.getIoMapsFromOptions(options);
     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;
@@ -1620,7 +1870,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 = this.convertOptionsToWemapOsmOptions(options);
     if (mapWithStart && mapWithStart.isPointInside(end)) {
       try {
         ioMapItinerary = mapWithStart.getItineraryInsideMap(start, end, wemapOsmRouterOptions);
@@ -1639,7 +1889,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;
@@ -1657,7 +1907,7 @@ class WemapMultiRouter {
       try {
         ioMapItinerary = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapOsmRouterOptions);
         remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
-          remoteRouters,
+          remoteRouters2,
           mode,
           [ioMapItinerary.to, end]
         );
@@ -1668,7 +1918,7 @@ class WemapMultiRouter {
         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(
@@ -1686,7 +1936,7 @@ class WemapMultiRouter {
       try {
         ioMapItinerary = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapOsmRouterOptions);
         remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
-          remoteRouters,
+          remoteRouters2,
           mode,
           [start, ioMapItinerary.from]
         );
@@ -1697,7 +1947,7 @@ class WemapMultiRouter {
         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(
@@ -1724,7 +1974,7 @@ 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]
         );
@@ -1735,7 +1985,7 @@ class WemapMultiRouter {
         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(
@@ -1752,46 +2002,63 @@ 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 = helpers.polygon([bounds.map((coords) => [coords.lng, coords.lat])]);
+      this.bounds = bounds;
     } else {
-      const polygon = [network.nodes.map((node) => [node.coords.lng, node.coords.lat])];
+      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 = osm.OsmParser.parseOsmXmlString(osmXmlString);
-    const network = osm.OsmNetworkUtils.createNetworkFromOsmModel(osmModel);
-    const entryPoints = osmModel.nodes.filter(({ tags }) => tags && tags["wemap:routing-io"]).map((osmNode) => network.getNodeByCoords(osmNode.coords));
+    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__default.default([coordinates.lng, coordinates.lat], this.bounds);
@@ -1833,45 +2100,22 @@ class CustomNetworkMap {
   getItineraryInsideMap(start, end, options) {
     return this.router.getItinerary(start, end, options);
   }
+  getTripInsideMap(waypoints, options) {
+    return this.router.getTripItinerary(waypoints, 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 = 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 };
-}
-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", []);
@@ -1889,8 +2133,8 @@ class ItineraryInfoManager {
     }
     this._itinerary = itinerary;
     this._steps = itinerary.steps;
-    const network = itinerary.toNetwork();
-    this._mapMatching = new geo.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);
@@ -1915,15 +2159,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 geo.GraphNode) {
+    if (projection.nearestElement instanceof geo.GeoGraphVertex) {
       const idx = this._itinerary.coords.findIndex(
         (coords) => projection.nearestElement.coords === coords
       );
@@ -1942,14 +2186,14 @@ class ItineraryInfoManager {
         traveledPercentage: traveledDistance / this._itinerary.distance,
         remainingPercentage: remainingDistance / this._itinerary.distance
       };
-    } else if (projection.nearestElement instanceof geo.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);
@@ -1969,23 +2213,21 @@ class ItineraryInfoManager {
   }
 }
 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.StepInfo = StepInfo;
-exports.WemapMetaRouterIOMap = CustomNetworkMap;
 exports.WemapMultiRemoteRouter = WemapMultiRemoteRouter$1;
 exports.WemapMultiRemoteRouterPayload = WemapMultiRemoteRouterPayload;
 exports.WemapMultiRouter = WemapMultiRouter;
-exports.WemapOsmRouter = WemapOsmRouter;
-exports.WemapOsmRouterOptions = WemapOsmRouterOptions;
-exports.WemapOsmRouterUtils = WemapOsmRouterUtils;
 exports.getDurationFromLength = getDurationFromLength;
 //# sourceMappingURL=index.js.map