@wemap/routers 7.2.0 → 7.2.2

package/dist/wemap-routers.es.js

@@ -0,0 +1,3691 @@
+import { Coordinates, Network, GraphRouterOptions, GraphRouter, GraphUtils, Level, GraphEdge, GraphNode, NoRouteFoundError, GraphItinerary, Utils, MapMatching } from '@wemap/geo';
+import { OsmParser, OsmWay, OsmNode } from '@wemap/osm';
+import { deg2rad, diffAngle, positiveMod, rad2deg } from '@wemap/maths';
+import Logger from '@wemap/logger';
+import pointInPolygon from '@turf/boolean-point-in-polygon';
+import convexHullFn from '@turf/convex';
+import { polygon } from '@turf/helpers';
+import Polyline from '@mapbox/polyline';
+
+class LevelChange {
+
+    /** @type {!string} [up|down] */
+    direction;
+
+    /** @type {!number} [-2, -1, 1, ...] */
+    difference;
+
+    /** @type {?string} [elevator|conveyor|stairs] */
+    type = null;
+
+    /**
+     * @param {LevelChange} obj1
+     * @param {LevelChange} obj2
+     * @returns {Boolean}
+     */
+    static equalsTo(obj1, obj2) {
+        return obj1.difference === obj2.difference
+            && obj1.direction === obj2.direction
+            && obj1.type === obj2.type;
+    }
+
+    /**
+     * @param {LevelChange} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return LevelChange.equalsTo(this, obj);
+    }
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        return {
+            direction: this.direction,
+            difference: this.difference,
+            type: this.type
+        };
+    }
+
+    /**
+     * @param {object} json
+     * @returns {LevelChange}
+     */
+    static fromJson(json) {
+        const levelChange = new LevelChange();
+        levelChange.direction = json.direction;
+        levelChange.difference = json.difference;
+        levelChange.type = json.type;
+        return levelChange;
+    }
+}
+
+class Step {
+
+    /** @type {!boolean} */
+    firstStep = false;
+
+    /** @type {!boolean} */
+    lastStep = false;
+
+    /** @type {!number} */
+    number;
+
+    /** @type {!Coordinates} */
+    coords = [];
+
+
+    /** @type {!number} */
+    angle;
+
+    /** @type {!number} */
+    previousBearing;
+
+    /** @type {!number} */
+    nextBearing;
+
+
+    /** @type {!number} */
+    distance;
+
+    /** @type {?number} */
+    duration = null;
+
+    /** @type {?string} */
+    name = null;
+
+
+    /** @type {?LevelChange} */
+    levelChange = null;
+
+    /** @type {?{?subwayEntrance: boolean, ?subwayEntranceRef: string}} */
+    extras = {};
+
+    /** @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}
+     */
+    toJson() {
+        const output = {
+            number: this.number,
+            coords: this.coords.toCompressedJson(),
+            angle: this.angle,
+            previousBearing: this.previousBearing,
+            nextBearing: this.nextBearing,
+            distance: this.distance,
+            _idCoordsInLeg: this._idCoordsInLeg
+        };
+        if (this.firstStep) {
+            output.firstStep = true;
+        }
+        if (this.lastStep) {
+            output.lastStep = true;
+        }
+        if (this.duration !== null) {
+            output.duration = this.duration;
+        }
+        if (this.name !== null) {
+            output.name = this.name;
+        }
+        if (this.levelChange !== null) {
+            output.levelChange = this.levelChange.toJson();
+        }
+        if (this.extras && Object.keys(this.extras).length !== 0) {
+            output.extras = this.extras;
+        }
+        return output;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Step}
+     */
+    static fromJson(json) {
+        const step = new Step();
+        step.number = json.number;
+        step.coords = Coordinates.fromCompressedJson(json.coords);
+        step.angle = json.angle;
+        step.previousBearing = json.previousBearing;
+        step.nextBearing = json.nextBearing;
+        step.distance = json.distance;
+        step._idCoordsInLeg = json._idCoordsInLeg;
+        if (typeof json.firstStep === 'boolean') {
+            step.firstStep = json.firstStep;
+        }
+        if (typeof json.lastStep === 'boolean') {
+            step.lastStep = json.lastStep;
+        }
+        if (typeof json.duration === 'number') {
+            step.duration = json.duration;
+        }
+        if (typeof json.name === 'string') {
+            step.name = json.name;
+        }
+        if (typeof json.levelChange === 'object') {
+            step.levelChange = LevelChange.fromJson(json.levelChange);
+        }
+        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 values in Constants.ROUTING_MODE */
+    mode;
+
+    /** @type {!number} */
+    distance;
+
+    /** @type {!number} */
+    duration;
+
+    /** @type {?number} */
+    startTime = null;
+
+    /** @type {?number} */
+    endTime = null;
+
+    /** @type {!{name: ?string, coords: !Coordinates}} */
+    from;
+
+    /** @type {!{name: ?string, coords: !Coordinates}} */
+    to;
+
+    /** @type {!Coordinates[]} */
+    coords;
+
+    /** @type {?{name: !string, routeColor: ?string, routeTextColor: ?string, directionName: ?string}} */
+    transportInfo = null;
+
+    /** @type {?(Step[])} */
+    steps = null;
+
+    isPublicTransport() {
+        return Constants.PUBLIC_TRANSPORT.includes(this.mode);
+    }
+
+    /**
+     * @returns {Network}
+     */
+    toNetwork() {
+        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}
+     */
+    toJson() {
+        const output = {
+            mode: this.mode,
+            from: { coords: this.from.coords.toCompressedJson() },
+            to: { coords: this.to.coords.toCompressedJson() },
+            distance: this.distance,
+            duration: this.duration,
+            coords: this.coords.map(coords => coords.toCompressedJson())
+        };
+        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;
+        }
+        if (this.steps !== null && this.steps.length > 0) {
+            output.steps = this.steps.map(step => step.toJson());
+        }
+        return output;
+    }
+
+
+    /**
+     * @param {object} json
+     * @returns {Leg}
+     */
+    static fromJson(json) {
+        const leg = new Leg();
+        leg.mode = json.mode;
+        leg.distance = json.distance;
+        leg.duration = json.duration;
+
+        if (typeof json.startTime === 'number') {
+            leg.startTime = json.startTime;
+        }
+        if (typeof json.endTime === 'number') {
+            leg.endTime = json.endTime;
+        }
+
+        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 (typeof json.steps === 'object') {
+            leg.steps = json.steps.map(Step.fromJson);
+        }
+        return leg;
+    }
+
+}
+
+/**
+ * Get route duration
+ * @param {Number} speed in km/h
+ * @returns {Number} duration in seconds
+ */
+function getDurationFromLength(length, speed = 5) {
+    return length / (speed * 1000 / 3600);
+}
+
+/* eslint-disable max-statements */
+
+/**
+ * Main attributes are:
+ * nodes: the ordered list of Node
+ * edges: the ordered list of Edge
+ * start: the start point (Coordinates)
+ * end: the end point (Coordinates)
+ * length: the route length
+ */
+class Itinerary {
+
+    /** @type {!Coordinates} */
+    from;
+
+    /** @type {!Coordinates} */
+    to;
+
+    /** @type {!number} */
+    distance;
+
+    /** @type {!number} */
+    duration;
+
+    /** @type {!string} can be WALK, BIKE, CAR, PT */
+    _mode;
+
+    /** @type {?number} */
+    startTime = null;
+
+    /** @type {?number} */
+    endTime = null;
+
+    /** @type {!(Leg[])} */
+    legs = [];
+
+    /** @type {?Coordinates[]} */
+    _coords = null;
+
+    set coords(_) {
+        throw new Error('Itinerary.coords cannot be set. They are calculated from Itinerary.legs.');
+    }
+
+    /** @type {!(Coordinates[])} */
+    get coords() {
+        if (!this._coords) {
+            // Returns the coordinates contained in all legs and remove duplicates between array
+            this._coords = this.legs.reduce((acc, val) => {
+                const isDuplicate = acc.length && val.coords.length && acc[acc.length - 1].equalsTo(val.coords[0]);
+                acc.push(...val.coords.slice(isDuplicate ? 1 : 0));
+                return acc;
+            }, []);
+        }
+        return this._coords;
+    }
+
+    set steps(_) {
+        throw new Error('Itinerary.step cannot be set. They are calculated from Itinerary.legs.');
+    }
+
+    /** @type {!(Step[])} */
+    get steps() {
+        return this.legs.map(leg => leg.steps).flat();
+    }
+
+    set mode(_) {
+        throw new Error('Itinerary.mode cannot be set. They are calculated from Itinerary.legs.');
+    }
+
+    get mode() {
+        if (!this._mode) {
+            let isPublicTransport = false;
+            let isBicycle = false;
+            let isDriving = false;
+
+            this.legs.forEach((leg) => {
+                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) {
+                this._mode = 'PT';
+            } else if (isDriving) {
+                this._mode = 'CAR';
+            } else if (isBicycle) {
+                this._mode = 'BIKE';
+            } else {
+                this._mode = 'WALK';
+            }
+        }
+
+        return this._mode;
+
+    }
+
+    /**
+     * @returns {Network}
+     */
+    toNetwork() {
+        return Network.fromCoordinates([this.coords]);
+    }
+
+    /**
+     * @param {Itinerary[]} itineraries
+     * @returns {Itinerary}
+     */
+    static fromItineraries(...itineraries) {
+        const itinerary = new Itinerary();
+        itinerary.from = itineraries[0].from;
+        itinerary.to = itineraries[itineraries.length - 1].to;
+        itinerary.distance = 0;
+        itinerary.duration = 0;
+        itinerary.legs = [];
+
+        itineraries.forEach(_itinerary => {
+            itinerary.distance += _itinerary.distance;
+            itinerary.duration += _itinerary.duration;
+            itinerary.legs.push(..._itinerary.legs);
+            itinerary.legs.forEach(leg => {
+                leg.steps[0].firstStep = false;
+                leg.steps[leg.steps.length - 1].lastStep = false;
+            });
+        });
+
+        itinerary.legs[0].steps[0].firstStep = true;
+        const lastLeg = itinerary.legs[itinerary.legs.length - 1];
+        lastLeg.steps[lastLeg.steps.length - 1].lastStep = true;
+
+        return itinerary;
+    }
+
+    /**
+     * Convert lat/lng/level points to Itinerary
+     * @param {number[][]} points 2D points array of lat/lng/level (level is optional)
+     * @param {Coordinates} from
+     * @param {Coordinates} to
+     * @param {string} mode
+     * @returns {Itinerary}
+     */
+    static fromOrderedPointsArray(points, start, end) {
+
+        const pointToCoordinates = point => new Coordinates(point[0], point[1], null, point[2]);
+
+        return this.fromOrderedCoordinates(
+            points.map(pointToCoordinates),
+            pointToCoordinates(start),
+            pointToCoordinates(end)
+        );
+    }
+
+    /**
+     * Convert ordered Coordinates to Itinerary
+     * @param {Coordinates[]} points
+     * @param {Coordinates} from
+     * @param {Coordinates} to
+     * @param {string} mode
+     * @returns {Itinerary}
+     */
+    static fromOrderedCoordinates(points, from, to, mode = 'WALK') {
+
+        const itinerary = new Itinerary();
+        itinerary.from = from;
+        itinerary.to = to;
+
+        const leg = new Leg();
+        leg.mode = mode;
+        leg.from = { name: null, coords: from };
+        leg.to = { name: null, coords: to };
+
+        leg.coords = points;
+        leg.distance = points.reduce((acc, coords, idx, arr) => {
+            if (idx !== 0) {
+                return acc + arr[idx - 1].distanceTo(coords);
+            }
+            return acc;
+        }, 0);
+        leg.duration = getDurationFromLength(leg.distance);
+        itinerary.legs.push(leg);
+
+        itinerary.distance = leg.distance;
+        itinerary.duration = leg.duration;
+
+        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}
+     */
+    toJson() {
+        const output = {
+            from: this.from.toCompressedJson(),
+            to: this.to.toCompressedJson(),
+            distance: this.distance,
+            duration: this.duration,
+            mode: this.mode,
+            legs: this.legs.map(leg => leg.toJson())
+        };
+        if (this.startTime !== null) {
+            output.startTime = this.startTime;
+        }
+        if (this.endTime !== null) {
+            output.endTime = this.endTime;
+        }
+        return output;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Itinerary}
+     */
+    static fromJson(json) {
+        const itinerary = new Itinerary();
+        itinerary.from = Coordinates.fromCompressedJson(json.from);
+        itinerary.to = Coordinates.fromCompressedJson(json.to);
+        itinerary.distance = json.distance;
+        itinerary.duration = json.duration;
+        itinerary.legs = json.legs.map(Leg.fromJson);
+        if (typeof json.startTime === 'number') {
+            itinerary.startTime = json.startTime;
+        }
+        if (typeof json.endTime === 'number') {
+            itinerary.endTime = json.endTime;
+        }
+        return itinerary;
+    }
+}
+
+class RouterResponse {
+
+    /** @type {!string|Array<string>} */
+    routerName;
+
+    /** @type {!Coordinates} */
+    from;
+
+    /** @type {!Coordinates} */
+    to;
+
+    /** @type {!(Itinerary[])} */
+    itineraries = [];
+
+    /** @type {?object} */
+    error = null;
+
+    /**
+     * @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() {
+        const json = {
+            routerName: this.routerName,
+            from: this.from.toCompressedJson(),
+            to: this.to.toCompressedJson(),
+            itineraries: this.itineraries.map(itinerary => itinerary.toJson())
+        };
+        if (this.error) {
+            json.error = this.error;
+        }
+        return json;
+    }
+
+    /**
+     * @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);
+        if (json.error) {
+            routerResponse.error = json.error;
+        }
+        return routerResponse;
+    }
+}
+
+class ItineraryInfo {
+
+    /** @type {Step} */
+    nextStep;
+
+    /** @type {Step} */
+    previousStep;
+
+    /** @type {GraphProjection} */
+    projection;
+
+    /** @type {Leg} */
+    leg;
+
+    /** @type {number} */
+    traveledDistance;
+
+    /** @type {number} */
+    traveledPercentage;
+
+    /** @type {number} */
+    remainingDistance;
+
+    /** @type {number} */
+    remainingPercentage;
+
+}
+
+class WemapRouterOptions extends GraphRouterOptions {
+
+    /** @type {WemapRouterOptions} */
+    static DEFAULT = new WemapRouterOptions();
+
+    /**
+     * @returns {WemapRouterOptions}
+     */
+    static get WITHOUT_STAIRS() {
+        const options = new WemapRouterOptions();
+        options.acceptEdgeFn = edge => edge.builtFrom.tags.highway !== 'steps';
+        return options;
+    }
+
+    /**
+     * Get route duration
+     * @param {Number} speed in km/h
+     */
+    static getDurationFromLength(length, speed = 5) {
+        return length / (speed * 1000 / 3600);
+    }
+
+    /** @type {function(GraphEdge<OsmElement>):boolean} */
+    weightEdgeFn = edge => edge.builtFrom.isElevator ? 30 : WemapRouterOptions.getDurationFromLength(edge.length);
+
+
+}
+
+class WemapRouter extends GraphRouter {
+
+    /**
+     * @param {!Network<OsmElement>} network
+     */
+    constructor(network) {
+        super(network);
+    }
+
+
+    /** @type {string} */
+    static get rname() {
+        return 'wemap';
+    }
+
+    /**
+     * @param {Coordinates} start
+     * @param {Coordinates} end
+     * @param {WemapRouterOptions} options
+     * @returns {GraphItinerary<OsmElement>}
+     */
+    getShortestPath(start, end, options = new WemapRouterOptions()) {
+        return super.getShortestPath(start, end, options);
+    }
+
+}
+
+/* eslint-disable complexity */
+
+const SKIP_STEP_ANGLE_MAX = deg2rad(20);
+
+class WemapStepsGeneration {
+
+    /**
+     * @param {GraphItinerary<OsmElement>} itinerary
+     * @returns {Step[]}
+     */
+    static fromGraphItinerary(itinerary) {
+
+        const steps = [];
+
+        const { start, end, nodes, edges } = itinerary;
+
+        let currentStep, previousStep;
+        let previousBearing = start.bearingTo(nodes[0].coords);
+
+        for (let i = 0; i < nodes.length - 1; i++) {
+
+            const isFirstStep = !currentStep;
+
+            const node = nodes[i];
+            const nextNode = nodes[i + 1];
+            const edge = edges[i];
+
+            const bearing = edge.bearing;
+            const angle = diffAngle(previousBearing, bearing + Math.PI);
+
+            let splitByAngle = Math.abs(diffAngle(Math.PI, angle)) >= SKIP_STEP_ANGLE_MAX;
+
+            const splitByLevel = edge.level && edge.level.isRange
+                && node.coords.level && !node.coords.level.isRange;
+            splitByAngle = splitByAngle && !(node.coords.level && node.coords.level.isRange);
+
+            const splitStepCondition = splitByAngle || splitByLevel;
+
+            const isSubwayEntrance = node ? node.builtFrom.tags.railway === 'subway_entrance' : false;
+
+            // New step creation
+            if (isFirstStep || splitStepCondition || isSubwayEntrance) {
+
+                previousStep = currentStep;
+
+                currentStep = new Step();
+                currentStep.coords = node.coords;
+                currentStep.number = steps.length + 1;
+                currentStep.angle = angle;
+                currentStep.previousBearing = previousBearing;
+                currentStep.nextBearing = bearing;
+                currentStep.name = edge.builtFrom.tags.name || null;
+                currentStep.distance = 0;
+                currentStep.duration = 0;
+
+                if (isSubwayEntrance) {
+                    currentStep.extras.subwayEntrance = true;
+                    currentStep.name = node.builtFrom.tags.name;
+                    if (node.builtFrom.tags.ref) {
+                        currentStep.extras.subwayEntranceRef = node.builtFrom.tags.ref;
+                    }
+                }
+
+                if (splitByLevel) {
+                    currentStep.levelChange = WemapStepsGeneration.levelChangefromTwoNodes(node, nextNode);
+                }
+
+                steps.push(currentStep);
+
+                if (!previousStep) {
+                    currentStep.firstStep = true;
+                }
+            }
+
+            currentStep.distance += edge.length;
+            currentStep.duration += itinerary.edgesWeights[i];
+            previousBearing = bearing;
+        }
+
+        const lastNode = nodes[nodes.length - 1];
+
+        // 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);
+        }
+
+        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;
+    }
+}
+
+/**
+ * @param {GraphItinerary<OsmElement>} graphItinerary
+ * @param {string} mode
+ * @returns {Leg}
+ */
+function createLegFromGraphItinerary(graphItinerary,
+    mode = Constants.ROUTING_MODE.WALK) {
+
+    const leg = new Leg();
+
+    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;
+}
+
+/**
+ * @param {GraphItinerary<OsmElement>} graphItinerary
+ * @param {string} mode
+ * @returns {Itinerary}
+ */
+function createItineraryFromGraphItinerary(graphItinerary,
+    mode = Constants.ROUTING_MODE.WALK) {
+
+    const leg = createLegFromGraphItinerary(graphItinerary, mode);
+
+    const itinerary = new Itinerary();
+
+    itinerary.from = graphItinerary.start;
+    itinerary.to = graphItinerary.end;
+    itinerary.distance = leg.distance;
+    itinerary.duration = leg.duration;
+    itinerary.legs.push(leg);
+
+    return itinerary;
+}
+
+var WemapRouterUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createLegFromGraphItinerary: createLegFromGraphItinerary,
+    createItineraryFromGraphItinerary: createItineraryFromGraphItinerary
+});
+
+const HIGHWAYS_PEDESTRIANS = ['footway', 'steps', 'pedestrian', 'living_street', 'path', 'track', 'sidewalk'];
+
+const DEFAULT_WAY_SELECTOR = way => {
+    return HIGHWAYS_PEDESTRIANS.includes(way.tags.highway)
+        || way.tags.footway === 'sidewalk'
+        || way.tags.public_transport === 'platform'
+        || way.tags.railway === 'platform';
+};
+
+/**
+ * @param {Network<OsmElement>} network
+ * @param {string} name
+ */
+function getNodeByName(network, name) {
+    return network.nodes.find(({ builtFrom }) => builtFrom.tags.name === name);
+}
+
+/**
+ * @param {Network<OsmElement>} network
+ * @param {string} name
+ */
+function getEdgeByName(network, name) {
+    return network.edges.find(({ builtFrom }) => builtFrom.tags.name === name);
+}
+
+/**
+ * @param {GraphEdge<OsmElement>} edge
+ * @param {OsmWay} way
+ * @returns {boolean}
+ */
+function manageOneWay(edge, way) {
+
+    const { highway, oneway, conveying } = way.tags;
+
+    edge.isOneway = Boolean((oneway === 'yes' || oneway === 'true' || oneway === '1')
+        || (conveying && highway && ['yes', 'forward', 'backward'].includes(conveying)));
+
+    if (edge.isOneway && conveying === 'backward') {
+        const tmpNode = edge.node1;
+        edge.node1 = edge.node2;
+        edge.node2 = tmpNode;
+    }
+}
+
+/**
+ * @param {Network} networkModel
+ * @param {GraphNode} node
+ */
+function createNodesAndEdgesFromElevator(networkModel, node) {
+
+    /** @type {GraphNode[]} */
+    const createdNodes = [];
+    const getOrCreateLevelNode = (level, builtFrom) => {
+        let levelNode = createdNodes.find(({ coords }) => Level.equalsTo(level, coords.level));
+        if (!levelNode) {
+            levelNode = new GraphNode(node.coords.clone(), builtFrom);
+            levelNode.coords.level = level;
+            createdNodes.push(levelNode);
+            networkModel.nodes.push(levelNode);
+        }
+        return levelNode;
+    };
+
+    // Create nodes from node.edges
+    node.edges.forEach(edge => {
+        if (edge.level.isRange) {
+            throw new Error('Cannot handle this elevator edge due to ambiguity');
+        }
+
+        const levelNode = getOrCreateLevelNode(edge.level, node.builtFrom);
+        if (edge.node1 === node) {
+            edge.node1 = levelNode;
+        } else {
+            edge.node2 = levelNode;
+        }
+        levelNode.edges.push(edge);
+    });
+
+    // Create edges from createdNodes
+    for (let i = 0; i < createdNodes.length; i++) {
+        for (let j = i + 1; j < createdNodes.length; j++) {
+
+            const createdNode1 = createdNodes[i];
+            const createdNode2 = createdNodes[j];
+
+            const newEdge = new GraphEdge(
+                createdNode1,
+                createdNode2,
+                new Level(createdNode1.coords.level.val, createdNode2.coords.level.val),
+                node.builtFrom
+            );
+            networkModel.edges.push(newEdge);
+        }
+    }
+
+    // Remove the historical elevator node from the network
+    networkModel.nodes = networkModel.nodes.filter(_node => _node !== node);
+}
+
+
+/**
+ * @param {OsmModel} osmModel
+ * @param {function} _waySelectionFilter
+ * @returns {Network<OsmElement>}
+ */
+function createNetworkFromOsmModel(
+    osmModel,
+    waySelectionFilter = DEFAULT_WAY_SELECTOR
+) {
+
+    const networkModel = new Network();
+
+    const nodesCreated = {};
+    const elevatorNodes = [];
+
+    /**
+     * @param {OsmNode} osmNode
+     */
+    const getOrCreateNode = osmNode => {
+        let node = nodesCreated[osmNode.id];
+        if (!node) {
+            node = new GraphNode(osmNode.coords, osmNode);
+            nodesCreated[osmNode.id] = node;
+            networkModel.nodes.push(node);
+
+            if (osmNode.tags.highway === 'elevator') {
+                elevatorNodes.push(node);
+            }
+        }
+        return node;
+    };
+
+    osmModel.ways.forEach(way => {
+        if (!waySelectionFilter(way)) {
+            return;
+        }
+
+        let firstNode = getOrCreateNode(way.nodes[0]);
+        for (let i = 1; i < way.nodes.length; i++) {
+            const secondNode = getOrCreateNode(way.nodes[i]);
+
+            const edge = new GraphEdge(firstNode, secondNode, way.level, way);
+            manageOneWay(edge, way);
+            networkModel.edges.push(edge);
+            firstNode = secondNode;
+        }
+
+    });
+
+    elevatorNodes.forEach(node => {
+        // We have to clone this node for each connected edge
+        createNodesAndEdgesFromElevator(networkModel, node);
+    });
+
+    GraphNode.generateNodesLevels(networkModel.nodes);
+
+    return networkModel;
+}
+
+
+// /**
+//  * @param {GraphNode} node
+//  * @param {object} tags
+//  */
+// static _applyNodePropertiesFromTags(node, tags) {
+//     node.name = tags.name || null;
+//     node.subwayEntrance = tags.railway === 'subway_entrance';
+//     if (node.subwayEntrance && tags.ref) {
+//         node.subwayEntranceRef = tags.ref;
+//     }
+// }
+
+// /**
+//  * @param {GraphEdge} edge
+//  * @param {object} tags
+//  */
+// static _applyEdgePropertiesFromTags(edge, tags) {
+//     const { highway, oneway, conveying, name } = tags;
+//     edge.name = name || null;
+//     edge.isStairs = highway === 'steps';
+//     edge.isConveying = 'conveying' in tags;
+//     edge.isOneway = Boolean((oneway === 'yes' || oneway === 'true' || oneway === '1')
+//         || (conveying && highway && ['yes', 'forward', 'backward'].includes(conveying)));
+
+//     if (conveying === 'backward') {
+//         const tmpNode = edge.node1;
+//         edge.node1 = edge.node2;
+//         edge.node2 = tmpNode;
+//     }
+
+// }
+
+var WemapNetworkUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    HIGHWAYS_PEDESTRIANS: HIGHWAYS_PEDESTRIANS,
+    DEFAULT_WAY_SELECTOR: DEFAULT_WAY_SELECTOR,
+    getNodeByName: getNodeByName,
+    getEdgeByName: getEdgeByName,
+    createNetworkFromOsmModel: createNetworkFromOsmModel
+});
+
+class IOMap {
+
+    /** @type {?string} */
+    name;
+
+    /** @type {!GraphRouter} */
+    router;
+
+    /** @type {!([number, number][])} */
+    bounds;
+
+
+    /** @type {!(GraphNode[])} */
+    entryPoints;
+
+    /**
+     * @param {Network} network The network of the map
+     * @param {GraphNode[]} entryPoints The map vertex that can be used to go inside / outside a IOMap
+     * @param {Coordinates[]} bounds The bounds
+     * @param {string} name The name of the map
+     * @returns {IOMap}
+     */
+    constructor(network, entryPoints, bounds = null, name = null) {
+
+        this.name = name;
+        this.router = new GraphRouter(network);
+
+        // Entry points
+        entryPoints.forEach(entryPoint => {
+            if (!network.nodes.includes(entryPoint)) {
+                throw new Error(`Cannot find entry point ${entryPoint.coords.toString()} in network "${name}"`);
+            }
+        });
+        this.entryPoints = entryPoints;
+
+        // Bounds
+        if (bounds) {
+            this.bounds = polygon([bounds.map(coords => [coords.lng, coords.lat])]);
+        } else {
+            const polygon = [network.nodes.map(node => [node.coords.lng, node.coords.lat])];
+            const convexHull = convexHullFn(polygon);
+            if (!convexHull) {
+                throw new Error(`Cannot calculate convexHull of network "${name}"`);
+            }
+            this.bounds = convexHull;
+        }
+    }
+
+    /**
+     * @param {string} osmXmlString
+     * @param {string} name
+     * @returns {IOMap}
+     */
+    static fromOsmXml(osmXmlString, name = null) {
+
+        const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
+        const network = createNetworkFromOsmModel(osmModel);
+
+        const entryPoints = osmModel.nodes
+            .filter(({ tags }) => tags && tags['wemap:routing-io'])
+            .map(osmNode => network.getNodeByCoords(osmNode.coords));
+        if (entryPoints.some(el => el === null)
+            || new Set(entryPoints).size !== entryPoints.length
+        ) {
+            throw new Error('Cannot parse wemap:routing-io correctly');
+        }
+
+        const wayBounds = osmModel.ways.find(({ tags }) => tags['wemap:routing-bounds']);
+        if (!wayBounds) {
+            throw new Error('Search bounds is undefined. Please use OSM tag : "wemap:routing-bounds=yes"');
+        }
+        const bounds = wayBounds.nodes.map(node => node.coords);
+        return new IOMap(network, entryPoints, bounds, name);
+    }
+
+    /**
+     * @param {Coordinates} coordinates
+     * @returns {boolean}
+     */
+    isPointInside(coordinates) {
+        return pointInPolygon([coordinates.lng, coordinates.lat], this.bounds);
+    }
+
+    /**
+     * Get the list of entry points sorted by the lowest distance between:
+     * start -> entry point -> end
+     * (as the crow flies)
+     *
+     * @param {Coordinates} start
+     * @param {Coordinates} end
+     * @returns {GraphNode[]}
+     */
+    getOrderedEntryPointsSortedByDistance(start, end) {
+        const entryPointsCopy = [...this.entryPoints];
+        return entryPointsCopy.sort((ep1, ep2) =>
+            + ep1.coords.distanceTo(start) + ep1.coords.distanceTo(end)
+            - ep2.coords.distanceTo(start) - ep2.coords.distanceTo(end)
+        );
+    }
+
+    /**
+     * Get the best itinerary from any entry point to an end coordinates.
+     *
+     * The algorithm works as following:
+     * 1 - Entry points are sorted using distance (as the crow flies) between start - entry point - end
+     * 2 - Try to calculate an itinerary from the first entry point to the end coordinates.
+     * 3 - If an itinerary is found, it is returned. Otherwise it tries from the next entry point.
+     *
+     * /!\ start is only used to sort the entry points (step 1).
+     *
+     * @param {Coordinates} start The start coordinates (which is outside the network)
+     * @param {Coordinates} end Then end coordinates (which is inside the network)
+     * @param {WemapRouterOptions} options
+     * @returns {Itinerary}
+     */
+    getBestItineraryFromEntryPointsToEnd(start, end, options) {
+
+        const sortedEntryPoints = this.getOrderedEntryPointsSortedByDistance(start, end);
+        for (const entryPoint of sortedEntryPoints) {
+            const itinerary = this.getItineraryInsideMap(entryPoint, end, options);
+            if (itinerary) {
+                return itinerary;
+            }
+            // no route found
+        }
+        throw new NoRouteFoundError(start, end,
+            `No route found from entry points to ${end.toString()} in map: ${this.name}`
+        );
+    }
+
+
+    /**
+     * Get the best itinerary from start coordinates to any entry point.
+     *
+     * The algorithm works as following:
+     * 1 - Entry points are sorted using distance (as the crow flies) between start - entry point - end
+     * 2 - Try to calculate an itinerary from the start coordinates to the first entry point.
+     * 3 - If an itinerary is found, it is returned. Otherwise it tries to the next entry point.
+     *
+     * /!\ end is only used to sort the entry points (step 1).
+     *
+     * @param {Coordinates} start The start coordinates (which is inside the network)
+     * @param {Coordinates} end Then end coordinates (which is outside the network)
+     * @param {WemapRouterOptions} options
+     * @returns {Itinerary}
+     */
+    getBestItineraryFromStartToEntryPoints(start, end, options) {
+
+        const sortedEntryPoints = this.getOrderedEntryPointsSortedByDistance(start, end);
+        for (const entryPoint of sortedEntryPoints) {
+            const itinerary = this.getItineraryInsideMap(start, entryPoint, options);
+            if (itinerary) {
+                return itinerary;
+            }
+            // no route found
+        }
+        throw new NoRouteFoundError(start, end,
+            `No route found from ${start.toString()} to entry points in map: ${this.name}`
+        );
+    }
+
+    /**
+     * @param {Coordinates} start the start coordinates
+     * @param {Coordinates} end the end coordinates
+     * @param {WemapRouterOptions} options
+     * @returns {?Itinerary}
+     */
+    getItineraryInsideMap(start, end, options) {
+
+        // Call the Wemap router to get the shortest path
+        const graphItinerary = this.router.getShortestPath(start, end, options);
+        if (graphItinerary === null) {
+            return null;
+        }
+
+        // Transform a network itinerary (nodes, edges...) to a router itinerary (legs, steps...)
+        return createItineraryFromGraphItinerary(graphItinerary, Constants.ROUTING_MODE.WALK);
+    }
+}
+
+class WemapMetaRouterOptions {
+
+    /** @type {!boolean} */
+    useStairs = true;
+
+    /** @type {?(string[])} */
+    targetMaps = null;
+
+    /**
+     * List of ordered remote routers (first of the list, first tested)
+     * Algorithm will try the first router and if it fails continue
+     * with the second, etc...
+     * @type {!({name: string, endpointUrl: string}[])}
+     */
+    remoteRouters = [];
+}
+
+class RemoteRouterOptions {
+
+    /** @type {boolean} */
+    useStairs = true;
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        return { useStairs: this.useStairs };
+    }
+
+    /**
+     * @param {object}
+     * @returns {RemoteRouterOptions}
+     */
+    static fromJson(json) {
+        const obj = new RemoteRouterOptions();
+        obj.useStairs = json.useStairs;
+        return obj;
+    }
+
+}
+
+class RemoteRouter {
+
+    /**
+     * Get the router name
+     * @type {string} the router name
+     */
+    get rname() {
+        return 'Unknown';
+    }
+
+    /**
+     * @abstract
+     * @param {string} endpointUrl
+     * @param {string} mode see Constants.ROUTING_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()');
+    }
+
+}
+
+/**
+ * @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);
+
+        });
+    });
+}
+
+
+/**
+ * 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 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;
+}
+
+class RemoteRouterServerUnreachable extends Error {
+
+    /**
+     * @param {!string} name
+     * @param {!string} endpointUrl
+     */
+    constructor(name, endpointUrl) {
+        super(`Remote router server ${name} is unreachable. URL: ${endpointUrl}`);
+    }
+}
+
+class RoutingModeCorrespondanceNotFound extends Error {
+
+    /** @type {!string} */
+    routerName;
+
+    /** @type {!string} */
+    routingMode;
+
+    /**
+     * @param {!string} routerName
+     * @param {!string} routingMode
+     */
+    constructor(routerName, routingMode) {
+        this.routerName = routerName;
+        this.routingMode = routingMode;
+        super(`routing mode "${routingMode}" correspondance not found for router "${routerName}"`);
+    }
+}
+
+/* eslint-disable max-depth */
+
+/**
+ * Input mode correspondance
+ */
+const inputModeCorrespondance$2 = new Map();
+inputModeCorrespondance$2.set(Constants.ROUTING_MODE.CAR, 'Car');
+inputModeCorrespondance$2.set(Constants.ROUTING_MODE.WALK, 'Walk');
+inputModeCorrespondance$2.set(Constants.ROUTING_MODE.BIKE, 'Bike');
+inputModeCorrespondance$2.set(Constants.ROUTING_MODE.BUS, 'PT');
+inputModeCorrespondance$2.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
+     * @throws {RoutingModeCorrespondanceNotFound}
+     * @throws {RemoteRouterServerUnreachable}
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        const url = this.getURL(endpointUrl, mode, waypoints);
+        const res = await fetch(url);
+        if (res.status !== 200) {
+            throw new RemoteRouterServerUnreachable(this.rname, url);
+        }
+        const response = await res.json();
+        return this.createRouterResponseFromJson(response);
+    }
+
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     * @throws {RoutingModeCorrespondanceNotFound}
+     */
+    getURL(endpointUrl, mode, waypoints) {
+        const citywayMode = inputModeCorrespondance$2.get(mode);
+        if (!citywayMode) {
+            throw new RoutingModeCorrespondanceNotFound(this.rname, 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;
+                }
+
+                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);
+                            }
+                        });
+
+
+                        step.name = jsonPathLink.Departure.Site.Name;
+                        step.levelChange = null;
+
+                        step.distance = jsonPathLink.Distance;
+
+                        leg.steps.push(step);
+                    }
+
+                } 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}`);
+                }
+
+                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);
+
+            }
+
+            routerResponse.itineraries.push(itinerary);
+
+            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;
+
+        return routerResponse;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Coordinates}
+     */
+    jsonToCoordinates(json) {
+        return new Coordinates(json.Lat, json.Long);
+    }
+
+    /**
+     * @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();
+    }
+
+    /**
+     * @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 (tmpCoordsPt) {
+            const [lng, lat] = tmpCoordsPt[1].split(' ');
+            return [new Coordinates(Number(lat), Number(lng))];
+        }
+
+        return tmpCoordsStr[1].split(',').map(str => {
+            const sp = str.trim().split(' ');
+            return new Coordinates(Number(sp[1]), Number(sp[0]));
+        });
+    }
+
+    /**
+     * @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 */
+
+/**
+ * Singleton.
+ */
+class DeutscheBahnRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'deutsche-bahn';
+    }
+
+    /**
+     * @override
+     * @throws {RemoteRouterServerUnreachable}
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        const url = this.getURL(endpointUrl, mode, waypoints);
+        const res = await fetch(url);
+        if (res.status !== 200) {
+            throw new RemoteRouterServerUnreachable(this.rname, url);
+        }
+        const response = await res.json();
+        return this.createRouterResponseFromJson(response, waypoints[0], waypoints[1]);
+    }
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     */
+    getURL(endpointUrl, mode, waypoints) {
+        let url = endpointUrl + '/route/v1/walking/';
+
+        url += 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(';');
+
+        url += '?geometries=geojson&overview=full&steps=true';
+
+        return url;
+    }
+
+    /**
+     * 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) {
+
+        const { segments: jsonSegments } = json;
+
+        if (!jsonSegments) {
+            return null;
+        }
+
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
+
+        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);
+
+                if (nodes.length !== 0
+                    && nodes[nodes.length - 1].coords.equalsTo(coord)) {
+                    continue;
+                }
+
+                const osmNode = new OsmNode(id++, coord);
+                const node = new GraphNode(osmNode.coords, osmNode);
+
+                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;
+    }
+}
+
+var DeutscheBahnRemoteRouter$1 = new DeutscheBahnRemoteRouter();
+
+class IdfmRemoteRouterTokenError extends Error {
+
+    constructor() {
+        super('An error occured with IDFM token request');
+    }
+}
+
+/* eslint-disable max-statements */
+
+/**
+ * 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 last(array) {
+    return array[array.length - 1];
+}
+
+/**
+ * Singleton.
+ */
+class IdfmRemoteRouter extends RemoteRouter {
+
+    isLogged = false;
+    token = null;
+    expiresAt = null;
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'idfm';
+    }
+
+    /**
+     * @override
+     * @throws {IdfmRemoteRouterTokenError}
+     * @throws {RemoteRouterServerUnreachable}
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        if (!this.canRequestService()) {
+            await this._connect();
+        }
+
+        const url = this.getURL(endpointUrl, mode, waypoints);
+
+        const res = await fetch(url, {
+            method: 'GET',
+            headers: { Authorization: 'Bearer ' + this.token }
+        });
+        if (res.status !== 200) {
+            throw new RemoteRouterServerUnreachable(this.rname, url);
+        }
+        const response = await res.json();
+
+        return this.createRouterResponseFromJson(response);
+    }
+
+    /**
+     * @throws {IdfmRemoteRouterTokenError}
+     */
+    async _connect() {
+
+        const details = {
+            'grant_type': 'client_credentials',
+            'scope': 'read-data',
+            'client_id': clientId,
+            'client_secret': clientSecret
+        };
+
+        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 headers = new Headers({
+            'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'
+        });
+
+        const res = await fetch('https://idfm.getwemap.com/api/oauth/token', {
+            method: 'POST',
+            body: data,
+            headers
+        });
+        if (res.status !== 200) {
+            throw new IdfmRemoteRouterTokenError();
+        }
+        const response = await res.json();
+
+        if (response.access_token) {
+            this.token = response.access_token;
+            this.isLogged = true;
+            this.expiresAt = new Date(new Date().getTime() + response.expires_in * 1000);
+        }
+    }
+
+    canRequestService() {
+        return this.token && this.expiresAt && this.expiresAt - new Date() > 0;
+    }
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     */
+    getURL(endpointUrl, mode, waypoints) {
+
+        if (waypoints.length > 2) {
+            Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+        }
+
+        const fromPlace = `from=${waypoints[0].longitude};${waypoints[0].latitude}`;
+        const toPlace = `to=${waypoints[1].longitude};${waypoints[1].latitude}`;
+
+        let url = new URL(endpointUrl);
+        let { search } = url;
+        search = (search ? `${search}&` : '?') + `${fromPlace}&${toPlace}`;
+
+        let query = '';
+        switch (mode) {
+        case Constants.ROUTING_MODE.WALK:
+            query = this.getWalkingQuery();
+            break;
+        case Constants.ROUTING_MODE.BIKE:
+            query = this.getBikeQuery();
+            break;
+        case Constants.ROUTING_MODE.CAR:
+            query = this.getCarQuery();
+            break;
+        }
+
+        url = `${url.origin}${url.pathname}${search}${query}`;
+
+        return url;
+    }
+
+    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';
+
+        return `&${forbiddenTransport}&${allowCar}`;
+    }
+
+    getWalkingQuery() {
+        const forbiddenTransport = TRANSPORT_IDS.map((id) => `forbidden_uris[]=${id}`).join('&');
+        const allowWalking = 'first_section_mode[]=walking&last_section_mode[]=walking';
+
+        return `&${forbiddenTransport}&${allowWalking}`;
+    }
+
+    getBikeQuery() {
+        const forbiddenTransport = TRANSPORT_IDS.map((id) => `forbidden_uris[]=${id}`).join('&');
+        const allowBike = 'first_section_mode[]=bike&last_section_mode[]=bike';
+
+        return `&${forbiddenTransport}&${allowBike}`;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Coordinates}
+     */
+    jsonToCoordinates(json) {
+        return new Coordinates(Number(json.lat), Number(json.lon));
+    }
+
+    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);
+
+        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;
+
+            if (idx === 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++;
+
+                step._idCoordsInLeg = accumulatedIndex;
+
+                newCoords = duplicatedCoords[0];
+
+                coords[step._idCoordsInLeg] = newCoords;
+            } else {
+                const result = Utils.trimRoute(duplicatedCoords, duplicatedCoords[0], previousStep.distance);
+                accumulatedIndex += result.length - 1;
+
+                duplicatedCoords.splice(0, result.length - 1);
+
+                step._idCoordsInLeg = accumulatedIndex;
+
+                newCoords = last(result);
+
+                coords[step._idCoordsInLeg] = newCoords;
+            }
+
+            step.coords = newCoords;
+
+            previousStep = step;
+        }
+    }
+
+    /**
+     * @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();
+    }
+
+    /**
+     * Generate multi itineraries from OTP JSON
+     * @param {object} json JSON file provided by OTP.
+     * @returns {?RouterResponse}
+     */
+    createRouterResponseFromJson(json) {
+
+        if (!json || !json.journeys) {
+            return null;
+        }
+
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
+
+        routerResponse.from = this.getSectionCoords(json.journeys[0].sections[0]).from;
+        routerResponse.to = this.getSectionCoords(last(json.journeys[0].sections)).to;
+
+        const timeZone = json.context.timezone;
+
+        for (const jsonItinerary of json.journeys) {
+
+            const itinerary = new Itinerary();
+
+            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;
+
+            routerResponse.itineraries.push(itinerary);
+
+            for (const jsonSection of jsonItinerary.sections) {
+
+                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: jsonSection.from.name,
+                    coords: from
+                };
+
+                leg.to = {
+                    name: jsonSection.to.name,
+                    coords: to
+                };
+
+                // 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));
+                    }
+
+                    return acc;
+                }, []);
+
+                leg.steps = [];
+
+                if (jsonSection.path) {
+                    for (const jsonPathLink of jsonSection.path) {
+                        const step = new Step();
+
+                        step.levelChange = null;
+
+                        step.name = jsonPathLink.name;
+                        step.distance = jsonPathLink.length;
+
+                        leg.distance += step.distance;
+                        leg.steps.push(step);
+                    }
+
+                    this.findStepsCoord(leg);
+                }
+
+                if (jsonSection.type === 'public_transport') {
+                    leg.transportInfo = {
+                        name: jsonSection.display_informations.code,
+                        routeColor: jsonSection.display_informations.color,
+                        routeTextColor: jsonSection.display_informations.text_color,
+                        directionName: jsonSection.display_informations.direction
+                    };
+
+                    leg.mode = routingModeCorrespondance.get(jsonSection.display_informations.physical_mode);
+
+                    const legStep = new 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.steps = [legStep];
+                }
+
+                itinerary.distance += leg.distance;
+
+                itinerary.legs.push(leg);
+
+            }
+
+            // All legs have to be parsed before computing steps metadata
+            generateStepsMetadata(itinerary);
+        }
+
+        return routerResponse;
+    }
+}
+
+var IdfmRemoteRouter$1 = new IdfmRemoteRouter();
+
+/* eslint-disable max-statements */
+
+/**
+ * Input mode correspondance
+ */
+const inputModeCorrespondance$1 = new Map();
+inputModeCorrespondance$1.set(Constants.ROUTING_MODE.CAR, 'driving');
+inputModeCorrespondance$1.set(Constants.ROUTING_MODE.WALK, 'walking');
+inputModeCorrespondance$1.set(Constants.ROUTING_MODE.BIKE, 'bike');
+inputModeCorrespondance$1.set(Constants.ROUTING_MODE.BUS, 'bus');
+inputModeCorrespondance$1.set(Constants.ROUTING_MODE.MULTI, 'walking');
+
+
+/**
+ * Singleton.
+ */
+class OsrmRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'osrm';
+    }
+
+    /**
+     * @override
+     * @throws {RemoteRouterServerUnreachable}
+     * @throws {RoutingModeCorrespondanceNotFound}
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        const url = this.getURL(endpointUrl, mode, waypoints);
+        const res = await fetch(url);
+        if (res.status !== 200) {
+            throw new RemoteRouterServerUnreachable(this.rname, url);
+        }
+        const response = await res.json();
+        return this.createRouterResponseFromJson(response, waypoints[0], waypoints[1]);
+    }
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     * @throws {RoutingModeCorrespondanceNotFound}
+     */
+    getURL(endpointUrl, mode, waypoints) {
+
+        const osrmMode = inputModeCorrespondance$1.get(mode);
+        if (!osrmMode) {
+            throw new RoutingModeCorrespondanceNotFound(this.rname, 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();
+
+/* eslint-disable max-statements */
+
+/**
+ * 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, 'BICYCLE');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.BUS, 'WALK,TRANSIT');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.MULTI, 'WALK,TRANSIT');
+
+/**
+ * Singleton.
+ */
+class OtpRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'otp';
+    }
+
+    /**
+     * @override
+     * @throws {RemoteRouterServerUnreachable}
+     * @throws {RoutingModeCorrespondanceNotFound}
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        const url = this.getURL(endpointUrl, mode, waypoints);
+        const res = await fetch(url);
+        if (res.status !== 200) {
+            throw new RemoteRouterServerUnreachable(this.rname, url);
+        }
+        const response = await res.json();
+        return this.createRouterResponseFromJson(response);
+    }
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     * @throws {RoutingModeCorrespondanceNotFound}
+     */
+    getURL(endpointUrl, mode, waypoints) {
+
+        const otpMode = inputModeCorrespondance.get(mode);
+        if (!otpMode) {
+            throw new RoutingModeCorrespondanceNotFound(this.rname, 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();
+
+/**
+ * Singleton
+ */
+class RemoteRouterManager {
+
+    /** @type {RemoteRouter[]} */
+    remoteRouters = [
+        CitywayRemoteRouter$1,
+        DeutscheBahnRemoteRouter$1,
+        IdfmRemoteRouter$1,
+        OsrmRemoteRouter$1,
+        OtpRemoteRouter$1
+    ];
+
+    /**
+     * @param {string} name
+     * @returns {RemoteRouter}
+     */
+    getRouterByName(name) {
+        return this.remoteRouters.find(remoteRouter => remoteRouter.rname === name);
+    }
+
+    /**
+     * @param {!string} endpointUrl
+     * @param {!string} mode see Constants.ROUTING_MODE
+     * @param {Array<Coordinates>} waypoints
+     * @param {?RemoteRouterOptions} options
+     * @returns {!RouterResponse}
+     * @throws {RemoteRouterServerUnreachable}
+     * @throws {RoutingModeCorrespondanceNotFound}
+     * @throws {IdfmRemoteRouterTokenError}
+     */
+    async getItineraries(name, endpointUrl, mode, waypoints, options = new RemoteRouterOptions()) {
+        const router = this.getRouterByName(name);
+        if (!router) {
+            throw new Error(`Unknown "${this.rname}" remote router`);
+        }
+        return router.getItineraries(endpointUrl, mode, waypoints, options);
+    }
+
+
+    /**
+     * @param {!{name: string, endpointUrl: string}[]} remoteRouters
+     * @param {!string} mode see Constants.ROUTING_MODE
+     * @param {!Array<Coordinates>} waypoints
+     * @param {?RemoteRouterOptions} options
+     * @returns {!RouterResponse}
+     * @throws {RemoteRouterServerUnreachable}
+     * @throws {RoutingModeCorrespondanceNotFound}
+     * @throws {IdfmRemoteRouterTokenError}
+     */
+    async getItinerariesWithFallback(remoteRouters, mode, waypoints, options = new RemoteRouterOptions()) {
+        let routerResponse;
+        for (const { name, endpointUrl } of remoteRouters) {
+            routerResponse = await this.getItineraries(name, endpointUrl, mode, waypoints, options);
+            if (routerResponse.itineraries.length) {
+                return routerResponse;
+            }
+        }
+        if (!routerResponse) {
+            routerResponse = new RouterResponse();
+            routerResponse.from = waypoints[0];
+            routerResponse.to = waypoints[waypoints.length];
+        }
+        return routerResponse;
+    }
+
+}
+
+var RemoteRouterManager$1 = new RemoteRouterManager();
+
+// Also extends properties of WemapMetaRouterOptions
+class WemapMetaRemoteRouterOptions extends RemoteRouterOptions {
+
+    constructor() {
+        super();
+        // Ugly multiple inheritance trick
+        Object.assign(this, new WemapMetaRouterOptions());
+    }
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const json = super.toJson();
+        json.remoteRouters = this.remoteRouters;
+        if (this.targetMaps) {
+            json.targetMaps = this.targetMaps;
+        }
+        return json;
+    }
+
+    /**
+     * @param {object}
+     * @returns {WemapMetaRemoteRouterOptions}
+     */
+    static fromJson(json) {
+        const obj = new WemapMetaRemoteRouterOptions();
+        obj.useStairs = json.useStairs;
+        obj.remoteRouters = json.remoteRouters;
+        obj.targetMaps = json.targetMaps ? json.targetMaps : null;
+        return obj;
+    }
+}
+
+/* eslint-disable complexity */
+
+
+class WemapMetaRouter {
+
+    /** @type {!(IOMap[])} */
+    maps = [];
+
+
+    /** @type {string} */
+    get rname() {
+        return 'wemap-meta';
+    }
+
+    /**
+     * @param {!IOMap} ioMap
+     */
+    addIOMap(ioMap) {
+        this.maps.push(ioMap);
+    }
+
+    /**
+     * @param {!IOMap} ioMap
+     */
+    removeIOMap(ioMap) {
+        this.maps = this.maps.filter(map => map !== ioMap);
+    }
+
+    /**
+     * @param {string} mode see Constants.ROUTING_MODE
+     * @param {Coordinates[]} waypoints
+     * @param {WemapMetaRouterOptions} options
+     * @returns {RouterResponse}
+     */
+    async getItineraries(mode, waypoints, options) {
+
+        /*
+         * Here, we try to get the shortest path using io maps networks and a remote router server.
+         */
+
+        /**
+         * ----- 1 -----
+         * Parse function params
+         * -------------
+         */
+
+        if (waypoints.length > 2) {
+            Logger.warn(`WemapMetaRouter uses only the first 2 waypoints (asked ${waypoints.length})`);
+        }
+        const start = waypoints[0];
+        const end = waypoints[1];
+
+        // Avoid cycles on remoteRouters
+        const remoteRouters = options.remoteRouters.filter(
+            ({ name }) => name !== WemapMetaRemoteRouterOptions.rname
+        );
+
+        /*
+         * ----- 2 -----
+         * Retrieve the IO maps to consider for this itinerary
+         * -------------
+         *
+         * By default, all maps in this.maps are considered
+         * If options.targetMaps is defined, only use this subset
+         */
+        let ioMapsToTest = this.maps;
+
+        const { targetMaps } = options;
+        if (targetMaps) {
+
+            ioMapsToTest = this.maps.filter(map => targetMaps.includes(map.name));
+
+            // Send a warning if one of the request ioMap (from targetMaps) is not present in this.maps
+            if (ioMapsToTest.length !== targetMaps.length) {
+                targetMaps.forEach(map => {
+                    if (!ioMapsToTest.includes(map)) {
+                        Logger.warn(`IOMap "${map.name}" not found in WemapMetaRouter`);
+                    }
+                });
+            }
+        }
+
+        /*
+         * If there is no local map to test, use remote router directly.
+         * This should happen:
+         * 1 - this.maps is empty
+         * 2 - options.targetMaps is defined but empty
+         * 3 - intersection of this.maps and options.targetMaps is empty
+         */
+        if (!ioMapsToTest.length) {
+            return RemoteRouterManager$1.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+        }
+
+
+        /**
+         * ----- 3 -----
+         * Run the IO Maps - Remote Routers logic
+         * -------------
+         *
+         * For this purpose we have to consider 5 use cases
+         *
+         */
+
+        const routerResponse = new RouterResponse();
+        routerResponse.from = start;
+        routerResponse.to = end;
+
+
+        // Find the first map where the "start" is inside.
+        const mapWithStart = ioMapsToTest.find(map => map.isPointInside(start));
+
+        // Create WemapRouterOptions from WemapMetaRouterOptions
+        const wemapRouterOptions = options.useStairs
+            ? WemapRouterOptions.DEFAULT
+            : WemapRouterOptions.WITHOUT_STAIRS;
+
+        /*
+         * Case 1
+         *
+         * If "start" and "end" are in the same map, use the local router.
+         */
+        if (mapWithStart && mapWithStart.isPointInside(end)) {
+
+            const itinerary = mapWithStart.getItineraryInsideMap(start, end, wemapRouterOptions);
+
+            routerResponse.itineraries.push(itinerary);
+            routerResponse.routerName = [this.rname, WemapRouter.rname];
+
+            return routerResponse;
+        }
+
+        // Find the first map where the "end" is inside.
+        // Note: At this step, mapWithEnd is necessarily different from mapWithStart
+        const mapWithEnd = ioMapsToTest.find(map => map.isPointInside(end));
+
+        /*
+         * Case 2
+         *
+         * If no io map have been found for "start" and "end", therefore use remote router.
+         */
+        if (!mapWithStart && !mapWithEnd) {
+            return RemoteRouterManager$1.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+        }
+
+        /** @type {RouterResponse} */
+        let remoteRouterResponse;
+
+        /** @type {Itinerary} */
+        let ioMapItinerary;
+
+        /**
+         * Case 3
+         *
+         * If a map has been found for the "start"  but not for the "end", so:
+         * - A first itinerary (firstRoute) is calculated from "start" to an "entrypoint"
+         *  of the IO map network using the wemap router.
+         * - A second itinerary (secondRoute) is calculated from an "entrypoint" to the
+         * "end" using remote routers.
+         * Itinerary returned is the concatenation of the both itineraries.
+         *
+         * Note: Check the mapWithEnd.getBestItineraryFromEntryPointsToEnd to understand
+         * which "entrypoint" is chosen by the algorithm
+         */
+        if (mapWithStart && !mapWithEnd) {
+
+            if (!mapWithStart.entryPoints.length) {
+                routerResponse.error = `A map including the "start" but the "end" has been 
+                    found (${mapWithStart.name}), however, no "entrypoints" have been found to go out`;
+                return routerResponse;
+            }
+
+            ioMapItinerary = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapRouterOptions);
+            remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
+                remoteRouters, mode, [ioMapItinerary.to, end]
+            );
+
+
+            if (!remoteRouterResponse.itineraries.length) {
+                routerResponse.error = `Tried to calculate an itinerary from "start" 
+                    to "entrypoints" using wemap router on local map "${mapWithStart.name}" and
+                    an itinerary from  "entrypoints" to "end" using remote routers 
+                    (${remoteRouters.map(r => r.name).join(', ')}), but failed.`;
+                return routerResponse;
+            }
+
+            // Concat the the IO map itinerary with the remote router response (for each itinerary)
+            routerResponse.itineraries = remoteRouterResponse.itineraries.map(
+                remoteRouterItinerary => Itinerary.fromItineraries(ioMapItinerary, remoteRouterItinerary)
+            );
+            routerResponse.routerName = [this.rname, remoteRouterResponse.routerName, WemapRouter.rname];
+            return routerResponse;
+        }
+
+        /*
+         * Case 4
+         *
+         * If a map has been found for the "end" but not for the "start", so:
+         * - A first itinerary (remoteRouterResponse) is calculated from "start" to an "entrypoint"
+         *  of the IO map network using remote routers.
+         * - A second itinerary (ioMapItinerary) is calculated from an "entrypoint" to the
+         *  "end" using the wemap router.
+         * Itinerary returned is the concatenation of the both itineraries.
+         *
+         * Note: Check the mapWithEnd.getBestItineraryFromEntryPointsToEnd to understand
+         * which "entrypoint" is chosen by the algorithm
+         */
+        if (!mapWithStart && mapWithEnd) {
+
+            if (!mapWithEnd.entryPoints.length) {
+                routerResponse.error = `A map including the "end" but the "start" has been 
+                    found (${mapWithEnd.name}), however, no "entrypoints" have been found to go in`;
+                return routerResponse;
+            }
+
+            /*
+             * ioMapItinerary is computed before the remoteRouterResponse because it is less expensive to
+             * calculate all the routes to entrypoints using local router than all the routes with the
+             * remote router.
+             */
+            ioMapItinerary = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapRouterOptions);
+            remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
+                remoteRouters, mode, [start, ioMapItinerary.from]
+            );
+
+            if (!remoteRouterResponse.itineraries.length) {
+                routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" 
+                    using remote routers (${remoteRouters.map(r => r.name).join(', ')}) and an
+                    itinerary from "entrypoints" to "end" using wemap router on local map
+                    "${mapWithEnd.name}", but failed.`;
+                return routerResponse;
+            }
+
+            // Concat the remote router response (for each itinerary) with the IO map itinerary
+            routerResponse.itineraries = remoteRouterResponse.itineraries.map(
+                remoteRouterItinerary => Itinerary.fromItineraries(remoteRouterItinerary, ioMapItinerary)
+            );
+            routerResponse.routerName = [this.rname, remoteRouterResponse.routerName, WemapRouter.rname];
+            return routerResponse;
+        }
+
+        /**
+         * Case 5
+         *
+         * If maps have been found for the "start" and the "end" but they are different, so:
+         * - A first itinerary (ioMapItinerary1) is calculated from "start" to an "entrypoint" of
+         *  the mapWithStart using the wemap router.
+         * - A second itinerary (remoteRouterResponse) is calculated from an "entrypoint" of the
+         *  mapWithStart to an "entrypoint" of the endWithMap using remote routers.
+         * - A third itinerary (ioMapItinerary2) is calculated from an "entrypoint" of the mapWithEnd
+         *  to the "end" using the wemap router.
+         * Itinerary returned is the concatenation of the three itineraries.
+         */
+        // if (startMap && endMap) {
+
+        if (!mapWithStart.entryPoints.length) {
+            routerResponse.error = `One map including the "start" (${mapWithStart.name}) and another 
+                including the "end" (${mapWithEnd.name}) has been found, however, no "entrypoints" have 
+                been found to go out of the start map`;
+            return routerResponse;
+        }
+
+        if (!mapWithEnd.entryPoints.length) {
+            routerResponse.error = `One map including the "start" (${mapWithStart.name}) and another 
+                including the "end" (${mapWithEnd.name}) has been found, however, no "entrypoints" have 
+                been found to go in the second map`;
+            return routerResponse;
+        }
+
+        const ioMapItinerary1 = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapRouterOptions);
+        const ioMapItinerary2 = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapRouterOptions);
+        remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
+            remoteRouters, mode, [ioMapItinerary1.to, ioMapItinerary2.from]
+        );
+
+        if (!remoteRouterResponse.itineraries.length) {
+            routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints1" 
+                using wemap router on local map  "${mapWithStart.name}", an itinerary from
+                "entrypoints1" to "entrypoints2" using remote routers 
+                (${remoteRouters.map(r => r.name).join(', ')}) and an itinerary from "entrypoints2" 
+                to "end" using wemap router on local map "${mapWithEnd.name}", but failed.`;
+            return routerResponse;
+        }
+
+        // Concat the IO map itinerary 2 with the remote router response (for each itinerary)
+        // and the IO map itinerary 2
+        routerResponse.itineraries = remoteRouterResponse.itineraries.map(
+            remoteRouterItinerary => Itinerary.fromItineraries(
+                ioMapItinerary1,
+                remoteRouterItinerary,
+                ioMapItinerary2
+            )
+        );
+        routerResponse.routerName = [this.rname, remoteRouterResponse.routerName, WemapRouter.rname];
+        return routerResponse;
+
+        // }
+    }
+
+}
+
+class WemapMetaRemoteRouterPayload {
+
+    /** @type {!(Coordinates[])} */
+    waypoints;
+
+    /** @type {!string} */
+    mode;
+
+    /** @type {!WemapMetaRemoteRouterOptions} */
+    options = null;
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const json = {
+            waypoints: this.waypoints.map(coords => coords.toCompressedJson()),
+            mode: this.mode
+        };
+        if (this.options) {
+            json.options = this.options.toJson();
+        }
+        return json;
+    }
+
+    /**
+     * @param {object}
+     * @returns {WemapMetaRemoteRouterPayload}
+     */
+    static fromJson(json) {
+        const obj = new WemapMetaRemoteRouterPayload();
+        obj.waypoints = json.waypoints.map(coords => Coordinates.fromCompressedJson(coords));
+        obj.mode = json.mode;
+        if (json.options) {
+            obj.options = WemapMetaRemoteRouterOptions.fromJson(json.options);
+        }
+        return obj;
+    }
+}
+
+/* eslint-disable max-statements */
+
+
+/**
+ * Singleton.
+ */
+class WemapMetaRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'wemap-meta';
+    }
+
+    /**
+     * @param {!string} endpointUrl
+     * @param {!string} mode see Constants.ROUTING_MODE
+     * @param {Array<Coordinates>} waypoints
+     * @param {?WemapMetaRemoteRouterOptions} options
+     * @returns {!RouterResponse}
+     * @throws {RemoteRouterServerUnreachable}
+     */
+    async getItineraries(endpointUrl, mode, waypoints, options) {
+
+        const payload = new WemapMetaRemoteRouterPayload();
+        payload.waypoints = waypoints;
+        payload.mode = mode;
+        payload.options = options;
+
+        const res = await fetch(endpointUrl, {
+            method: 'POST',
+            headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(payload.toJson())
+        });
+
+        if (res.status !== 200) {
+            throw new RemoteRouterServerUnreachable(this.rname, endpointUrl);
+        }
+        const response = await res.json();
+        return RouterResponse.fromJson(response);
+    }
+
+}
+
+var WemapMetaRemoteRouter$1 = new WemapMetaRemoteRouter();
+
+/* eslint-disable max-statements */
+
+class ItineraryInfoManager {
+
+    /** @type {Itinerary} */
+    _itinerary;
+
+    /** @type {Network} */
+    _network;
+
+    /** @type {Network} */
+    _mapMatching;
+
+    /** @type {Step[]} */
+    _steps;
+
+    /** @type {Step[]} */
+    _coordsNextStep;
+
+    /** @type {Step[]} */
+    _coordsPreviousStep;
+
+    /** @type {number[]} */
+    _coordsDistanceTraveled;
+
+    /** @type {Leg[]} */
+    _coordsLeg;
+
+    /** @type {Itinerary} */
+    set itinerary(itinerary) {
+
+        if (itinerary === null) {
+            this._itinerary = null;
+            return;
+        }
+
+        this._itinerary = itinerary;
+        this._steps = itinerary.steps;
+        this._network = itinerary.toNetwork();
+        this._mapMatching = new MapMatching(this._network);
+
+        this._coordsNextStep = new Array(itinerary.coords.length);
+        this._coordsPreviousStep = new Array(itinerary.coords.length);
+        this._coordsDistanceTraveled = new Array(itinerary.coords.length);
+        this._coordsLeg = new Array(itinerary.coords.length);
+
+        let stepId = 0;
+        let previousStep = null;
+        let nextStep = this._steps[0];
+        let distanceTraveled = 0;
+
+        itinerary.coords.forEach((coords, idx, arr) => {
+            if (stepId < this._steps.length && this._steps[stepId].coords.equalsTo(coords)) {
+                previousStep = this._steps[stepId];
+                nextStep = stepId === this._steps.length - 1 ? null : this._steps[stepId + 1];
+                stepId++;
+            }
+            if (idx !== 0) {
+                distanceTraveled += arr[idx - 1].distanceTo(coords);
+            }
+
+            this._coordsNextStep[idx] = nextStep;
+            this._coordsPreviousStep[idx] = previousStep;
+            this._coordsDistanceTraveled[idx] = distanceTraveled;
+            this._coordsLeg[idx] = itinerary.legs.find(leg => leg.coords.includes(coords));
+        });
+    }
+
+    /**
+     * @param {Coordinates} position
+     * @returns {ItineraryInfo}
+     */
+    getInfo(position) {
+
+        if (!this._itinerary) {
+            return null;
+        }
+
+        if (!(position instanceof Coordinates)) {
+            return null;
+        }
+
+        const projection = this._mapMatching.getProjection(position);
+        if (!projection) {
+            return null;
+        }
+
+        let itineraryInfo = null;
+
+        if (projection.nearestElement instanceof GraphNode) {
+            const idx = this._itinerary.coords.findIndex(
+                coords => projection.nearestElement.coords === coords
+            );
+            if (idx === -1) {
+                throw new Error('ItineraryInfoManager: could not find projection in itinerary (Node)');
+            }
+
+            itineraryInfo = new ItineraryInfo();
+            itineraryInfo.nextStep = this._coordsNextStep[idx];
+            itineraryInfo.previousStep = this._coordsPreviousStep[idx];
+            itineraryInfo.projection = projection;
+            itineraryInfo.leg = this._coordsLeg[idx];
+            itineraryInfo.traveledDistance = this._coordsDistanceTraveled[idx];
+            itineraryInfo.remainingDistance = this._itinerary.distance - itineraryInfo.traveledDistance;
+            itineraryInfo.traveledPercentage = itineraryInfo.traveledDistance / this._itinerary.distance;
+            itineraryInfo.remainingPercentage = itineraryInfo.remainingDistance / this._itinerary.distance;
+
+        } else if (projection.nearestElement instanceof GraphEdge) {
+
+            let firstNode = projection.nearestElement.node1.coords;
+            let idx = this._itinerary.coords.findIndex(coords => firstNode === coords);
+            if (idx === -1) {
+                throw new Error('ItineraryInfoManager: could not find projection in itinerary (Edge)');
+            }
+
+            // graphEdge is not necessarly ordered. We have to look for the first point
+            if (idx === this._itinerary.coords.length - 1
+                || this._itinerary.coords[idx + 1] !== projection.nearestElement.node2.coords
+            ) {
+                firstNode = projection.nearestElement.node2.coords;
+                idx--;
+            }
+
+            itineraryInfo = new ItineraryInfo();
+            itineraryInfo.nextStep = this._coordsNextStep[idx];
+            itineraryInfo.previousStep = this._coordsPreviousStep[idx];
+            itineraryInfo.projection = projection;
+            itineraryInfo.leg = this._coordsLeg[idx];
+            itineraryInfo.traveledDistance = this._coordsDistanceTraveled[idx]
+                + projection.projection.distanceTo(firstNode);
+            itineraryInfo.remainingDistance = this._itinerary.distance - itineraryInfo.traveledDistance;
+            itineraryInfo.traveledPercentage = itineraryInfo.traveledDistance / this._itinerary.distance;
+            itineraryInfo.remainingPercentage = itineraryInfo.remainingDistance / this._itinerary.distance;
+
+        }
+
+        return itineraryInfo;
+    }
+
+}
+
+export { CitywayRemoteRouter$1 as CitywayRemoteRouter, Constants, 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, WemapMetaRemoteRouterOptions, WemapMetaRemoteRouterPayload, WemapMetaRouter, IOMap as WemapMetaRouterIOMap, WemapMetaRouterOptions, WemapNetworkUtils, WemapRouter, WemapRouterOptions, WemapRouterUtils, getDurationFromLength };
+//# sourceMappingURL=wemap-routers.es.js.map