@wemap/routers 6.2.2 → 7.0.0

package/dist/wemap-routers.es.js

@@ -1,8 +1,8 @@
-import { GraphUtils, Level, Coordinates, Network, GraphRouterOptions, GraphRouter, GraphEdge, GraphNode, GraphItinerary, MapMatching } from '@wemap/geo';
+import { Coordinates, Network, GraphRouterOptions, GraphRouter, GraphUtils, Level, GraphEdge, GraphNode, GraphItinerary, Utils, MapMatching } from '@wemap/geo';
 import { OsmWay, OsmNode } from '@wemap/osm';
-import { diffAngle, deg2rad, positiveMod, rad2deg } from '@wemap/maths';
-import Polyline from '@mapbox/polyline';
+import { deg2rad, diffAngle, positiveMod, rad2deg } from '@wemap/maths';
 import Logger from '@wemap/logger';
+import Polyline from '@mapbox/polyline';
 
 class LevelChange {
 
@@ -16,28 +16,22 @@ class LevelChange {
     type = null;
 
     /**
-     * @param {GraphNode<OsmElement>} firstNode
-     * @param {GraphNode<OsmElement>} secondNode
-     * @returns {LevelChange}
+     * @param {LevelChange} obj1
+     * @param {LevelChange} obj2
+     * @returns {Boolean}
      */
-    static fromTwoNodes(firstNode, secondNode) {
-
-        const levelChange = new LevelChange();
-
-        const edge = GraphUtils.getEdgeByNodes(firstNode.edges, firstNode, secondNode);
-
-        if (edge.builtFrom.isElevator) {
-            levelChange.type = 'elevator';
-        } else if (edge.builtFrom.isConveying) {
-            levelChange.type = 'conveyor';
-        } else if (edge.builtFrom.areStairs) {
-            levelChange.type = 'stairs';
-        }
-
-        levelChange.difference = Level.diff(firstNode.coords.level, secondNode.coords.level);
-        levelChange.direction = levelChange.difference > 0 ? 'up' : 'down';
+    static equalsTo(obj1, obj2) {
+        return obj1.difference === obj2.difference
+            && obj1.direction === obj2.direction
+            && obj1.type === obj2.type;
+    }
 
-        return levelChange;
+    /**
+     * @param {LevelChange} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return LevelChange.equalsTo(this, obj);
     }
 
     /**
@@ -108,6 +102,45 @@ class Step {
     /** @type {!number} */
     _idCoordsInLeg = null;
 
+    /**
+     * @param {Step} obj1
+     * @param {Step} obj2
+     * @returns {Boolean}
+     */
+    static equalsTo(obj1, obj2) {
+        return obj1.firstStep === obj2.firstStep
+            && obj1.lastStep === obj2.lastStep
+            && obj1.number === obj2.number
+            && obj1.coords.equalsTo(obj2.coords)
+            && obj1.angle === obj2.angle
+            && obj1.previousBearing === obj2.previousBearing
+            && obj1.nextBearing === obj2.nextBearing
+            && obj1.distance === obj2.distance
+            && obj1.duration === obj2.duration
+            && obj1.name === obj2.name
+            && (
+                obj1.levelChange === obj2.levelChange
+                || obj1.levelChange !== null && obj1.levelChange.equalsTo(obj2.levelChange)
+            )
+            && (
+                obj1.extras === obj2.extras
+                || (
+                    obj1.extras !== null
+                    && obj1.extras.subwayEntrance === obj2.extras.subwayEntrance
+                    && obj1.extras.subwayEntranceRef === obj2.extras.subwayEntranceRef
+                )
+            )
+            && obj1._idCoordsInLeg === obj2._idCoordsInLeg;
+    }
+
+    /**
+     * @param {Step} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return Step.equalsTo(this, obj);
+    }
+
     /**
      * @returns {object}
      */
@@ -155,31 +188,62 @@ class Step {
         step.nextBearing = json.nextBearing;
         step.distance = json.distance;
         step._idCoordsInLeg = json._idCoordsInLeg;
-        if (json.firstStep) {
+        if (typeof json.firstStep === 'boolean') {
             step.firstStep = json.firstStep;
         }
-        if (json.lastStep) {
+        if (typeof json.lastStep === 'boolean') {
             step.lastStep = json.lastStep;
         }
-        if (json.duration) {
+        if (typeof json.duration === 'number') {
             step.duration = json.duration;
         }
-        if (json.name) {
+        if (typeof json.name === 'string') {
             step.name = json.name;
         }
-        if (json.levelChange) {
+        if (typeof json.levelChange === 'object') {
             step.levelChange = LevelChange.fromJson(json.levelChange);
         }
-        if (json.extras) {
+        if (typeof json.extras === 'object') {
             step.extras = json.extras;
         }
         return step;
     }
 }
 
+const Constants = {};
+
+Constants.ROUTING_MODE = {
+    AIRPLANE: 'AIRPLANE',
+    BOAT: 'BOAT',
+    BIKE: 'BIKE',
+    BUS: 'BUS',
+    CAR: 'CAR',
+    FERRY: 'FERRY',
+    FUNICULAR: 'FUNICULAR',
+    METRO: 'METRO',
+    MOTO: 'MOTO',
+    TRAIN: 'TRAIN',
+    TAXI: 'TAXI',
+    TRAM: 'TRAM',
+    WALK: 'WALK',
+    MULTI: 'MULTI',
+    UNKNOWN: 'UNKNOWN'
+};
+
+Constants.PUBLIC_TRANSPORT = [
+    Constants.ROUTING_MODE.AIRPLANE,
+    Constants.ROUTING_MODE.BOAT,
+    Constants.ROUTING_MODE.BUS,
+    Constants.ROUTING_MODE.FERRY,
+    Constants.ROUTING_MODE.FUNICULAR,
+    Constants.ROUTING_MODE.METRO,
+    Constants.ROUTING_MODE.TRAIN,
+    Constants.ROUTING_MODE.TRAM
+];
+
 class Leg {
 
-    /** @type {!string} can be WALK, BIKE, BUS, TRAM, CAR, FUNICULAR */
+    /** @type {!string} can be values in Constants.ROUTING_MODE */
     mode;
 
     /** @type {!number} */
@@ -209,6 +273,10 @@ class Leg {
     /** @type {?(Step[])} */
     steps = null;
 
+    isPublicTransport() {
+        return Constants.PUBLIC_TRANSPORT.includes(this.mode);
+    }
+
     /**
      * @returns {Network}
      */
@@ -216,6 +284,72 @@ class Leg {
         return Network.fromCoordinates([this.coords]);
     }
 
+
+    /**
+     * @param {Leg} obj1
+     * @param {Leg} obj2
+     * @returns {Boolean}
+     */
+    // eslint-disable-next-line complexity
+    static equalsTo(obj1, obj2) {
+        const intermediate = obj1.mode === obj2.mode
+            && obj1.distance === obj2.distance
+            && obj1.duration === obj2.duration
+            && obj1.startTime === obj2.startTime
+            && obj1.endTime === obj2.endTime
+            && obj1.from.name === obj2.from.name
+            && obj1.from.coords.equalsTo(obj2.from.coords)
+            && obj1.to.name === obj2.to.name
+            && obj1.to.coords.equalsTo(obj2.to.coords)
+            && obj1.coords.length === obj2.coords.length
+            && (
+                obj1.steps === obj2.steps
+                || obj1.steps.length === obj2.steps.length
+            );
+
+        if (!intermediate) {
+            return false;
+        }
+
+        let i;
+        for (i = 0; i < obj1.coords.length; i++) {
+            if (!obj1.coords[i].equalsTo(obj2.coords[i])) {
+                return false;
+            }
+        }
+        if (obj1.steps) {
+            for (i = 0; i < obj1.steps.length; i++) {
+                if (!obj1.steps[i].equalsTo(obj2.steps[i])) {
+                    return false;
+                }
+            }
+        }
+
+        if (obj1.transportInfo !== obj2.transportInfo) {
+            if (obj1.transportInfo === null) {
+                return false;
+            }
+            if (
+                obj1.transportInfo.name !== obj2.transportInfo.name
+                || obj1.transportInfo.routeColor !== obj2.transportInfo.routeColor
+                || obj1.transportInfo.routeTextColor !== obj2.transportInfo.routeTextColor
+                || obj1.transportInfo.directionName !== obj2.transportInfo.directionName
+            ) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * @param {Leg} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return Leg.equalsTo(this, obj);
+    }
+
     /**
      * @returns {object}
      */
@@ -228,18 +362,18 @@ class Leg {
             duration: this.duration,
             coords: this.coords.map(coords => coords.toCompressedJson())
         };
-        if (this.from.name) {
-            output.from.name = this.from.name;
-        }
-        if (this.to.name) {
-            output.to.name = this.to.name;
-        }
         if (this.startTime !== null) {
             output.startTime = this.startTime;
         }
         if (this.endTime !== null) {
             output.endTime = this.endTime;
         }
+        if (this.from.name !== null) {
+            output.from.name = this.from.name;
+        }
+        if (this.to.name !== null) {
+            output.to.name = this.to.name;
+        }
         if (this.transportInfo !== null) {
             output.transportInfo = this.transportInfo;
         }
@@ -257,27 +391,31 @@ class Leg {
     static fromJson(json) {
         const leg = new Leg();
         leg.mode = json.mode;
-        leg.from = { coords: Coordinates.fromCompressedJson(json.from.coords) };
-        leg.to = { coords: Coordinates.fromCompressedJson(json.to.coords) };
         leg.distance = json.distance;
         leg.duration = json.duration;
-        leg.coords = json.coords.map(Coordinates.fromCompressedJson);
-        if (json.from.name) {
-            leg.from.name = json.from.name;
-        }
-        if (json.to.name) {
-            leg.to.name = json.to.name;
-        }
-        if (json.startTime) {
+
+        if (typeof json.startTime === 'number') {
             leg.startTime = json.startTime;
         }
-        if (json.endTime) {
+        if (typeof json.endTime === 'number') {
             leg.endTime = json.endTime;
         }
-        if (json.transportInfo) {
+
+        leg.from = {
+            coords: Coordinates.fromCompressedJson(json.from.coords),
+            name: typeof json.from.name === 'string' ? json.from.name : null
+        };
+        leg.to = {
+            coords: Coordinates.fromCompressedJson(json.to.coords),
+            name: typeof json.to.name === 'string' ? json.to.name : null
+        };
+
+        leg.coords = json.coords.map(Coordinates.fromCompressedJson);
+
+        if (typeof json.transportInfo === 'object') {
             leg.transportInfo = json.transportInfo;
         }
-        if (json.steps) {
+        if (typeof json.steps === 'object') {
             leg.steps = json.steps.map(Step.fromJson);
         }
         return leg;
@@ -294,58 +432,6 @@ function getDurationFromLength(length, speed = 5) {
     return length / (speed * 1000 / 3600);
 }
 
-
-/**
- * @param {Itinerary} itinerary
- */
-function generateStepsMetadata(itinerary) {
-
-    let counter = 1;
-
-    itinerary.legs.forEach((leg, legId) => {
-        leg.steps.forEach((step, stepId) => {
-
-            if (counter === 1) {
-                step.firstStep = true;
-            }
-            if (legId === itinerary.legs.length - 1
-                && stepId === leg.steps.length - 1) {
-                step.lastStep = true;
-            }
-
-            step.number = counter++;
-
-
-            /*
-             * Generate previousBearing, nextBearing and angle
-             */
-
-            let coordsBeforeStep;
-            if (step._idCoordsInLeg > 0) {
-                coordsBeforeStep = leg.coords[step._idCoordsInLeg - 1];
-            } else if (legId === 0) {
-                coordsBeforeStep = itinerary.from;
-            } else {
-                coordsBeforeStep = itinerary.legs[legId - 1].to.coords;
-            }
-
-            let coordsAfterStep;
-            if (step._idCoordsInLeg !== leg.coords.length - 1) {
-                coordsAfterStep = leg.coords[step._idCoordsInLeg + 1];
-            } else if (legId === itinerary.legs.length - 1) {
-                coordsAfterStep = itinerary.to;
-            } else {
-                coordsAfterStep = itinerary.legs[legId + 1].from.coords;
-            }
-
-            step.previousBearing = coordsBeforeStep.bearingTo(step.coords);
-            step.nextBearing = step.coords.bearingTo(coordsAfterStep);
-            step.angle = diffAngle(step.previousBearing, step.nextBearing + Math.PI);
-
-        });
-    });
-}
-
 /* eslint-disable max-statements */
 
 /**
@@ -417,14 +503,14 @@ class Itinerary {
 
     get mode() {
         if (!this._mode) {
-            let isPublicTransport;
-            let isBicycle;
-            let isDriving;
+            let isPublicTransport = false;
+            let isBicycle = false;
+            let isDriving = false;
 
             this.legs.forEach((leg) => {
-                isPublicTransport = isPublicTransport || ['BUS', 'FUNICULAR', 'TRAM', 'TRAIN'].includes(leg.mode);
-                isBicycle = isBicycle || ['BIKE', 'BICYCLE'].includes(leg.mode);
-                isDriving = isDriving || leg.mode === 'CAR';
+                isPublicTransport = isPublicTransport || Constants.PUBLIC_TRANSPORT.includes(leg.mode);
+                isBicycle = isBicycle || leg.mode === Constants.ROUTING_MODE.BIKE;
+                isDriving = isDriving || leg.mode === Constants.ROUTING_MODE.CAR;
             });
 
             if (isPublicTransport) {
@@ -532,6 +618,42 @@ class Itinerary {
         return itinerary;
     }
 
+
+    /**
+     * @param {Itinerary} obj1
+     * @param {Itinerary} obj2
+     * @returns {Boolean}
+     */
+    static equalsTo(obj1, obj2) {
+        const intermediate = obj1.from.equalsTo(obj2.from)
+            && obj1.to.equalsTo(obj2.to)
+            && obj1.distance === obj2.distance
+            && obj1.duration === obj2.duration
+            && obj1.startTime === obj2.startTime
+            && obj1.endTime === obj2.endTime
+            && obj1.legs.length === obj2.legs.length;
+
+        if (!intermediate) {
+            return false;
+        }
+
+        for (let i = 0; i < obj1.legs.length; i++) {
+            if (!obj1.legs[i].equalsTo(obj2.legs[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * @param {Itinerary} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return Itinerary.equalsTo(this, obj);
+    }
+
     /**
      * @returns {object}
      */
@@ -564,10 +686,10 @@ class Itinerary {
         itinerary.distance = json.distance;
         itinerary.duration = json.duration;
         itinerary.legs = json.legs.map(Leg.fromJson);
-        if (json.startTime) {
+        if (typeof json.startTime === 'number') {
             itinerary.startTime = json.startTime;
         }
-        if (json.endTime) {
+        if (typeof json.endTime === 'number') {
             itinerary.endTime = json.endTime;
         }
         return itinerary;
@@ -576,7 +698,7 @@ class Itinerary {
 
 class RouterResponse {
 
-    /** @type {!string} */
+    /** @type {!string|Array<string>} */
     routerName;
 
     /** @type {!Coordinates} */
@@ -587,6 +709,64 @@ class RouterResponse {
 
     /** @type {!(Itinerary[])} */
     itineraries = [];
+
+    /**
+     * @param {RouterResponse} obj1
+     * @param {RouterResponse} obj2
+     * @returns {Boolean}
+     */
+    static equalsTo(obj1, obj2) {
+        const intermediate = obj1.routerName === obj2.routerName
+            && obj1.from.equalsTo(obj2.from)
+            && obj1.to.equalsTo(obj2.to)
+            && obj1.itineraries.length === obj2.itineraries.length;
+
+        if (!intermediate) {
+            return false;
+        }
+
+        for (let i = 0; i < obj1.itineraries.length; i++) {
+            if (!obj1.itineraries[i].equalsTo(obj2.itineraries[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * @param {RouterResponse} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return RouterResponse.equalsTo(this, obj);
+    }
+
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        return {
+            routerName: this.routerName,
+            from: this.from.toCompressedJson(),
+            to: this.to.toCompressedJson(),
+            itineraries: this.itineraries.map(itinerary => itinerary.toJson())
+        };
+    }
+
+    /**
+     * @param {object} json
+     * @returns {RouterResponse}
+     */
+    static fromJson(json) {
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = json.routerName;
+        routerResponse.from = Coordinates.fromCompressedJson(json.from);
+        routerResponse.to = Coordinates.fromCompressedJson(json.to);
+        routerResponse.itineraries = json.itineraries.map(Itinerary.fromJson);
+        return routerResponse;
+    }
 }
 
 class ItineraryInfo {
@@ -654,6 +834,12 @@ class WemapRouter extends GraphRouter {
         super(network);
     }
 
+
+    /** @type {string} */
+    static get rname() {
+        return 'wemap';
+    }
+
     /**
      * @param {Coordinates} start
      * @param {Coordinates} end
@@ -730,7 +916,7 @@ class WemapStepsGeneration {
                 }
 
                 if (splitByLevel) {
-                    currentStep.levelChange = LevelChange.fromTwoNodes(node, nextNode);
+                    currentStep.levelChange = WemapStepsGeneration.levelChangefromTwoNodes(node, nextNode);
                 }
 
                 steps.push(currentStep);
@@ -746,21 +932,48 @@ class WemapStepsGeneration {
         }
 
         const lastNode = nodes[nodes.length - 1];
-        const lastStep = new Step();
-        lastStep.coords = lastNode.coords;
-        lastStep.number = steps.length + 1;
-        lastStep.previousBearing = previousBearing;
-        lastStep.distance = lastNode.coords.distanceTo(end);
+
+        // Create a last step if end is not on the network
         if (!Coordinates.equalsTo(lastNode.coords, end)) {
+            const lastStep = new Step();
+            lastStep.coords = lastNode.coords;
+            lastStep.number = steps.length + 1;
+            lastStep.previousBearing = previousBearing;
+            lastStep.distance = lastNode.coords.distanceTo(end);
             lastStep.nextBearing = lastNode.coords.bearingTo(end);
             lastStep.angle = diffAngle(lastStep.previousBearing, lastStep.nextBearing + Math.PI);
+            steps.push(lastStep);
         }
-        lastStep.lastStep = true;
-        steps.push(lastStep);
+
+        steps[steps.length - 1].lastStep = true;
 
         return steps;
     }
 
+    /**
+     * @param {GraphNode<OsmElement>} firstNode
+     * @param {GraphNode<OsmElement>} secondNode
+     * @returns {LevelChange}
+     */
+    static levelChangefromTwoNodes(firstNode, secondNode) {
+
+        const levelChange = new LevelChange();
+
+        const edge = GraphUtils.getEdgeByNodes(firstNode.edges, firstNode, secondNode);
+
+        if (edge.builtFrom.isElevator) {
+            levelChange.type = 'elevator';
+        } else if (edge.builtFrom.isConveying) {
+            levelChange.type = 'conveyor';
+        } else if (edge.builtFrom.areStairs) {
+            levelChange.type = 'stairs';
+        }
+
+        levelChange.difference = Level.diff(firstNode.coords.level, secondNode.coords.level);
+        levelChange.direction = levelChange.difference > 0 ? 'up' : 'down';
+
+        return levelChange;
+    }
 }
 
 /**
@@ -768,17 +981,21 @@ class WemapStepsGeneration {
  * @param {string} mode
  * @returns {Leg}
  */
-function createLegFromGraphItinerary(graphItinerary, mode = 'WALK') {
+function createLegFromGraphItinerary(graphItinerary,
+    mode = Constants.ROUTING_MODE.WALK) {
 
     const leg = new Leg();
 
-    leg.from = { coords: graphItinerary.start };
-    leg.to = { coords: graphItinerary.end };
+    leg.from = { coords: graphItinerary.start, name: null };
+    leg.to = { coords: graphItinerary.end, name: null };
     leg.coords = graphItinerary.nodes.map(node => node.coords);
     leg.distance = graphItinerary.edges.reduce((acc, edge) => acc + edge.length, 0);
     leg.duration = graphItinerary.edgesWeights.reduce((acc, weight) => acc + weight, 0);
     leg.mode = mode;
     leg.steps = WemapStepsGeneration.fromGraphItinerary(graphItinerary);
+    leg.steps.forEach(step => {
+        step._idCoordsInLeg = leg.coords.findIndex(coords => coords === step.coords);
+    });
 
     return leg;
 }
@@ -788,7 +1005,8 @@ function createLegFromGraphItinerary(graphItinerary, mode = 'WALK') {
  * @param {string} mode
  * @returns {Itinerary}
  */
-function createItineraryFromGraphItinerary(graphItinerary, mode = 'WALK') {
+function createItineraryFromGraphItinerary(graphItinerary,
+    mode = Constants.ROUTING_MODE.WALK) {
 
     const leg = createLegFromGraphItinerary(graphItinerary, mode);
 
@@ -1010,745 +1228,1643 @@ var WemapNetworkUtils = /*#__PURE__*/Object.freeze({
     createNetworkFromOsmModel: createNetworkFromOsmModel
 });
 
-/* eslint-disable max-statements */
-
 /**
- * @param {Coordinates} coordinates
- * @returns {object}
+ * @param {Itinerary} itinerary
  */
-function coordinatesToJson(coordinates) {
-    const output = [coordinates.lng, coordinates.lat];
-    if (coordinates.level) {
-        output.push(coordinates.level.toString());
-    }
-    return output;
-}
+function generateStepsMetadata(itinerary) {
 
-/**
- * @param {object} json
- * @returns {Coordinates}
- */
-function jsonToCoordinates$2(json) {
-    const output = new Coordinates(json[1], json[0]);
-    if (json.length > 2) {
-        output.level = Level.fromString(json[2]);
-    }
-    return output;
-}
+    let counter = 1;
 
-function nodesToJsonCoords(nodes) {
-    return nodes.map(node => coordinatesToJson(node.coords));
-}
+    itinerary.legs.forEach((leg, legId) => {
+        leg.steps.forEach((step, stepId) => {
 
+            if (counter === 1) {
+                step.firstStep = true;
+            }
+            if (legId === itinerary.legs.length - 1
+                && stepId === leg.steps.length - 1) {
+                step.lastStep = true;
+            }
 
-function getModifierFromAngle(_angle) {
+            step.number = counter++;
 
-    const angle = positiveMod(rad2deg(_angle), 360);
 
-    if (angle > 0 && angle < 60) {
-        return 'sharp right';
-    }
-    if (angle >= 60 && angle < 140) {
-        return 'right';
-    }
-    if (angle >= 140 && angle < 160) {
-        return 'slight right';
-    }
-    if (angle >= 160 && angle <= 200) {
-        return 'straight';
-    }
-    if (angle > 200 && angle <= 220) {
-        return 'slight left';
-    }
-    if (angle > 220 && angle <= 300) {
-        return 'left';
-    }
-    if (angle > 300 && angle < 360) {
-        return 'sharp left';
-    }
-    return 'u turn';
-}
+            /*
+             * Generate previousBearing, nextBearing and angle
+             */
 
+            let coordsBeforeStep;
+            if (step._idCoordsInLeg > 0) {
+                coordsBeforeStep = leg.coords[step._idCoordsInLeg - 1];
+            } else if (legId === 0) {
+                coordsBeforeStep = itinerary.from;
+            } else {
+                coordsBeforeStep = itinerary.legs[legId - 1].to.coords;
+            }
 
-function noRouteFoundJson(message) {
-    return {
-        'code': 'NoRoute',
-        message
-    };
-}
+            let coordsAfterStep;
+            if (step._idCoordsInLeg !== leg.coords.length - 1) {
+                coordsAfterStep = leg.coords[step._idCoordsInLeg + 1];
+            } else if (legId === itinerary.legs.length - 1) {
+                coordsAfterStep = itinerary.to;
+            } else {
+                coordsAfterStep = itinerary.legs[legId + 1].from.coords;
+            }
 
-/**
- * @param {Itinerary} itinerary
- * @returns {object}
+            step.previousBearing = coordsBeforeStep.bearingTo(step.coords);
+            step.nextBearing = step.coords.bearingTo(coordsAfterStep);
+            step.angle = diffAngle(step.previousBearing, step.nextBearing + Math.PI);
+
+        });
+    });
+}
+
+
+/**
+ * Create and return a date with a given timezone
+ * @param {number} year
+ * @param {number} month
+ * @param {number} day
+ * @param {number} hours
+ * @param {number} minutes
+ * @param {number} seconds
+ * @param {string} timeZone - timezone name (e.g. 'Europe/Paris')
  */
-function itineraryToOsrmJson(itinerary) {
+function dateWithTimeZone(year, month, day, hour, minute, second, timeZone = 'Europe/Paris') {
+    const date = new Date(Date.UTC(year, month, day, hour, minute, second));
+
+    const utcDate = new Date(date.toLocaleString('en-US', { timeZone: 'UTC' }));
+    const tzDate = new Date(date.toLocaleString('en-US', { timeZone: timeZone }));
+    const offset = utcDate.getTime() - tzDate.getTime();
+
+    date.setTime(date.getTime() + offset);
+
+    return date;
+}
+
+const stringify = (data) => {
+    return Object.keys(data).map(key => {
+        return `${key}=${data[key]}`;
+    });
+};
+
+
+const request = async (url, options = {}) => {
+    const responseType = options.responseType || 'json';
+
+    const fetchOptions = {
+        method: options.method || 'GET',
+        headers: {}
+        // headers: new Headers(options.headers || {})
+    };
+
+    if (options.hasOwnProperty('json')) {
+        fetchOptions.headers.append('Content-Type', 'application/json');
+        fetchOptions.body = JSON.stringify(options.json);
+    } else if (options.hasOwnProperty('data')) {
+        fetchOptions.headers.append('Content-Type', 'application/x-www-form-urlencoded;charset=UTF-8');
+        fetchOptions.body = options.data instanceof URLSearchParams ? options.data : stringify(options.data);
+    }
+
+    return fetch(url, fetchOptions).then(response => {
+        if (responseType === 'arraybuffer') {
+            Logger.ok('Request succeeded for: ' + url);
+            return response.arrayBuffer();
+        } else if (responseType === 'json') {
+            return response.json().then((json) => {
+                Logger.ok('Request succeeded for: ' + url);
+                return json;
+            }).catch(() => {
+                Logger.error('Request failed for: ' + url);
+                throw Error('Request failed for: ' + url);
+            });
+        }
+
+        return null;
+    });
+};
+
+class RemoteRouterOptions {
+
+    /** @type {boolean} */
+    useStairs = true;
+
+}
+
+class RemoteRouter {
+
+    /**
+     * Get the router name
+     * @type {string} the router name
+     */
+    get rname() {
+        return 'Unknown';
+    }
+
+    /**
+     * @abstract
+     * @param {string} endpointUrl
+     * @param {string} mode see Constants.ITINERARY_MODE
+     * @param {Array<Coordinates>} waypoints
+     * @param {RemoteRouterOptions} options
+     * @returns {!RouterResponse}
+     */
+    // eslint-disable-next-line no-unused-vars
+    async getItineraries(endpointUrl, mode, waypoints, options = new RemoteRouterOptions()) {
+        throw new Error('RemoteRouter "' + this.rname + '" does not @override getItineraries()');
+    }
+
+}
+
+class OsrmRoutingModeCorrespondanceNotFound extends Error {
+
+    /**
+     * @param {!string} routingMode
+     */
+    constructor(routingMode) {
+        super(`OSRM routing mode correspondance not found: ${routingMode}`);
+    }
+}
+
+/* eslint-disable max-statements */
+
+/**
+ * Input mode correspondance
+ */
+const inputModeCorrespondance$2 = new Map();
+inputModeCorrespondance$2.set(Constants.ROUTING_MODE.CAR, 'driving');
+inputModeCorrespondance$2.set(Constants.ROUTING_MODE.WALK, 'walking');
+inputModeCorrespondance$2.set(Constants.ROUTING_MODE.BIKE, 'bike');
+inputModeCorrespondance$2.set(Constants.ROUTING_MODE.BUS, 'bus');
+inputModeCorrespondance$2.set(Constants.ROUTING_MODE.MULTI, 'walking');
+
+
+/**
+ * Singleton.
+ */
+class OsrmRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'osrm';
+    }
+
+    /**
+     * @override
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        const url = this.getURL(endpointUrl, mode, waypoints);
+        const response = await request(url);
+        return this.createRouterResponseFromJson(response, waypoints[0], waypoints[1]);
+    }
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     */
+    getURL(endpointUrl, mode, waypoints) {
+
+        const osrmMode = inputModeCorrespondance$2.get(mode);
+        if (!osrmMode) {
+            throw new OsrmRoutingModeCorrespondanceNotFound(mode);
+        }
+
+        let url = endpointUrl + '/route/v1/' + osrmMode + '/';
+        url += waypoints.map(waypoint => [waypoint.longitude + ',' + waypoint.latitude]).join(';');
+        url += '?geometries=geojson&overview=full&steps=true';
+
+        return url;
+    }
+
+    /**
+     * @param {Coordinates} coordinates
+     * @returns {object}
+     */
+    coordinatesToJson(coordinates) {
+        const output = [coordinates.lng, coordinates.lat];
+        if (coordinates.level) {
+            output.push(coordinates.level.toString());
+        }
+        return output;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Coordinates}
+     */
+    jsonToCoordinates(json) {
+        const output = new Coordinates(json[1], json[0]);
+        if (json.length > 2) {
+            output.level = Level.fromString(json[2]);
+        }
+        return output;
+    }
+
+    nodesToJsonCoords(nodes) {
+        return nodes.map(node => this.coordinatesToJson(node.coords));
+    }
+
+
+    getModifierFromAngle(_angle) {
+
+        const angle = positiveMod(rad2deg(_angle), 360);
+
+        if (angle > 0 && angle < 60) {
+            return 'sharp right';
+        }
+        if (angle >= 60 && angle < 140) {
+            return 'right';
+        }
+        if (angle >= 140 && angle < 160) {
+            return 'slight right';
+        }
+        if (angle >= 160 && angle <= 200) {
+            return 'straight';
+        }
+        if (angle > 200 && angle <= 220) {
+            return 'slight left';
+        }
+        if (angle > 220 && angle <= 300) {
+            return 'left';
+        }
+        if (angle > 300 && angle < 360) {
+            return 'sharp left';
+        }
+        return 'u turn';
+    }
+
+
+    noRouteFoundJson(message) {
+        return {
+            'code': 'NoRoute',
+            message
+        };
+    }
+
+    /**
+     * @param {Itinerary} itinerary
+     * @returns {object}
+     */
+    itineraryToOsrmJson(itinerary) {
+
+        const lastLegId = itinerary.legs.length - 1;
+
+        const jsonLegs = itinerary.legs.map(({ distance, duration, coords, steps }, idLeg) => {
+
+            const lastStepId = steps.length - 1;
+
+            return {
+                distance,
+                duration,
+                steps: steps.map((step, idStep, arr) => {
+
+                    let type = idStep === 0 && idLeg === 0 ? 'depart' : 'turn';
+                    type = idStep === lastStepId && idLeg === lastLegId ? 'arrive' : type;
+
+                    const stepCoordsIdx = coords.findIndex(p => p.equalsTo(step.coords));
+                    const nextStepCoordsIdx = idStep === lastStepId
+                        ? stepCoordsIdx
+                        : coords.findIndex(p => p.equalsTo(arr[idStep + 1].coords));
+
+                    const jsonStep = {
+                        geometry: {
+                            type: 'LineString',
+                            coordinates: coords.slice(stepCoordsIdx, nextStepCoordsIdx + 1).map(this.coordinatesToJson)
+                        },
+                        distance: step.distance,
+                        duration: step.duration,
+                        name: step.name,
+                        maneuver: {
+                            bearing_before: rad2deg(step.previousBearing),
+                            bearing_after: rad2deg(step.nextBearing),
+                            location: this.coordinatesToJson(step.coords),
+                            modifier: this.getModifierFromAngle(step.angle),
+                            type
+                        }
+                    };
+                    if (step.levelChange !== null) {
+                        jsonStep.levelChange = step.levelChange.toJson();
+                    }
+                    if (typeof step.extras === 'object' && Object.keys(step.extras).length !== 0) {
+                        jsonStep.extras = step.extras;
+                    }
+
+                    return jsonStep;
+                })
+            };
+        });
+
+        return {
+            'code': 'Ok',
+            'routes': [
+                {
+                    'geometry': {
+                        'type': 'LineString',
+                        'coordinates': itinerary.coords.map(this.coordinatesToJson)
+                    },
+                    'legs': jsonLegs,
+                    'distance': itinerary.distance,
+                    'duration': itinerary.duration,
+                    'weight_name': 'routability',
+                    'weight': 0
+                }
+            ],
+            'waypoints': []
+        };
+    }
+
+    /**
+     * @param {object} jsonSteps
+     * @param {Coordinates[]} legCoords
+     * @returns {Step[]}
+     */
+    parseJsonSteps(jsonSteps, legCoords) {
+
+        if (!jsonSteps) {
+            return [];
+        }
+
+        return jsonSteps.map(jsonStep => {
+
+            const step = new Step();
+            step.coords = this.jsonToCoordinates(jsonStep.maneuver.location);
+
+            // Sometimes, OSRM step does not have the same coordinates than a point in legCoords.
+            // ex: first step of https://routing.getwemap.com/route/v1/walking/2.33222164147,48.87084765712;2.3320734,48.8730212?geometries=geojson&overview=full&steps=true
+            // That is why we look for the closest point.
+            const distances = legCoords.map(coords => coords.distanceTo(step.coords));
+            const idStepCoordsInLeg = distances.indexOf(Math.min(...distances));
+            if (idStepCoordsInLeg < 0) {
+                throw new Error('Osrm Parser: Cannot find step coords in leg coordinates');
+            }
+            step._idCoordsInLeg = idStepCoordsInLeg;
+
+            step.name = jsonStep.name;
+            step.levelChange = jsonStep.levelChange ? LevelChange.fromJson(jsonStep.levelChange) : null;
+
+            step.distance = jsonStep.distance;
+            step.duration = jsonStep.duration;
+
+            if (jsonStep.extras && jsonStep.extras.subwayEntrance) {
+                step.extras.subwayEntrance = true;
+                if (jsonStep.extras.subwayEntranceRef) {
+                    step.extras.subwayEntranceRef = jsonStep.extras.subwayEntranceRef;
+                }
+            }
+
+            return step;
+        });
+    }
+
+    /**
+     * Generate multi itineraries from OSRM JSON
+     * @param {object} json JSON file provided by OSRM.
+     * @param {Coordinates} from itinerary start
+     * @param {Coordinates} to itinerary end
+     * @param {?string} routingMode [walking|driving|bicycle]
+     * @returns {?RouterResponse}
+     */
+    createRouterResponseFromJson(json, from, to, routingMode = 'walking') {
+        const { routes: jsonRoutes } = json;
+
+        if (!jsonRoutes) {
+            return null;
+        }
+
+        const routingModeCorrespondance = new Map();
+        routingModeCorrespondance.set('walking', 'WALK');
+        routingModeCorrespondance.set('driving', 'CAR');
+        routingModeCorrespondance.set('bicycle', 'BIKE');
+        const mode = routingModeCorrespondance.get(routingMode) || null;
+
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
+
+        routerResponse.from = from;
+        routerResponse.to = to;
+
+        for (const jsonItinerary of jsonRoutes) {
+
+            const itinerary = new Itinerary();
+
+            // itinerary.coords = jsonItinerary.geometry.coordinates.map(jsonToCoordinates);
+            itinerary.distance = jsonItinerary.distance;
+            itinerary.duration = jsonItinerary.duration;
+            itinerary.from = from;
+            itinerary.to = to;
+
+            routerResponse.itineraries.push(itinerary);
+
+            for (const jsonLeg of jsonItinerary.legs) {
+
+                const leg = new Leg();
+
+                leg.mode = mode;
+                leg.distance = jsonLeg.distance;
+                leg.duration = jsonLeg.duration;
+
+                leg.coords = jsonLeg.steps
+                    .map(step => step.geometry.coordinates.map(this.jsonToCoordinates))
+                    .flat()
+                    // Remove duplicates
+                    .filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equalsTo(coords));
+
+                leg.from = {
+                    name: null,
+                    coords: leg.coords[0]
+                };
+                leg.to = {
+                    name: null,
+                    coords: leg.coords[leg.coords.length - 1]
+                };
+
+                leg.steps = this.parseJsonSteps(jsonLeg.steps, leg.coords);
+
+                itinerary.legs.push(leg);
+            }
+
+            // All legs have to be parsed before computing steps metadata
+            generateStepsMetadata(itinerary);
+
+        }
+
+        return routerResponse;
+    }
+}
+
+var OsrmRemoteRouter$1 = new OsrmRemoteRouter();
+
+class OtpRoutingModeCorrespondanceNotFound extends Error {
+
+    /**
+     * @param {!string} routingMode
+     */
+    constructor(routingMode) {
+        super(`OTP routing mode correspondance not found: ${routingMode}`);
+    }
+}
+
+/* eslint-disable max-statements */
+
+/**
+ * Input mode correspondance
+ */
+const inputModeCorrespondance$1 = new Map();
+inputModeCorrespondance$1.set(Constants.ROUTING_MODE.CAR, 'CAR');
+inputModeCorrespondance$1.set(Constants.ROUTING_MODE.WALK, 'WALK');
+inputModeCorrespondance$1.set(Constants.ROUTING_MODE.BIKE, 'BICYCLE');
+inputModeCorrespondance$1.set(Constants.ROUTING_MODE.BUS, 'WALK,TRANSIT');
+inputModeCorrespondance$1.set(Constants.ROUTING_MODE.MULTI, 'WALK,TRANSIT');
+
+/**
+ * Singleton.
+ */
+class OtpRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'otp';
+    }
+
+    /**
+     * @override
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        const url = this.getURL(endpointUrl, mode, waypoints);
+        const response = await request(url);
+        return this.createRouterResponseFromJson(response);
+    }
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     */
+    getURL(endpointUrl, mode, waypoints) {
+
+        const otpMode = inputModeCorrespondance$1.get(mode);
+        if (!otpMode) {
+            throw new OtpRoutingModeCorrespondanceNotFound(mode);
+        }
+
+        if (waypoints.length > 2) {
+            Logger.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}`;
+        const queryMode = `mode=${otpMode}`;
+
+        const url = new URL(endpointUrl);
+        let { search } = url;
+        search = (search ? `${search}&` : '?') + `${fromPlace}&${toPlace}&${queryMode}`;
+
+        return `${url.origin}${url.pathname}${search}`;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Coordinates}
+     */
+    jsonToCoordinates(json) {
+        return new Coordinates(json.lat, json.lon);
+    }
+
+    /**
+     * @param {object} jsonSteps
+     * @param {Coordinates[]} legCoords
+     * @returns {Step[]}
+     */
+    parseJsonSteps(jsonSteps, legCoords) {
+
+        if (!jsonSteps) {
+            return [];
+        }
+
+        return jsonSteps.map(jsonStep => {
+
+            const step = new Step();
+            const stepCoords = this.jsonToCoordinates(jsonStep);
+
+            // OTP step does not have the same coordinates than a point in legCoords.
+            // That is why we look for the closest point.
+            const distances = legCoords.map(coords => coords.distanceTo(stepCoords));
+            const idStepCoordsInLeg = distances.indexOf(Math.min(...distances));
+            if (idStepCoordsInLeg < 0) {
+                throw new Error('OTP Parser: Cannot find closest step');
+            }
+            step.coords = legCoords[idStepCoordsInLeg];
+            step._idCoordsInLeg = idStepCoordsInLeg;
+
+            step.name = jsonStep.streetName;
+            step.levelChange = null;
+
+            step.distance = jsonStep.distance;
+
+            return step;
+        });
+    }
+
+    /**
+     * Generate multi itineraries from OTP JSON
+     * @param {object} json JSON file provided by OTP.
+     * @returns {?RouterResponse}
+     */
+    createRouterResponseFromJson(json) {
+
+        const { plan: jsonPlan } = json;
+
+        if (!jsonPlan) {
+            return null;
+        }
+
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
+
+        routerResponse.from = this.jsonToCoordinates(jsonPlan.from);
+        routerResponse.to = this.jsonToCoordinates(jsonPlan.to);
+
+        for (const jsonItinerary of jsonPlan.itineraries) {
+
+            const itinerary = new Itinerary();
+
+            itinerary.duration = jsonItinerary.duration;
+            itinerary.startTime = jsonItinerary.startTime;
+            itinerary.endTime = jsonItinerary.endTime;
+            itinerary.from = routerResponse.from;
+            itinerary.to = routerResponse.to;
+
+            routerResponse.itineraries.push(itinerary);
+
+            for (const jsonLeg of jsonItinerary.legs) {
+
+                const leg = new Leg();
+
+                leg.mode = jsonLeg.mode;
+                leg.duration = jsonLeg.duration;
+                leg.startTime = jsonLeg.startTime;
+                leg.endTime = jsonLeg.endTime;
+                leg.from = {
+                    name: jsonLeg.from.name,
+                    coords: this.jsonToCoordinates(jsonLeg.from)
+                };
+                leg.to = {
+                    name: jsonLeg.to.name,
+                    coords: this.jsonToCoordinates(jsonLeg.to)
+                };
+                leg.coords = Polyline.decode(jsonLeg.legGeometry.points).map(([lat, lon]) => new Coordinates(lat, lon));
+
+                leg.steps = this.parseJsonSteps(jsonLeg.steps, leg.coords);
+
+                if (leg.mode === 'BUS' || leg.mode === 'TRAM') {
+                    leg.transportInfo = {
+                        name: jsonLeg.route,
+                        routeColor: jsonLeg.routeColor,
+                        routeTextColor: jsonLeg.routeTextColor,
+                        directionName: jsonLeg.headsign
+                    };
+
+                    const legStep = new Step();
+                    legStep.coords = leg.coords[0];
+                    legStep._idCoordsInLeg = 0;
+                    legStep.name = jsonLeg.headsign;
+                    legStep.levelChange = null;
+                    legStep.distance = jsonLeg.distance;
+                    leg.steps = [legStep];
+                }
+
+                // jsonLeg.distance is not reliable when compared to the array of leg coords.
+                // leg.distance = jsonLeg.distance;
+                leg.distance = leg.coords.reduce((acc, coords, idx, arr) => {
+                    if (idx === 0) {
+                        return acc;
+                    }
+                    return acc + arr[idx - 1].distanceTo(coords);
+                }, 0);
+
+                itinerary.legs.push(leg);
+
+            }
+
+            itinerary.distance = itinerary.coords.reduce((acc, coords, idx, arr) => {
+                if (idx === 0) {
+                    return acc;
+                }
+                return acc + arr[idx - 1].distanceTo(coords);
+            }, 0);
+
+            // All legs have to be parsed before computing steps metadata
+            generateStepsMetadata(itinerary);
+        }
+
+        return routerResponse;
+    }
+}
+
+var OtpRemoteRouter$1 = new OtpRemoteRouter();
+
+class CitywayRoutingModeCorrespondanceNotFound extends Error {
+
+    /**
+     * @param {!string} routingMode
+     */
+    constructor(routingMode) {
+        super(`Cityway routing mode correspondance not found: ${routingMode}`);
+    }
+}
+
+/* eslint-disable max-depth */
+
+/**
+ * Input mode correspondance
+ */
+const inputModeCorrespondance = new Map();
+inputModeCorrespondance.set(Constants.ROUTING_MODE.CAR, 'Car');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.WALK, 'Walk');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.BIKE, 'Bike');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.BUS, 'PT');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.MULTI, 'PT');
+
+
+/**
+ * List of all routing modes supported by the API
+ */
+const routingModeCorrespondance$1 = new Map();
+routingModeCorrespondance$1.set('WALK', Constants.ROUTING_MODE.WALK);
+routingModeCorrespondance$1.set('BICYCLE', Constants.ROUTING_MODE.BIKE);
+routingModeCorrespondance$1.set('TRAMWAY', Constants.ROUTING_MODE.TRAM);
+routingModeCorrespondance$1.set('METRO', Constants.ROUTING_MODE.METRO);
+routingModeCorrespondance$1.set('FUNICULAR', Constants.ROUTING_MODE.FUNICULAR);
+routingModeCorrespondance$1.set('BUS', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('COACH', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('SCHOOL', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('BUS_PMR', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('MINIBUS', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('TROLLEY_BUS', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('TAXIBUS', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('SHUTTLE', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance$1.set('TRAIN', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance$1.set('HST', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance$1.set('LOCAL_TRAIN', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance$1.set('AIR', Constants.ROUTING_MODE.AIRPLANE);
+routingModeCorrespondance$1.set('FERRY', Constants.ROUTING_MODE.BOAT);
+routingModeCorrespondance$1.set('TAXI', Constants.ROUTING_MODE.UNKNOWN);
+routingModeCorrespondance$1.set('CAR_POOL', Constants.ROUTING_MODE.UNKNOWN);
+routingModeCorrespondance$1.set('PRIVATE_VEHICLE', Constants.ROUTING_MODE.CAR);
+routingModeCorrespondance$1.set('SCOOTER', Constants.ROUTING_MODE.MOTO);
+
+/**
+ * List of all plan trip supported by the API
+ * Routing mode UNKNOWN means that the itinerary will not be parsed by the router
+ */
+const planTripType = new Map();
+planTripType.set(0, Constants.ROUTING_MODE.BUS);
+planTripType.set(1, Constants.ROUTING_MODE.WALK);
+planTripType.set(2, Constants.ROUTING_MODE.BIKE);
+planTripType.set(3, Constants.ROUTING_MODE.CAR);
+planTripType.set(4, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(5, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(6, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(7, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(8, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(9, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(10, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(11, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(12, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(13, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(14, Constants.ROUTING_MODE.UNKNOWN);
+
+
+/**
+ * Singleton.
+ */
+class CitywayRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'cityway';
+    }
+
+
+    /**
+     * @override
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        const url = this.getURL(endpointUrl, mode, waypoints);
+        const response = await request(url);
+        return this.createRouterResponseFromJson(response);
+    }
+
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     */
+    getURL(endpointUrl, mode, waypoints) {
+        const citywayMode = inputModeCorrespondance.get(mode);
+        if (!citywayMode) {
+            throw new CitywayRoutingModeCorrespondanceNotFound(mode);
+        }
+        if (waypoints.length > 2) {
+            Logger.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}`;
+        const queryMode = `TripModes=${citywayMode}`;
+
+        const url = new URL(endpointUrl);
+        let { search } = url;
+        search = (search ? `${search}&` : '?') + `${fromPlace}&${toPlace}&${queryMode}`;
+
+        return `${url.origin}${url.pathname}${search}`;
+    }
+
+    /**
+     * Generate multi itineraries from Cityway JSON
+     * @param {object} json JSON file provided by Cityway.
+     * @returns {?RouterResponse}
+     * @example https://preprod.api.lia2.cityway.fr/journeyplanner/api/opt/PlanTrips/json?DepartureLatitude=49.51509388236216&DepartureLongitude=0.09341749619366316&ArrivalLatitude=49.5067090188444&ArrivalLongitude=0.1694842115417831&DepartureType=COORDINATES&ArrivalType=COORDINATES
+     */
+    createRouterResponseFromJson(json) {
+
+        if (json.StatusCode !== 200 || !json.Data || !json.Data.length) {
+            return null;
+        }
+
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
+
+
+        // Do not know if it the best approach, but it works...
+        const allJsonTrips = json.Data.reduce((acc, dataObj) => {
+            acc.push(...dataObj.response.trips.Trip.map(trip => ({
+                ...trip,
+                ...(dataObj.hasOwnProperty('PlanTripType') ? { PlanTripType: dataObj.PlanTripType } : {})
+            })));
+            return acc;
+        }, []);
+
+        // eslint-disable-next-line no-labels
+        itineraryLoop:
+        for (const trip of allJsonTrips) {
+
+            if (trip.hasOwnProperty('PlanTripType') && planTripType.get(trip.PlanTripType) === Constants.ROUTING_MODE.UNKNOWN) {
+                continue;
+            }
+
+            const itinerary = new Itinerary();
+
+            itinerary.duration = this.parseDuration(trip.Duration);
+            itinerary.startTime = this.jsonDateToTimestamp(trip.Departure.Time);
+            itinerary.from = this.jsonToCoordinates(trip.Departure.Site.Position);
+            itinerary.endTime = this.jsonDateToTimestamp(trip.Arrival.Time);
+            itinerary.to = this.jsonToCoordinates(trip.Arrival.Site.Position);
+
+            for (const jsonSection of trip.sections.Section) {
+
+                const jsonLeg = jsonSection.Leg ? jsonSection.Leg : jsonSection.PTRide;
+
+                const leg = new Leg();
+
+                leg.mode = routingModeCorrespondance$1.get(jsonLeg.TransportMode);
+                leg.duration = this.parseDuration(jsonLeg.Duration);
+                leg.startTime = this.jsonDateToTimestamp(jsonLeg.Departure.Time);
+                leg.endTime = this.jsonDateToTimestamp(jsonLeg.Arrival.Time);
+                leg.coords = [];
+
+                if (leg.mode === Constants.ROUTING_MODE.UNKNOWN) {
+                    // eslint-disable-next-line
+                    continue itineraryLoop;
+                }
 
-    const lastLegId = itinerary.legs.length - 1;
+                if (leg.mode === Constants.ROUTING_MODE.WALK
+                    || leg.mode === Constants.ROUTING_MODE.BIKE
+                    || leg.mode === Constants.ROUTING_MODE.CAR) {
+
+                    leg.from = {
+                        name: jsonLeg.Departure.Site.Name,
+                        coords: this.jsonToCoordinates(jsonLeg.Departure.Site.Position)
+                    };
+                    leg.to = {
+                        name: jsonLeg.Arrival.Site.Name,
+                        coords: this.jsonToCoordinates(jsonLeg.Arrival.Site.Position)
+                    };
+
+                    leg.steps = [];
+                    for (const jsonPathLink of jsonLeg.pathLinks.PathLink) {
+                        const step = new Step();
+                        let stepCoords;
+                        if (jsonPathLink.Geometry) {
+                            stepCoords = this.parseWKTGeometry(jsonPathLink.Geometry);
+                        } else {
+                            stepCoords = [leg.from.coords, leg.to.coords];
+                        }
+                        step.coords = stepCoords[0];
+                        step._idCoordsInLeg = leg.coords.length;
+                        stepCoords.forEach((coords, idx) => {
+                            if (
+                                idx !== 0
+                                || leg.coords.length === 0
+                                || !leg.coords[leg.coords.length - 1].equalsTo(coords)
+                            ) {
+                                leg.coords.push(coords);
+                            }
+                        });
 
-    const jsonLegs = itinerary.legs.map(({ distance, duration, coords, steps }, idLeg) => {
 
-        const lastStepId = steps.length - 1;
+                        step.name = jsonPathLink.Departure.Site.Name;
+                        step.levelChange = null;
 
-        return {
-            distance,
-            duration,
-            steps: steps.map((step, idStep, arr) => {
-
-                let type = idStep === 0 && idLeg === 0 ? 'depart' : 'turn';
-                type = idStep === lastStepId && idLeg === lastLegId ? 'arrive' : type;
-
-                const stepCoordsIdx = coords.findIndex(p => p.equalsTo(step.coords));
-                const nextStepCoordsIdx = idStep === lastStepId
-                    ? stepCoordsIdx
-                    : coords.findIndex(p => p.equalsTo(arr[idStep + 1].coords));
-
-                const jsonStep = {
-                    geometry: {
-                        type: 'LineString',
-                        coordinates: coords.slice(stepCoordsIdx, nextStepCoordsIdx + 1).map(coordinatesToJson)
-                    },
-                    distance: step.distance,
-                    duration: step.duration,
-                    name: step.name,
-                    maneuver: {
-                        bearing_before: rad2deg(step.previousBearing),
-                        bearing_after: rad2deg(step.nextBearing),
-                        location: coordinatesToJson(step.coords),
-                        modifier: getModifierFromAngle(step.angle),
-                        type
+                        step.distance = jsonPathLink.Distance;
+
+                        leg.steps.push(step);
                     }
-                };
-                if (step.levelChange !== null) {
-                    jsonStep.levelChange = step.levelChange.toJson();
-                }
-                if (typeof step.extras === 'object' && Object.keys(step.extras).length !== 0) {
-                    jsonStep.extras = step.extras;
+
+                } else if (Constants.PUBLIC_TRANSPORT.includes(leg.mode)) {
+
+                    leg.from = {
+                        name: jsonLeg.Departure.StopPlace.Name,
+                        coords: this.jsonToCoordinates(jsonLeg.Departure.StopPlace.Position)
+                    };
+                    leg.to = {
+                        name: jsonLeg.Arrival.StopPlace.Name,
+                        coords: this.jsonToCoordinates(jsonLeg.Arrival.StopPlace.Position)
+                    };
+
+                    let transportName = jsonLeg.Line.Number;
+                    if (leg.mode === Constants.ROUTING_MODE.TRAM && transportName.toLowerCase().includes('tram')) {
+                        // In order to remove the "TRAM " prefix.
+                        transportName = transportName.substr(5);
+                    }
+
+                    leg.transportInfo = {
+                        name: transportName,
+                        routeColor: jsonLeg.Line.Color,
+                        routeTextColor: jsonLeg.Line.TextColor,
+                        directionName: jsonLeg.Destination
+                    };
+
+                    for (const jsonStep of jsonLeg.steps.Step) {
+                        const stepCoords = this.parseWKTGeometry(jsonStep.Geometry);
+                        stepCoords.forEach((coords, idx) => {
+                            if (
+                                idx !== 0
+                                || leg.coords.length === 0
+                                || !leg.coords[leg.coords.length - 1].equalsTo(coords)
+                            ) {
+                                leg.coords.push(coords);
+                            }
+                        });
+                    }
+
+                    const legStep = new Step();
+                    legStep.coords = leg.coords[0];
+                    legStep._idCoordsInLeg = 0;
+                    legStep.name = jsonLeg.Line.Name;
+                    legStep.levelChange = null;
+                    legStep.distance = jsonLeg.Distance;
+                    leg.steps = [legStep];
+                } else {
+                    Logger.warn(`[CitywayParser] Unknown leg mode: ${jsonLeg.TransportMode}`);
                 }
 
-                return jsonStep;
-            })
-        };
-    });
+                leg.distance = leg.coords.reduce((acc, coords, idx, arr) => {
+                    if (idx === 0) {
+                        return acc;
+                    }
+                    return acc + arr[idx - 1].distanceTo(coords);
+                }, 0);
+
+                itinerary.legs.push(leg);
 
-    return {
-        'code': 'Ok',
-        'routes': [
-            {
-                'geometry': {
-                    'type': 'LineString',
-                    'coordinates': itinerary.coords.map(coordinatesToJson)
-                },
-                'legs': jsonLegs,
-                'distance': itinerary.distance,
-                'duration': itinerary.duration,
-                'weight_name': 'routability',
-                'weight': 0
             }
-        ],
-        'waypoints': []
-    };
-}
 
+            routerResponse.itineraries.push(itinerary);
 
-/**
- * @param {object} jsonSteps
- * @param {Coordinates[]} legCoords
- * @returns {Step[]}
- */
-function parseJsonSteps$1(jsonSteps, legCoords) {
+            itinerary.distance = itinerary.coords.reduce((acc, coords, idx, arr) => {
+                if (idx === 0) {
+                    return acc;
+                }
+                return acc + arr[idx - 1].distanceTo(coords);
+            }, 0);
 
-    if (!jsonSteps) {
-        return [];
-    }
+            // All legs have to be parsed before computing steps metadata
+            generateStepsMetadata(itinerary);
+        }
 
-    return jsonSteps.map(jsonStep => {
+        routerResponse.from = routerResponse.itineraries[0].from;
+        routerResponse.to = routerResponse.itineraries[routerResponse.itineraries.length - 1].to;
 
-        const step = new Step();
-        step.coords = jsonToCoordinates$2(jsonStep.maneuver.location);
+        return routerResponse;
+    }
 
-        // Sometimes, OSRM step does not have the same coordinates than a point in legCoords.
-        // ex: first step of https://routing.getwemap.com/route/v1/walking/2.33222164147,48.87084765712;2.3320734,48.8730212?geometries=geojson&overview=full&steps=true
-        // That is why we look for the closest point.
-        const distances = legCoords.map(coords => coords.distanceTo(step.coords));
-        const idStepCoordsInLeg = distances.indexOf(Math.min(...distances));
-        if (idStepCoordsInLeg < 0) {
-            throw new Error('Osrm Parser: Cannot find step coords in leg coordinates');
-        }
-        step._idCoordsInLeg = idStepCoordsInLeg;
+    /**
+     * @param {object} json
+     * @returns {Coordinates}
+     */
+    jsonToCoordinates(json) {
+        return new Coordinates(json.Lat, json.Long);
+    }
 
-        step.name = jsonStep.name;
-        step.levelChange = jsonStep.levelChange ? LevelChange.fromJson(jsonStep.levelChange) : null;
+    /**
+     * @param {string} jsonDate
+     * @returns {number}
+     */
+    jsonDateToTimestamp(jsonDate) {
+        const [dateStr, timeStr] = jsonDate.split(' ');
+        const [dayStr, monthStr, yearStr] = dateStr.split('/');
+        const [hoursStr, minutesStr, secondsStr] = timeStr.split(':');
+
+        return dateWithTimeZone(
+            Number(yearStr),
+            Number(monthStr) - 1,
+            Number(dayStr),
+            Number(hoursStr),
+            Number(minutesStr),
+            Number(secondsStr)
+        ).getTime();
+    }
 
-        step.distance = jsonStep.distance;
-        step.duration = jsonStep.duration;
+    /**
+     * @param {string} wktGeometry
+     * @returns {Coordinates[]}
+     */
+    parseWKTGeometry(wktGeometry) {
+        const tmpCoordsStr = wktGeometry.match(/LINESTRING \((.*)\)/i);
+        const tmpCoordsPt = wktGeometry.match(/POINT \((.*)\)/i);
+        if (!tmpCoordsStr && !tmpCoordsPt) {
+            return null;
+        }
 
-        if (jsonStep.extras && jsonStep.extras.subwayEntrance) {
-            step.extras.subwayEntrance = true;
-            if (jsonStep.extras.subwayEntranceRef) {
-                step.extras.subwayEntranceRef = jsonStep.extras.subwayEntranceRef;
-            }
+        if (tmpCoordsPt) {
+            const [lng, lat] = tmpCoordsPt[1].split(' ');
+            return [new Coordinates(Number(lat), Number(lng))];
         }
 
-        return step;
-    });
+        return tmpCoordsStr[1].split(',').map(str => {
+            const sp = str.trim().split(' ');
+            return new Coordinates(Number(sp[1]), Number(sp[0]));
+        });
+    }
+
+    /**
+     * @param {string} iso8601Duration
+     * @see https://stackoverflow.com/a/29153059/2239938
+     */
+    parseDuration(iso8601Duration) {
+        const iso8601DurationRegex = /(-)?P(?:([.,\d]+)Y)?(?:([.,\d]+)M)?(?:([.,\d]+)W)?(?:([.,\d]+)D)?T(?:([.,\d]+)H)?(?:([.,\d]+)M)?(?:([.,\d]+)S)?/;
+
+        var matches = iso8601Duration.match(iso8601DurationRegex);
+
+        // const sign = typeof matches[1] === 'undefined' ? '+' : '-',
+        const years = typeof matches[2] === 'undefined' ? 0 : Number(matches[2]);
+        const months = typeof matches[3] === 'undefined' ? 0 : Number(matches[3]);
+        const weeks = typeof matches[4] === 'undefined' ? 0 : Number(matches[4]);
+        const days = typeof matches[5] === 'undefined' ? 0 : Number(matches[5]);
+        const hours = typeof matches[6] === 'undefined' ? 0 : Number(matches[6]);
+        const minutes = typeof matches[7] === 'undefined' ? 0 : Number(matches[7]);
+        const seconds = typeof matches[8] === 'undefined' ? 0 : Number(matches[8]);
+
+        return seconds
+            + minutes * 60
+            + hours * 3600
+            + days * 86400
+            + weeks * (86400 * 7)
+            + months * (86400 * 30)
+            + years * (86400 * 365.25);
+    }
 }
 
+var CitywayRemoteRouter$1 = new CitywayRemoteRouter();
+
+/* eslint-disable max-statements */
 
 /**
- * Generate multi itineraries from OSRM JSON
- * @param {object} json JSON file provided by OSRM.
- * @param {Coordinates} from itinerary start
- * @param {Coordinates} to itinerary end
- * @param {?string} routingMode [walking|driving|bicycle]
- * @returns {?RouterResponse}
+ * Singleton.
  */
-function createRouterResponseFromJson$3(json, from, to, routingMode = 'walking') {
+class DeutscheBahnRemoteRouter extends RemoteRouter {
 
-    const { routes: jsonRoutes } = json;
+    /**
+     * @override
+     */
+    get rname() {
+        return 'deutsche-bahn';
+    }
 
-    if (!jsonRoutes) {
-        return null;
+    /**
+     * @override
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        const url = this.getURL(endpointUrl, mode, waypoints);
+        const response = await request(url);
+        return this.createRouterResponseFromJson(response, waypoints[0], waypoints[1]);
     }
 
-    const routingModeCorrespondance = new Map();
-    routingModeCorrespondance.set('walking', 'WALK');
-    routingModeCorrespondance.set('driving', 'CAR');
-    routingModeCorrespondance.set('bicycle', 'BIKE');
-    const mode = routingModeCorrespondance.get(routingMode) || null;
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     */
+    getURL(endpointUrl, mode, waypoints) {
+        let url = endpointUrl + '/route/v1/' + mode + '/';
 
-    const routerResponse = new RouterResponse();
-    routerResponse.routerName = 'osrm';
+        url += waypoints.map(waypoint => {
+            if (waypoint.level) {
+                const altitude = waypoint.level.isRange ? waypoint.level.low : waypoint.level.val;
 
-    routerResponse.from = from;
-    routerResponse.to = to;
+                return waypoint.longitude + ',' + waypoint.latitude + ',' + altitude;
+            }
 
-    for (const jsonItinerary of jsonRoutes) {
+            return waypoint.longitude + ',' + waypoint.latitude;
+        }).join(';');
 
-        const itinerary = new Itinerary();
+        url += '?geometries=geojson&overview=full&steps=true';
 
-        // itinerary.coords = jsonItinerary.geometry.coordinates.map(jsonToCoordinates);
-        itinerary.distance = jsonItinerary.distance;
-        itinerary.duration = jsonItinerary.duration;
-        itinerary.from = from;
-        itinerary.to = to;
+        return url;
+    }
 
-        routerResponse.itineraries.push(itinerary);
+    /**
+     * Generate multi itineraries from the DB JSON
+     * @param {object} json JSON file provided by the DB.
+     * @param {Coordinates} from itinerary start
+     * @param {Coordinates} to itinerary end
+     * @returns {?RouterResponse}
+     */
+    createRouterResponseFromJson(json, from, to) {
 
-        for (const jsonLeg of jsonItinerary.legs) {
+        const { segments: jsonSegments } = json;
 
-            const leg = new Leg();
+        if (!jsonSegments) {
+            return null;
+        }
 
-            leg.mode = mode;
-            leg.distance = jsonLeg.distance;
-            leg.duration = jsonLeg.duration;
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
 
-            leg.coords = jsonLeg.steps
-                .map(step => step.geometry.coordinates.map(jsonToCoordinates$2))
-                .flat()
-                // Remove duplicates
-                .filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equalsTo(coords));
+        routerResponse.from = from;
+        routerResponse.to = to;
 
-            leg.from = {
-                name: null,
-                coords: leg.coords[0]
-            };
-            leg.to = {
-                name: null,
-                coords: leg.coords[leg.coords.length - 1]
-            };
+        /** @type {GraphEdge<OsmElement>[]} */
+        const edges = [];
+
+        /** @type {GraphNode<OsmElement>[]} */
+        const nodes = [];
+
+        /** @type {number[]} */
+        const edgesWeights = [];
+
+        let id = 1;
+        for (const jsonSegment of jsonSegments) {
+
+            const level = new Level(jsonSegment.fromLevel, jsonSegment.toLevel);
+            const osmWay = new OsmWay(id++, null, level);
+
+            for (const jsonPoint of jsonSegment.polyline) {
+                const coord = new Coordinates(jsonPoint.lat, jsonPoint.lon, null, level);
+
+                if (nodes.length !== 0
+                    && nodes[nodes.length - 1].coords.equalsTo(coord)) {
+                    continue;
+                }
 
-            leg.steps = parseJsonSteps$1(jsonLeg.steps, leg.coords);
+                const osmNode = new OsmNode(id++, coord);
+                const node = new GraphNode(osmNode.coords, osmNode);
 
-            itinerary.legs.push(leg);
+                if (nodes.length !== 0) {
+                    const prevNode = nodes[nodes.length - 1];
+                    const edge = new GraphEdge(prevNode, node, level, osmWay);
+                    edges.push(edge);
+                    edgesWeights.push(prevNode.coords.distanceTo(osmNode));
+                }
+
+                nodes.push(node);
+
+            }
         }
 
+        /** @type {GraphItinerary<OsmElement>} */
+        const graphItinerary = new GraphItinerary();
+        graphItinerary.nodes = nodes;
+        graphItinerary.edges = edges;
+        graphItinerary.edgesWeights = edgesWeights;
+        graphItinerary.start = nodes[0].coords;
+        graphItinerary.end = nodes[nodes.length - 1].coords;
+
+        const points = nodes.map(node => node.coords);
+        const itinerary = Itinerary.fromOrderedCoordinates(points, from, to);
+        itinerary.legs[0].steps = WemapStepsGeneration.fromGraphItinerary(graphItinerary);
+        itinerary.legs[0].steps.map((step, idx) => (step._idCoordsInLeg = idx));
+
         // All legs have to be parsed before computing steps metadata
         generateStepsMetadata(itinerary);
 
-    }
+        routerResponse.itineraries.push(itinerary);
 
-    return routerResponse;
+        return routerResponse;
+    }
 }
 
-var OsrmUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    coordinatesToJson: coordinatesToJson,
-    jsonToCoordinates: jsonToCoordinates$2,
-    nodesToJsonCoords: nodesToJsonCoords,
-    getModifierFromAngle: getModifierFromAngle,
-    noRouteFoundJson: noRouteFoundJson,
-    itineraryToOsrmJson: itineraryToOsrmJson,
-    createRouterResponseFromJson: createRouterResponseFromJson$3
-});
+var DeutscheBahnRemoteRouter$1 = new DeutscheBahnRemoteRouter();
 
 /* eslint-disable max-statements */
 
 /**
- * @param {object} json
- * @returns {Coordinates}
+ * List of all modes supported by the API
+ * http://doc.navitia.io/#physical-mode
+ */
+
+const routingModeCorrespondance = new Map();
+routingModeCorrespondance.set('Air', Constants.ROUTING_MODE.AIRPLANE);
+routingModeCorrespondance.set('Boat', Constants.ROUTING_MODE.BOAT);
+routingModeCorrespondance.set('Bus', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('BusRapidTransit', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('Coach', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('Ferry', Constants.ROUTING_MODE.FERRY);
+routingModeCorrespondance.set('Funicular', Constants.ROUTING_MODE.FUNICULAR);
+routingModeCorrespondance.set('LocalTrain', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('LongDistanceTrain', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('Metro', Constants.ROUTING_MODE.METRO);
+routingModeCorrespondance.set('Métro', Constants.ROUTING_MODE.METRO);
+routingModeCorrespondance.set('RailShuttle', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('RapidTransit', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('Shuttle', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('SuspendedCableCar', Constants.ROUTING_MODE.FUNICULAR);
+routingModeCorrespondance.set('Taxi', Constants.ROUTING_MODE.TAXI);
+routingModeCorrespondance.set('Train', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('RER', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('Tramway', Constants.ROUTING_MODE.TRAM);
+routingModeCorrespondance.set('walking', Constants.ROUTING_MODE.WALK);
+routingModeCorrespondance.set('bike', Constants.ROUTING_MODE.BIKE);
+
+/**
+ * List of transports modes
+ */
+const TRANSPORT_IDS = [
+    'physical_mode:Air',
+    'physical_mode:Boat',
+    'physical_mode:Bus',
+    'physical_mode:BusRapidTransit',
+    'physical_mode:Coach',
+    'physical_mode:Ferry',
+    'physical_mode:Funicular',
+    'physical_mode:LocalTrain',
+    'physical_mode:LongDistanceTrain',
+    'physical_mode:Metro',
+    'physical_mode:RailShuttle',
+    'physical_mode:RapidTransit',
+    'physical_mode:Shuttle',
+    'physical_mode:SuspendedCableCar',
+    'physical_mode:Taxi',
+    'physical_mode:Train',
+    'physical_mode:Tramway'
+];
+
+const clientId = '539eec73-3bb5-4327-bb5e-a52672658592';
+const clientSecret = '899f4bb9-f1d5-45d3-9f67-530827bb6734';
+
+/**
+ * Get last item of a given array
+ * @param {Array} array
+ * @returns {any}
  */
-function jsonToCoordinates$1(json) {
-    return new Coordinates(json.lat, json.lon);
+function last(array) {
+    return array[array.length - 1];
 }
 
 /**
- * @param {object} jsonSteps
- * @param {Coordinates[]} legCoords
- * @returns {Step[]}
+ * Singleton.
  */
-function parseJsonSteps(jsonSteps, legCoords) {
+class IdfmRemoteRouter extends RemoteRouter {
 
-    if (!jsonSteps) {
-        return [];
+    isLogged = false;
+    token = null;
+    expiresAt = null;
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'idfm';
     }
 
-    return jsonSteps.map(jsonStep => {
+    /**
+     * @override
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        if (!this.canRequestService()) {
+            await this._connect();
+        }
 
-        const step = new Step();
-        const stepCoords = jsonToCoordinates$1(jsonStep);
+        const url = this.getURL(endpointUrl, mode, waypoints);
 
-        // OTP step does not have the same coordinates than a point in legCoords.
-        // That is why we look for the closest point.
-        const distances = legCoords.map(coords => coords.distanceTo(stepCoords));
-        const idStepCoordsInLeg = distances.indexOf(Math.min(...distances));
-        if (idStepCoordsInLeg < 0) {
-            throw new Error('OTP Parser: Cannot find closest step');
-        }
-        step.coords = legCoords[idStepCoordsInLeg];
-        step._idCoordsInLeg = idStepCoordsInLeg;
+        const response = await request(url, {
+            headers: { Authorization: 'Bearer ' + this.token }
+        });
 
-        step.name = jsonStep.streetName;
-        step.levelChange = null;
+        return this.createRouterResponseFromJson(response);
+    }
 
-        step.distance = jsonStep.distance;
+    _connect() {
 
-        return step;
-    });
-}
+        const details = {
+            'grant_type': 'client_credentials',
+            'scope': 'read-data',
+            'client_id': clientId,
+            'client_secret': clientSecret
+        };
 
-/**
- * Generate multi itineraries from OTP JSON
- * @param {object} json JSON file provided by OTP.
- * @returns {?RouterResponse}
- */
-function createRouterResponseFromJson$2(json) {
+        const data = new URLSearchParams();
+        for (const property in details) {
+            if (details.hasOwnProperty(property)) {
+                const encodedKey = encodeURIComponent(property);
+                const encodedValue = encodeURIComponent(details[property]);
+                data.append(encodedKey, encodedValue);
+            }
+        }
 
-    const { plan: jsonPlan } = json;
+        return request('https://idfm.getwemap.com/api/oauth/token', {
+            method: 'POST',
+            data
+        }).then((response) => {
+            if (response.access_token) {
+                this.token = response.access_token;
+                this.isLogged = true;
+                this.expiresAt = new Date(new Date().getTime() + response.expires_in * 1000);
+            }
+        });
+    }
 
-    if (!jsonPlan) {
-        return null;
+    canRequestService() {
+        return this.token && this.expiresAt && this.expiresAt - new Date() > 0;
     }
 
-    const routerResponse = new RouterResponse();
-    routerResponse.routerName = 'otp';
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     */
+    getURL(endpointUrl, mode, waypoints) {
 
-    routerResponse.from = jsonToCoordinates$1(jsonPlan.from);
-    routerResponse.to = jsonToCoordinates$1(jsonPlan.to);
+        if (waypoints.length > 2) {
+            Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+        }
 
-    for (const jsonItinerary of jsonPlan.itineraries) {
+        const fromPlace = `from=${waypoints[0].longitude};${waypoints[0].latitude}`;
+        const toPlace = `to=${waypoints[1].longitude};${waypoints[1].latitude}`;
+
+        let url = new URL(endpointUrl);
+        let { search } = url;
+        search = (search ? `${search}&` : '?') + `${fromPlace}&${toPlace}`;
+
+        let query = '';
+        switch (mode) {
+        case Constants.ITINERARY_MODE.FOOT:
+            query = this.getWalkingQuery();
+            break;
+        case Constants.ITINERARY_MODE.BIKE:
+            query = this.getBikeQuery();
+            break;
+        case Constants.ITINERARY_MODE.DRIVING:
+            query = this.getCarQuery();
+            break;
+        }
 
-        const itinerary = new Itinerary();
+        url = `${url.origin}${url.pathname}${search}${query}`;
 
-        itinerary.duration = jsonItinerary.duration;
-        itinerary.startTime = jsonItinerary.startTime;
-        itinerary.endTime = jsonItinerary.endTime;
-        itinerary.from = routerResponse.from;
-        itinerary.to = routerResponse.to;
+        return url;
+    }
 
-        routerResponse.itineraries.push(itinerary);
+    getCarQuery() {
+        const forbiddenTransport = TRANSPORT_IDS.map((id) => `forbidden_uris[]=${id}`).join('&');
+        const allowCar = 'first_section_mode[]=walking&first_section_mode[]=car&last_section_mode[]=walking&last_section_mode[]=car';
 
-        for (const jsonLeg of jsonItinerary.legs) {
+        return `&${forbiddenTransport}&${allowCar}`;
+    }
 
-            const leg = new Leg();
+    getWalkingQuery() {
+        const forbiddenTransport = TRANSPORT_IDS.map((id) => `forbidden_uris[]=${id}`).join('&');
+        const allowWalking = 'first_section_mode[]=walking&last_section_mode[]=walking';
 
-            leg.mode = jsonLeg.mode;
-            leg.duration = jsonLeg.duration;
-            leg.startTime = jsonLeg.startTime;
-            leg.endTime = jsonLeg.endTime;
-            leg.from = {
-                name: jsonLeg.from.name,
-                coords: jsonToCoordinates$1(jsonLeg.from)
-            };
-            leg.to = {
-                name: jsonLeg.to.name,
-                coords: jsonToCoordinates$1(jsonLeg.to)
-            };
-            leg.coords = Polyline.decode(jsonLeg.legGeometry.points).map(([lat, lon]) => new Coordinates(lat, lon));
+        return `&${forbiddenTransport}&${allowWalking}`;
+    }
 
-            leg.steps = parseJsonSteps(jsonLeg.steps, leg.coords);
+    getBikeQuery() {
+        const forbiddenTransport = TRANSPORT_IDS.map((id) => `forbidden_uris[]=${id}`).join('&');
+        const allowBike = 'first_section_mode[]=bike&last_section_mode[]=bike';
 
-            if (leg.mode === 'BUS' || leg.mode === 'TRAM') {
-                leg.transportInfo = {
-                    name: jsonLeg.route,
-                    routeColor: jsonLeg.routeColor,
-                    routeTextColor: jsonLeg.routeTextColor,
-                    directionName: jsonLeg.headsign
-                };
+        return `&${forbiddenTransport}&${allowBike}`;
+    }
 
-                const legStep = new Step();
-                legStep.coords = leg.coords[0];
-                legStep._idCoordsInLeg = 0;
-                legStep.name = jsonLeg.headsign;
-                legStep.levelChange = null;
-                legStep.distance = jsonLeg.distance;
-                leg.steps = [legStep];
-            }
+    /**
+     * @param {object} json
+     * @returns {Coordinates}
+     */
+    jsonToCoordinates(json) {
+        return new Coordinates(Number(json.lat), Number(json.lon));
+    }
 
-            // jsonLeg.distance is not reliable when compared to the array of leg coords.
-            // leg.distance = jsonLeg.distance;
-            leg.distance = leg.coords.reduce((acc, coords, idx, arr) => {
-                if (idx === 0) {
-                    return acc;
-                }
-                return acc + arr[idx - 1].distanceTo(coords);
-            }, 0);
+    getSectionCoords(section) {
+        const from = section.from.stop_point ? this.jsonToCoordinates(section.from.stop_point.coord) : this.jsonToCoordinates(section.from.address.coord);
+        const to = section.to.stop_point ? this.jsonToCoordinates(section.to.stop_point.coord) : this.jsonToCoordinates(section.to.address.coord);
 
-            itinerary.legs.push(leg);
+        return {
+            from,
+            to
+        };
+    }
 
-        }
+    /**
+     * Since the IDFM API does not provide coords for each step, we need to compute them
+     * We trim the coordinates of the leg with the distance of each step and keep the last result as the coords of the step
+     * @param {Leg} leg
+     */
+    findStepsCoord(leg) {
+        const { steps, coords } = leg;
+
+        const duplicatedCoords = [...coords];
+        let previousStep = steps[0];
+        let accumulatedIndex = 0;
+
+        for (const [idx, step] of steps.entries()) {
+            let newCoords;
 
-        itinerary.distance = itinerary.coords.reduce((acc, coords, idx, arr) => {
             if (idx === 0) {
-                return acc;
-            }
-            return acc + arr[idx - 1].distanceTo(coords);
-        }, 0);
+                step._idCoordsInLeg = 0;
+                newCoords = coords[0];
+            } else if (idx === steps.length - 1) {
+                step._idCoordsInLeg = coords.length - 1;
+                newCoords = last(coords);
+            } else if (duplicatedCoords.length === 1) {
+                accumulatedIndex++;
 
-        // All legs have to be parsed before computing steps metadata
-        generateStepsMetadata(itinerary);
-    }
+                step._idCoordsInLeg = accumulatedIndex;
 
-    return routerResponse;
-}
+                newCoords = duplicatedCoords[0];
 
-var OtpUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    jsonToCoordinates: jsonToCoordinates$1,
-    createRouterResponseFromJson: createRouterResponseFromJson$2
-});
+                coords[step._idCoordsInLeg] = newCoords;
+            } else {
+                const result = Utils.trimRoute(duplicatedCoords, duplicatedCoords[0], previousStep.distance);
+                accumulatedIndex += result.length - 1;
 
-/* eslint-disable max-depth */
+                duplicatedCoords.splice(0, result.length - 1);
 
-/**
- * @param {object} json
- * @returns {Coordinates}
- */
-function jsonToCoordinates(json) {
-    return new Coordinates(json.Lat, json.Long);
-}
+                step._idCoordsInLeg = accumulatedIndex;
 
-/**
- * @param {string} jsonDate
- * @returns {number}
- */
-function jsonDateToTimestamp(jsonDate) {
-    const [dateStr, timeStr] = jsonDate.split(' ');
-    const [dayStr, monthStr, yearStr] = dateStr.split('/');
-    const [hoursStr, minutesStr, secondsStr] = timeStr.split(':');
-    const date = new Date(
-        Number(yearStr), Number(monthStr) - 1, Number(dayStr),
-        Number(hoursStr), Number(minutesStr), Number(secondsStr)
-    );
-    return date.getTime();
-}
+                newCoords = last(result);
 
-/**
- * @param {string} wktGeometry
- * @returns {Coordinates[]}
- */
-function parseWKTGeometry(wktGeometry) {
-    const tmpCoordsStr = wktGeometry.match(/LINESTRING \((.*)\)/i);
-    if (!tmpCoordsStr) {
-        return null;
-    }
-    return tmpCoordsStr[1].split(',').map(str => {
-        const sp = str.trim().split(' ');
-        return new Coordinates(Number(sp[1]), Number(sp[0]));
-    });
-}
+                coords[step._idCoordsInLeg] = newCoords;
+            }
 
-/**
- * @param {string} iso8601Duration
- * @see https://stackoverflow.com/a/29153059/2239938
- */
-function parseDuration(iso8601Duration) {
-    const iso8601DurationRegex = /(-)?P(?:([.,\d]+)Y)?(?:([.,\d]+)M)?(?:([.,\d]+)W)?(?:([.,\d]+)D)?T(?:([.,\d]+)H)?(?:([.,\d]+)M)?(?:([.,\d]+)S)?/;
-
-    var matches = iso8601Duration.match(iso8601DurationRegex);
-
-    // const sign = typeof matches[1] === 'undefined' ? '+' : '-',
-    const years = typeof matches[2] === 'undefined' ? 0 : Number(matches[2]);
-    const months = typeof matches[3] === 'undefined' ? 0 : Number(matches[3]);
-    const weeks = typeof matches[4] === 'undefined' ? 0 : Number(matches[4]);
-    const days = typeof matches[5] === 'undefined' ? 0 : Number(matches[5]);
-    const hours = typeof matches[6] === 'undefined' ? 0 : Number(matches[6]);
-    const minutes = typeof matches[7] === 'undefined' ? 0 : Number(matches[7]);
-    const seconds = typeof matches[8] === 'undefined' ? 0 : Number(matches[8]);
-
-    return seconds
-        + minutes * 60
-        + hours * 3600
-        + days * 86400
-        + weeks * (86400 * 7)
-        + months * (86400 * 30)
-        + years * (86400 * 365.25);
-}
+            step.coords = newCoords;
 
-/**
- * Generate multi itineraries from Cityway JSON
- * @param {object} json JSON file provided by Cityway.
- * @returns {?RouterResponse}
- * @example https://preprod.api.lia2.cityway.fr/journeyplanner/api/opt/PlanTrips/json?DepartureLatitude=49.51509388236216&DepartureLongitude=0.09341749619366316&ArrivalLatitude=49.5067090188444&ArrivalLongitude=0.1694842115417831&DepartureType=COORDINATES&ArrivalType=COORDINATES
- */
-function createRouterResponseFromJson$1(json) {
+            previousStep = step;
+        }
+    }
 
-    if (json.StatusCode !== 200 || !json.Data || !json.Data.length) {
-        return null;
+    /**
+     * @param {string} stringDate (e.g. 20211117T104516)
+     * @returns {number}
+     */
+    dateStringToTimestamp(stringDate, timeZone) {
+        const yearStr = stringDate.substr(0, 4);
+        const monthStr = stringDate.substr(4, 2);
+        const dayStr = stringDate.substr(6, 2);
+        const hoursStr = stringDate.substr(9, 2);
+        const minutesStr = stringDate.substr(11, 2);
+        const secondsStr = stringDate.substr(13, 2);
+
+        return dateWithTimeZone(
+            Number(yearStr),
+            Number(monthStr) - 1,
+            Number(dayStr),
+            Number(hoursStr),
+            Number(minutesStr),
+            Number(secondsStr),
+            timeZone
+        ).getTime();
     }
 
-    const routerResponse = new RouterResponse();
-    routerResponse.routerName = 'cityway';
+    /**
+     * Generate multi itineraries from OTP JSON
+     * @param {object} json JSON file provided by OTP.
+     * @returns {?RouterResponse}
+     */
+    createRouterResponseFromJson(json) {
 
+        if (!json || !json.journeys) {
+            return null;
+        }
 
-    // Do not know if it the best approach, but it works...
-    const allJsonTrips = json.Data.reduce((acc, dataObj) => {
-        acc.push(...dataObj.response.trips.Trip);
-        return acc;
-    }, []);
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
 
-    for (const trip of allJsonTrips) {
+        routerResponse.from = this.getSectionCoords(json.journeys[0].sections[0]).from;
+        routerResponse.to = this.getSectionCoords(last(json.journeys[0].sections)).to;
 
-        const itinerary = new Itinerary();
+        const timeZone = json.context.timezone;
 
-        itinerary.duration = parseDuration(trip.Duration);
-        itinerary.startTime = jsonDateToTimestamp(trip.Departure.Time);
-        itinerary.from = jsonToCoordinates(trip.Departure.Site.Position);
-        itinerary.endTime = jsonDateToTimestamp(trip.Arrival.Time);
-        itinerary.to = jsonToCoordinates(trip.Arrival.Site.Position);
-        routerResponse.itineraries.push(itinerary);
+        for (const jsonItinerary of json.journeys) {
 
-        for (const jsonSection of trip.sections.Section) {
+            const itinerary = new Itinerary();
 
-            const jsonLeg = jsonSection.Leg ? jsonSection.Leg : jsonSection.PTRide;
+            itinerary.duration = jsonItinerary.duration;
+            itinerary.startTime = this.dateStringToTimestamp(jsonItinerary.departure_date_time, timeZone);
+            itinerary.endTime = this.dateStringToTimestamp(jsonItinerary.arrival_date_time, timeZone);
+            itinerary.from = routerResponse.from;
+            itinerary.to = routerResponse.to;
+            itinerary.distance = 0;
 
-            const leg = new Leg();
+            routerResponse.itineraries.push(itinerary);
 
-            leg.mode = jsonLeg.TransportMode;
-            leg.duration = parseDuration(jsonLeg.Duration);
-            leg.startTime = jsonDateToTimestamp(jsonLeg.Departure.Time);
-            leg.endTime = jsonDateToTimestamp(jsonLeg.Arrival.Time);
-            leg.coords = [];
+            for (const jsonSection of jsonItinerary.sections) {
 
-            if (leg.mode === 'WALK' || leg.mode === 'BICYCLE') {
+                if (jsonSection.type === 'waiting' || jsonSection.type === 'transfer') {
+                    continue;
+                }
+
+                const leg = new Leg();
+                let existingCoords = [];
+                const { from, to } = this.getSectionCoords(jsonSection);
+
+                leg.distance = 0;
+                leg.mode = routingModeCorrespondance.get(jsonSection.mode);
+                leg.duration = jsonSection.duration;
+                leg.startTime = this.dateStringToTimestamp(jsonSection.departure_date_time, timeZone);
+                leg.endTime = this.dateStringToTimestamp(jsonSection.arrival_date_time, timeZone);
 
                 leg.from = {
-                    name: jsonLeg.Departure.Site.Name,
-                    coords: jsonToCoordinates(jsonLeg.Departure.Site.Position)
+                    name: jsonSection.from.name,
+                    coords: from
                 };
+
                 leg.to = {
-                    name: jsonLeg.Arrival.Site.Name,
-                    coords: jsonToCoordinates(jsonLeg.Arrival.Site.Position)
+                    name: jsonSection.to.name,
+                    coords: to
                 };
 
-                leg.steps = [];
-                for (const jsonPathLink of jsonLeg.pathLinks.PathLink) {
-                    const step = new Step();
-                    let stepCoords;
-                    if (jsonPathLink.Geometry) {
-                        stepCoords = parseWKTGeometry(jsonPathLink.Geometry);
-                    } else {
-                        stepCoords = [leg.from.coords, leg.to.coords];
+                // A section can have multiple same coordinates, we need to remove them
+                leg.coords = jsonSection.geojson.coordinates.reduce((acc, [lon, lat]) => {
+                    if (!existingCoords.includes(`${lon}-${lat}`)) {
+                        existingCoords = existingCoords.concat(`${lon}-${lat}`);
+                        acc.push(new Coordinates(lat, lon));
                     }
-                    step.coords = stepCoords[0];
-                    step._idCoordsInLeg = leg.coords.length;
-                    stepCoords.forEach((coords, idx) => {
-                        if (
-                            idx !== 0
-                            || leg.coords.length === 0
-                            || !leg.coords[leg.coords.length - 1].equalsTo(coords)
-                        ) {
-                            leg.coords.push(coords);
-                        }
-                    });
 
+                    return acc;
+                }, []);
 
-                    step.name = jsonPathLink.Departure.Site.Name;
-                    step.levelChange = null;
+                leg.steps = [];
 
-                    step.distance = jsonPathLink.Distance;
+                if (jsonSection.path) {
+                    for (const jsonPathLink of jsonSection.path) {
+                        const step = new Step();
 
-                    leg.steps.push(step);
-                }
+                        step.levelChange = null;
 
-            } else if (leg.mode === 'BUS' || leg.mode === 'TRAMWAY' || leg.mode === 'FUNICULAR' || leg.mode === 'TRAIN') {
+                        step.name = jsonPathLink.name;
+                        step.distance = jsonPathLink.length;
 
-                leg.from = {
-                    name: jsonLeg.Departure.StopPlace.Name,
-                    coords: jsonToCoordinates(jsonLeg.Departure.StopPlace.Position)
-                };
-                leg.to = {
-                    name: jsonLeg.Arrival.StopPlace.Name,
-                    coords: jsonToCoordinates(jsonLeg.Arrival.StopPlace.Position)
-                };
+                        leg.distance += step.distance;
+                        leg.steps.push(step);
+                    }
 
-                let transportName = jsonLeg.Line.Number;
-                if (leg.mode === 'TRAMWAY') {
-                    leg.mode = 'TRAM';
-                    // In order to remove the "TRAM " prefix.
-                    transportName = transportName.substr(5);
+                    this.findStepsCoord(leg);
                 }
 
-                leg.transportInfo = {
-                    name: transportName,
-                    routeColor: jsonLeg.Line.Color,
-                    routeTextColor: jsonLeg.Line.TextColor,
-                    directionName: jsonLeg.Destination
-                };
+                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
+                    };
 
-                for (const jsonStep of jsonLeg.steps.Step) {
-                    const stepCoords = parseWKTGeometry(jsonStep.Geometry);
-                    stepCoords.forEach((coords, idx) => {
-                        if (
-                            idx !== 0
-                            || leg.coords.length === 0
-                            || !leg.coords[leg.coords.length - 1].equalsTo(coords)
-                        ) {
-                            leg.coords.push(coords);
-                        }
-                    });
-                }
+                    leg.mode = routingModeCorrespondance.get(jsonSection.display_informations.physical_mode);
 
-                const legStep = new Step();
-                legStep.coords = leg.coords[0];
-                legStep._idCoordsInLeg = 0;
-                legStep.name = jsonLeg.Line.Name;
-                legStep.levelChange = null;
-                legStep.distance = jsonLeg.Distance;
-                leg.steps = [legStep];
-            } else {
-                Logger.warn(`[CitywayParser] Unknown leg mode: ${leg.mode}`);
-            }
+                    const legStep = new Step();
+                    legStep.coords = leg.coords[0];
+                    legStep._idCoordsInLeg = 0;
+                    legStep.name = leg.transportInfo.directionName;
+                    legStep.levelChange = null;
+                    legStep.distance = jsonSection.geojson.properties[0].length;
 
-            leg.distance = leg.coords.reduce((acc, coords, idx, arr) => {
-                if (idx === 0) {
-                    return acc;
+                    leg.steps = [legStep];
                 }
-                return acc + arr[idx - 1].distanceTo(coords);
-            }, 0);
 
-            itinerary.legs.push(leg);
+                itinerary.distance += leg.distance;
 
-        }
+                itinerary.legs.push(leg);
 
-        itinerary.distance = itinerary.coords.reduce((acc, coords, idx, arr) => {
-            if (idx === 0) {
-                return acc;
             }
-            return acc + arr[idx - 1].distanceTo(coords);
-        }, 0);
-
-        // All legs have to be parsed before computing steps metadata
-        generateStepsMetadata(itinerary);
-    }
 
-    routerResponse.from = routerResponse.itineraries[0].from;
-    routerResponse.to = routerResponse.itineraries[routerResponse.itineraries.length - 1].to;
+            // All legs have to be parsed before computing steps metadata
+            generateStepsMetadata(itinerary);
+        }
 
-    return routerResponse;
+        return routerResponse;
+    }
 }
 
-var CitywayUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    jsonToCoordinates: jsonToCoordinates,
-    createRouterResponseFromJson: createRouterResponseFromJson$1
-});
+var IdfmRemoteRouter$1 = new IdfmRemoteRouter();
 
 /* eslint-disable max-statements */
 
+
 /**
- * Generate multi itineraries from the DB JSON
- * @param {object} json JSON file provided by the DB.
- * @param {Coordinates} from itinerary start
- * @param {Coordinates} to itinerary end
- * @returns {?RouterResponse}
+ * Singleton.
  */
-function createRouterResponseFromJson(json, from, to) {
+class WemapMetaRemoteRouter extends RemoteRouter {
 
-    const { segments: jsonSegments } = json;
-
-    if (!jsonSegments) {
-        return null;
+    /**
+     * @override
+     */
+    get rname() {
+        return 'wemap-meta';
     }
 
-    const routerResponse = new RouterResponse();
-    routerResponse.routerName = 'deutsche-bahn';
-
-    routerResponse.from = from;
-    routerResponse.to = to;
-
-    /** @type {GraphEdge<OsmElement>[]} */
-    const edges = [];
-
-    /** @type {GraphNode<OsmElement>[]} */
-    const nodes = [];
-
-    /** @type {number[]} */
-    const edgesWeights = [];
-
-    let id = 1;
-    for (const jsonSegment of jsonSegments) {
-
-        const level = new Level(jsonSegment.fromLevel, jsonSegment.toLevel);
-        const osmWay = new OsmWay(id++, null, level);
-
-        for (const jsonPoint of jsonSegment.polyline) {
-            const coord = new Coordinates(jsonPoint.lat, jsonPoint.lon, null, level);
+    /**
+     * @override
+     */
+    async getItineraries(endpointUrl, mode, waypoints, options) {
+        const url = this.getURL(endpointUrl, mode, waypoints, options);
+        const response = await request(url);
+        return RouterResponse.fromJson(response);
+    }
 
-            if (nodes.length !== 0
-                && nodes[nodes.length - 1].coords.equalsTo(coord)) {
-                continue;
-            }
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     * @param {WemapMetaRemoteRouterOptions} options
+     */
+    getURL(endpointUrl, mode, waypoints, options) {
 
-            const osmNode = new OsmNode(id++, coord);
-            const node = new GraphNode(osmNode.coords, osmNode);
+        const url = new URL(endpointUrl);
 
-            if (nodes.length !== 0) {
-                const prevNode = nodes[nodes.length - 1];
-                const edge = new GraphEdge(prevNode, node, level, osmWay);
-                edges.push(edge);
-                edgesWeights.push(prevNode.coords.distanceTo(osmNode));
+        url.pathname = url.pathname + waypoints.map(waypoint => {
+            if (waypoint.level) {
+                const altitude = waypoint.level.isRange ? waypoint.level.low : waypoint.level.val;
+                return waypoint.longitude + ',' + waypoint.latitude + ',' + altitude;
             }
+            return waypoint.longitude + ',' + waypoint.latitude;
+        }).join(';');
 
-            nodes.push(node);
+        url.searchParams.set('externalRouterName', options.externalRouterName);
+        url.searchParams.set('externalRouterEndpoint', encodeURIComponent(options.externalRouterEndpointUrl));
+        url.searchParams.set('externalRouterMode', mode);
 
-        }
+        return url;
     }
-
-    /** @type {GraphItinerary<OsmElement>} */
-    const graphItinerary = new GraphItinerary();
-    graphItinerary.nodes = nodes;
-    graphItinerary.edges = edges;
-    graphItinerary.edgesWeights = edgesWeights;
-    graphItinerary.start = nodes[0].coords;
-    graphItinerary.end = nodes[nodes.length - 1].coords;
-
-    const points = nodes.map(node => node.coords);
-    const itinerary = Itinerary.fromOrderedCoordinates(points, from, to);
-    itinerary.legs[0].steps = WemapStepsGeneration.fromGraphItinerary(graphItinerary);
-    itinerary.legs[0].steps.map((step, idx) => (step._idCoordsInLeg = idx));
-
-    // All legs have to be parsed before computing steps metadata
-    generateStepsMetadata(itinerary);
-
-    routerResponse.itineraries.push(itinerary);
-
-    return routerResponse;
 }
 
-var DeutscheBahnRouterUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    createRouterResponseFromJson: createRouterResponseFromJson
-});
+var WemapMetaRemoteRouter$1 = new WemapMetaRemoteRouter();
 
 /* eslint-disable max-statements */
 
@@ -1891,5 +3007,5 @@ class ItineraryInfoManager {
 
 }
 
-export { CitywayUtils, DeutscheBahnRouterUtils, Itinerary, ItineraryInfo, ItineraryInfoManager, Leg, LevelChange, OsrmUtils, OtpUtils, RouterResponse, Step, WemapNetworkUtils, WemapRouter, WemapRouterOptions, WemapRouterUtils, generateStepsMetadata, getDurationFromLength };
+export { CitywayRemoteRouter$1 as CitywayRemoteRouter, DeutscheBahnRemoteRouter$1 as DeutscheBahnRemoteRouter, IdfmRemoteRouter$1 as IdfmRemoteRouter, Itinerary, ItineraryInfo, ItineraryInfoManager, Leg, LevelChange, OsrmRemoteRouter$1 as OsrmRemoteRouter, OtpRemoteRouter$1 as OtpRemoteRouter, RouterResponse, Step, WemapMetaRemoteRouter$1 as WemapMetaRemoteRouter, WemapNetworkUtils, WemapRouter, WemapRouterOptions, WemapRouterUtils, getDurationFromLength };
 //# sourceMappingURL=wemap-routers.es.js.map