@wemap/osm 5.1.0 → 5.1.3

package/dist/wemap-osm.es.js

@@ -0,0 +1,1762 @@
+import { Level, Coordinates, GraphRouterOptions, GraphRouter, GraphUtils, Network, GraphEdge, GraphNode, MapMatching } from '@wemap/geo';
+import { SaxesParser } from 'saxes';
+import { deg2rad, diffAngle, positiveMod, rad2deg } from '@wemap/maths';
+import Polyline from '@mapbox/polyline';
+
+class OsmElement {
+
+    /** @type {number|null} */
+    id;
+
+    /** @type {object} */
+    tags;
+
+    /**
+     * @param {number} id
+     * @param {object} tags
+     */
+    constructor(id, tags) {
+        this.id = id;
+        this.tags = tags || {};
+    }
+}
+
+class OsmWay extends OsmElement {
+
+    /** @type {OsmNode[]} */
+    nodes = [];
+
+    /** @type {?Level} */
+    level = null;
+
+    /**
+     * @param {number} id
+     * @param {object} tags
+     * @param {?Level} level
+     */
+    constructor(id, tags, level) {
+        super(id, tags);
+        this.level = level || null;
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    get areStairs() {
+        return this.tags.highway === 'steps';
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    get isConveying() {
+        return this.tags.hasOwnProperty('conveying');
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    get isEscalator() {
+        return this.areStairs && this.isConveying;
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    get isMovingWalkway() {
+        return !this.areStairs && this.isConveying;
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    get isArea() {
+        // That is not the real definition for OSM
+        return this.nodes[0] === this.nodes[this.nodes.length - 1];
+    }
+}
+
+class OsmNode extends OsmElement {
+
+    /** @type {Coordinates} */
+    coords = null;
+
+    /** @type {OsmWay[]} */
+    ways = [];
+
+    /**
+     * @param {number} id
+     * @param {Coordinates} coords
+     * @param {object} tags
+     */
+    constructor(id, coords, tags) {
+        super(id, tags);
+        this.coords = coords;
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    get isElevator() {
+        return this.tags.highway === 'elevator';
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    get isConveying() {
+        return this.isElevator;
+    }
+}
+
+class OsmModel {
+
+    /** @type {OsmNode[]} */
+    nodes;
+
+    /** @type {OsmWay[]} */
+    ways;
+
+    /**
+     * @param {OsmNode[]|undefined} nodes
+     * @param {OsmWay[]|undefined} ways
+     */
+    constructor(nodes, ways) {
+        this.nodes = nodes || [];
+        this.ways = ways || [];
+    }
+
+    /**
+     * @param {number} id
+     * @returns {OsmNode|null}
+     */
+    getNodeById(id) {
+        return this.nodes.find(node => node.id === id) || null;
+    }
+
+    /**
+     * @param {string} name
+     * @returns {OsmNode|null}
+     */
+    getNodeByName(name) {
+        return this.nodes.find(node => node.tags.name === name) || null;
+    }
+
+
+    /**
+     * @param {number} id
+     * @returns {OsmWay|null}
+     */
+    getWayById(id) {
+        return this.ways.find(way => way.id === id) || null;
+    }
+
+    /**
+     * @param {string} name
+     * @returns {OsmWay|null}
+     */
+    getWayByName(name) {
+        return this.ways.find(way => way.tags.name === name) || null;
+    }
+
+}
+
+/* eslint-disable max-statements */
+
+class OsmParser {
+
+    /**
+     * @param {string} osmXmlString
+     * @returns {OsmModel}
+     */
+    static parseOsmXmlString(osmXmlString) {
+
+        const model = new OsmModel();
+        const parser = new SaxesParser(true);
+
+        let buffer;
+
+        const isDeleted = element => element.attributes.action && element.attributes.action === 'delete';
+
+        parser.on('opentag', (node) => {
+
+            switch (node.name) {
+            case 'node': {
+                if (isDeleted(node)) {
+                    buffer = null;
+                    break;
+                }
+                const osmNode = this._parseNode(node.attributes);
+                buffer = osmNode;
+                model.nodes.push(osmNode);
+                break;
+            }
+            case 'way': {
+                if (isDeleted(node)) {
+                    buffer = null;
+                    break;
+                }
+                const osmWay = this._parseWay(node.attributes);
+                buffer = osmWay;
+                model.ways.push(osmWay);
+                break;
+            }
+            case 'tag': {
+                if (!buffer) {
+                    return;
+                }
+                const {
+                    k, v
+                } = node.attributes;
+                buffer.tags[k] = v;
+                break;
+            }
+            case 'nd': {
+                if (!buffer || !(buffer instanceof OsmWay)) {
+                    return;
+                }
+                const nodeId = Number(node.attributes.ref);
+                const refNode = model.getNodeById(nodeId);
+                if (!refNode) {
+                    throw Error('Node: ' + nodeId + ' in way ' + buffer.id + ' not found');
+                }
+
+                buffer.nodes.push(refNode);
+                refNode.ways.push(buffer);
+                break;
+            }
+            }
+        });
+
+        parser.write(osmXmlString);
+
+        for (let i = 0; i < model.ways.length; i++) {
+            const way = model.ways[i];
+            if (way.tags.level) {
+                way.level = Level.fromString(way.tags.level);
+            }
+        }
+
+        return model;
+    }
+
+
+    static _parseNode(attr) {
+        return new OsmNode(
+            Number(attr.id),
+            new Coordinates(Number(attr.lat), Number(attr.lon)));
+    }
+
+    static _parseWay(attr) {
+        return new OsmWay(Number(attr.id));
+    }
+}
+
+class OsmRouterOptions extends GraphRouterOptions {
+
+    /** @type {OsmRouterOptions} */
+    static DEFAULT = new OsmRouterOptions();
+
+    /**
+     * @returns {OsmRouterOptions}
+     */
+    static get WITHOUT_STAIRS() {
+        const options = new OsmRouterOptions();
+        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 : OsmRouterOptions.getDurationFromLength(edge.length);
+
+
+}
+
+class OsmRouter extends GraphRouter {
+
+    /**
+     * @param {!Network<OsmElement>} network
+     */
+    constructor(network) {
+        super(network);
+    }
+
+    /**
+     * @param {Coordinates} start
+     * @param {Coordinates} end
+     * @param {OsmRouterOptions} options
+     * @returns {GraphItinerary<OsmElement>}
+     */
+    getShortestPath(start, end, options = new OsmRouterOptions()) {
+        return super.getShortestPath(start, end, options);
+    }
+
+}
+
+class LevelChange {
+
+    /** @type {!string} [up|down] */
+    direction;
+
+    /** @type {!number} [-2, -1, 1, ...] */
+    difference;
+
+    /** @type {?string} [elevator|conveyor|stairs] */
+    type = null;
+
+    /**
+     * @param {GraphNode<OsmElement>} firstNode
+     * @param {GraphNode<OsmElement>} secondNode
+     * @returns {LevelChange}
+     */
+    static fromTwoNodes(firstNode, secondNode) {
+
+        const levelChange = new LevelChange();
+
+        const edge = GraphUtils.getEdgeByNodes(firstNode.edges, firstNode, secondNode);
+
+        if (edge.builtFrom.isElevator) {
+            levelChange.type = 'elevator';
+        } else if (edge.builtFrom.isConveying) {
+            levelChange.type = 'conveyor';
+        } else if (edge.builtFrom.areStairs) {
+            levelChange.type = 'stairs';
+        }
+
+        levelChange.difference = Level.diff(firstNode.coords.level, secondNode.coords.level);
+        levelChange.direction = levelChange.difference > 0 ? 'up' : 'down';
+
+        return levelChange;
+    }
+
+    /**
+     * @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;
+
+    /**
+     * @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 !== null) {
+            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 (json.firstStep) {
+            step.firstStep = json.firstStep;
+        }
+        if (json.lastStep) {
+            step.lastStep = json.lastStep;
+        }
+        if (json.duration) {
+            step.duration = json.duration;
+        }
+        if (json.name) {
+            step.name = json.name;
+        }
+        if (json.levelChange) {
+            step.levelChange = LevelChange.fromJson(json.levelChange);
+        }
+        if (json.extras) {
+            step.extras = json.extras;
+        }
+        return step;
+    }
+}
+
+class Leg {
+
+    /** @type {!string} can be WALK, BIKE, BUS, TRAM, CAR */
+    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;
+
+    /**
+     * @returns {Network}
+     */
+    toNetwork() {
+        return Network.fromCoordinates([this.coords]);
+    }
+
+    /**
+     * @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.from.name) {
+            output.from.name = this.from.name;
+        }
+        if (this.to.name) {
+            output.to.name = this.to.name;
+        }
+        if (this.startTime !== null) {
+            output.startTime = this.startTime;
+        }
+        if (this.endTime !== null) {
+            output.endTime = this.endTime;
+        }
+        if (this.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.from = { coords: Coordinates.fromCompressedJson(json.from.coords) };
+        leg.to = { coords: Coordinates.fromCompressedJson(json.to.coords) };
+        leg.distance = json.distance;
+        leg.duration = json.duration;
+        leg.coords = json.coords.map(Coordinates.fromCompressedJson);
+        if (json.from.name) {
+            leg.from.name = json.from.name;
+        }
+        if (json.to.name) {
+            leg.to.name = json.to.name;
+        }
+        if (json.startTime) {
+            leg.startTime = json.startTime;
+        }
+        if (json.endTime) {
+            leg.endTime = json.endTime;
+        }
+        if (json.transportInfo) {
+            leg.transportInfo = json.transportInfo;
+        }
+        if (json.steps) {
+            leg.steps = json.steps.map(Step.fromJson);
+        }
+        return leg;
+    }
+
+}
+
+/* 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 {?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();
+    }
+
+    /**
+     * @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 = from;
+        leg.to = 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 = leg.distance;
+        itinerary.legs.push(leg);
+
+        itinerary.distance = leg.distance;
+        itinerary.duration = leg.duration;
+
+        return itinerary;
+    }
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const output = {
+            from: this.from.toCompressedJson(),
+            to: this.to.toCompressedJson(),
+            distance: this.distance,
+            duration: this.duration,
+            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 (json.startTime) {
+            itinerary.startTime = json.startTime;
+        }
+        if (json.endTime) {
+            itinerary.endTime = json.endTime;
+        }
+        return itinerary;
+    }
+}
+
+/* eslint-disable complexity */
+
+const SKIP_STEP_ANGLE_MAX = deg2rad(20);
+
+class StepsGeneration {
+
+    /**
+     * @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 = LevelChange.fromTwoNodes(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];
+        const lastStep = new Step();
+        lastStep.coords = lastNode.coords;
+        lastStep.number = steps.length + 1;
+        lastStep.previousBearing = previousBearing;
+        lastStep.distance = lastNode.coords.distanceTo(end);
+        if (!Coordinates.equalsTo(lastNode.coords, end)) {
+            lastStep.nextBearing = lastNode.coords.bearingTo(end);
+            lastStep.angle = diffAngle(lastStep.previousBearing, lastStep.nextBearing + Math.PI);
+        }
+        lastStep.lastStep = true;
+        steps.push(lastStep);
+
+        return steps;
+    }
+
+}
+
+/**
+ * @param {GraphItinerary<OsmElement>} graphItinerary
+ * @param {string} mode
+ * @returns {Leg}
+ */
+function createLegFromGraphItinerary(graphItinerary, mode = 'WALK') {
+
+    const leg = new Leg();
+
+    leg.from = { coords: graphItinerary.start };
+    leg.to = { coords: graphItinerary.end };
+    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 = StepsGeneration.fromGraphItinerary(graphItinerary);
+
+    return leg;
+}
+
+/**
+ * @param {GraphItinerary<OsmElement>} graphItinerary
+ * @param {string} mode
+ * @returns {Itinerary}
+ */
+function createItineraryFromGraphItinerary(graphItinerary, 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 OsmRouterUtils = /*#__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 => {
+        let levelNode = createdNodes.find(({ coords }) => Level.equalsTo(level, coords.level));
+        if (!levelNode) {
+            levelNode = new GraphNode(node.coords.clone());
+            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);
+        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 OsmNetworkUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    HIGHWAYS_PEDESTRIANS: HIGHWAYS_PEDESTRIANS,
+    DEFAULT_WAY_SELECTOR: DEFAULT_WAY_SELECTOR,
+    getNodeByName: getNodeByName,
+    getEdgeByName: getEdgeByName,
+    createNetworkFromOsmModel: createNetworkFromOsmModel
+});
+
+class RouterResponse {
+
+    /** @type {!string} */
+    routerName;
+
+    /** @type {!Coordinates} */
+    from;
+
+    /** @type {!Coordinates} */
+    to;
+
+    /** @type {!(Itinerary[])} */
+    itineraries = [];
+}
+
+/**
+ * @param {Itinerary} itinerary
+ */
+function generateStepsMetadata(itinerary) {
+
+    let counter = 1;
+
+    itinerary.legs.forEach((leg, legId) => {
+        leg.steps.forEach((step, stepId) => {
+
+            if (counter === 1) {
+                step.firstStep = true;
+            }
+            if (legId === itinerary.legs.length - 1
+                && stepId === leg.steps.length - 1) {
+                step.lastStep = true;
+            }
+
+            step.number = counter++;
+
+
+            /*
+             * Generate previousBearing, nextBearing and angle
+             */
+
+            let coordsBeforeStep;
+            if (step._idCoordsInLeg > 0) {
+                coordsBeforeStep = leg.coords[step._idCoordsInLeg - 1];
+            } else if (legId === 0) {
+                coordsBeforeStep = itinerary.from;
+            } else {
+                coordsBeforeStep = itinerary.legs[legId - 1].to.coords;
+            }
+
+            let coordsAfterStep;
+            if (step._idCoordsInLeg !== leg.coords.length - 1) {
+                coordsAfterStep = leg.coords[step._idCoordsInLeg + 1];
+            } else if (legId === itinerary.legs.length - 1) {
+                coordsAfterStep = itinerary.to;
+            } else {
+                coordsAfterStep = itinerary.legs[legId + 1].from.coords;
+            }
+
+            step.previousBearing = coordsBeforeStep.bearingTo(step.coords);
+            step.nextBearing = step.coords.bearingTo(coordsAfterStep);
+            step.angle = diffAngle(step.previousBearing, step.nextBearing + Math.PI);
+
+        });
+    });
+}
+
+/* eslint-disable max-statements */
+
+/**
+ * @param {Coordinates} coordinates
+ * @returns {object}
+ */
+function coordinatesToJson(coordinates) {
+    const output = [coordinates.lng, coordinates.lat];
+    if (coordinates.level) {
+        output.push(coordinates.level.toString());
+    }
+    return output;
+}
+
+/**
+ * @param {object} json
+ * @returns {Coordinates}
+ */
+function jsonToCoordinates$1(json) {
+    const output = new Coordinates(json[1], json[0]);
+    if (json.length > 2) {
+        output.level = Level.fromString(json[2]);
+    }
+    return output;
+}
+
+function nodesToJsonCoords(nodes) {
+    return nodes.map(node => coordinatesToJson(node.coords));
+}
+
+
+function 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';
+}
+
+
+function noRouteFoundJson(message) {
+    return {
+        'code': 'NoRoute',
+        message
+    };
+}
+
+/**
+ * @param {Itinerary} itinerary
+ * @returns {object}
+ */
+function 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(coordinatesToJson)
+                    },
+                    distance: step.distance,
+                    duration: step.duration,
+                    name: step.name,
+                    maneuver: {
+                        bearing_before: rad2deg(step.previousBearing),
+                        bearing_after: rad2deg(step.nextBearing),
+                        location: coordinatesToJson(step.coords),
+                        modifier: getModifierFromAngle(step.angle),
+                        type
+                    }
+                };
+                if (step.levelChange !== null) {
+                    jsonStep.levelChange = step.levelChange;
+                }
+                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(coordinatesToJson)
+                },
+                'legs': jsonLegs,
+                'distance': itinerary.distance,
+                'duration': itinerary.duration,
+                'weight_name': 'routability',
+                'weight': 0
+            }
+        ],
+        'waypoints': []
+    };
+}
+
+
+/**
+ * @param {object} jsonSteps
+ * @param {Coordinates[]} legCoords
+ * @returns {Step[]}
+ */
+function parseJsonSteps$1(jsonSteps, legCoords) {
+
+    if (!jsonSteps) {
+        return [];
+    }
+
+    return jsonSteps.map(jsonStep => {
+
+        const step = new Step();
+        step.coords = jsonToCoordinates$1(jsonStep.maneuver.location);
+
+        const idStepCoordsInLeg = legCoords.findIndex(coords => step.coords.equalsTo(coords));
+        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 ? jsonStep.levelChange : null;
+
+        step.distance = jsonStep.distance;
+        step.duration = jsonStep.duration;
+
+        if (step.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}
+ */
+function createRouterResponseFromJson$1(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 = 'osrm';
+
+    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(jsonToCoordinates$1))
+                .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 = parseJsonSteps$1(jsonLeg.steps, leg.coords);
+
+            itinerary.legs.push(leg);
+        }
+
+        // All legs have to be parsed before computing steps metadata
+        generateStepsMetadata(itinerary);
+
+    }
+
+    return routerResponse;
+}
+
+var OsrmUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    coordinatesToJson: coordinatesToJson,
+    jsonToCoordinates: jsonToCoordinates$1,
+    nodesToJsonCoords: nodesToJsonCoords,
+    getModifierFromAngle: getModifierFromAngle,
+    noRouteFoundJson: noRouteFoundJson,
+    itineraryToOsrmJson: itineraryToOsrmJson,
+    createRouterResponseFromJson: createRouterResponseFromJson$1
+});
+
+/* eslint-disable max-statements */
+
+/**
+ * @param {object} json
+ * @returns {Coordinates}
+ */
+function jsonToCoordinates(json) {
+    return new Coordinates(json.lat, json.lon);
+}
+
+/**
+ * @param {object} jsonSteps
+ * @param {Coordinates[]} legCoords
+ * @returns {Step[]}
+ */
+function parseJsonSteps(jsonSteps, legCoords) {
+
+    if (!jsonSteps) {
+        return [];
+    }
+
+    return jsonSteps.map(jsonStep => {
+
+        const step = new Step();
+        const stepCoords = 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}
+ */
+function createRouterResponseFromJson(json) {
+
+    const { plan: jsonPlan } = json;
+
+    if (!jsonPlan) {
+        return null;
+    }
+
+    const routerResponse = new RouterResponse();
+    routerResponse.routerName = 'otp';
+
+    routerResponse.from = jsonToCoordinates(jsonPlan.from);
+    routerResponse.to = 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: jsonToCoordinates(jsonLeg.from)
+            };
+            leg.to = {
+                name: jsonLeg.to.name,
+                coords: jsonToCoordinates(jsonLeg.to)
+            };
+            leg.coords = Polyline.decode(jsonLeg.legGeometry.points).map(([lat, lon]) => new Coordinates(lat, lon));
+
+            leg.steps = 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 OtpUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    jsonToCoordinates: jsonToCoordinates,
+    createRouterResponseFromJson: createRouterResponseFromJson
+});
+
+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;
+
+}
+
+/* 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) {
+
+        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 (!(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 { Itinerary, ItineraryInfo, ItineraryInfoManager, Leg, LevelChange, OsmElement, OsmModel, OsmNetworkUtils, OsmNode, OsmParser, OsmRouter, OsmRouterOptions, OsmRouterUtils, OsmWay, OsrmUtils, OtpUtils, RouterResponse, Step };
+//# sourceMappingURL=wemap-osm.es.js.map