@wemap/osm 6.0.0 → 6.2.2

package/dist/wemap-osm.es.js

@@ -1,8 +1,5 @@
-import { Level, Coordinates, GraphRouterOptions, GraphRouter, GraphUtils, Network, GraphEdge, GraphNode, MapMatching } from '@wemap/geo';
+import { Level, Coordinates } from '@wemap/geo';
 import { SaxesParser } from 'saxes';
-import { deg2rad, diffAngle, positiveMod, rad2deg } from '@wemap/maths';
-import Polyline from '@mapbox/polyline';
-import Logger from '@wemap/logger';
 
 class OsmElement {
 
@@ -253,1760 +250,5 @@ class OsmParser {
     }
 }
 
-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 && 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 (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, FUNICULAR */
-    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, 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 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$2(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.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(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$2(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}
- */
-function createRouterResponseFromJson$2(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$2))
-                .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$2,
-    nodesToJsonCoords: nodesToJsonCoords,
-    getModifierFromAngle: getModifierFromAngle,
-    noRouteFoundJson: noRouteFoundJson,
-    itineraryToOsrmJson: itineraryToOsrmJson,
-    createRouterResponseFromJson: createRouterResponseFromJson$2
-});
-
-/* eslint-disable max-statements */
-
-/**
- * @param {object} json
- * @returns {Coordinates}
- */
-function jsonToCoordinates$1(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$1(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$1(json) {
-
-    const { plan: jsonPlan } = json;
-
-    if (!jsonPlan) {
-        return null;
-    }
-
-    const routerResponse = new RouterResponse();
-    routerResponse.routerName = 'otp';
-
-    routerResponse.from = jsonToCoordinates$1(jsonPlan.from);
-    routerResponse.to = jsonToCoordinates$1(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$1(jsonLeg.from)
-            };
-            leg.to = {
-                name: jsonLeg.to.name,
-                coords: jsonToCoordinates$1(jsonLeg.to)
-            };
-            leg.coords = Polyline.decode(jsonLeg.legGeometry.points).map(([lat, lon]) => new Coordinates(lat, lon));
-
-            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$1,
-    createRouterResponseFromJson: createRouterResponseFromJson$1
-});
-
-/* eslint-disable max-depth */
-
-/**
- * @param {object} json
- * @returns {Coordinates}
- */
-function jsonToCoordinates(json) {
-    return new Coordinates(json.Lat, json.Long);
-}
-
-/**
- * @param {string} jsonDate
- * @returns {number}
- */
-function jsonDateToTimestamp(jsonDate) {
-    const [dateStr, timeStr] = jsonDate.split(' ');
-    const [dayStr, monthStr, yearStr] = dateStr.split('/');
-    const [hoursStr, minutesStr, secondsStr] = timeStr.split(':');
-    const date = new Date(
-        Number(yearStr), Number(monthStr) - 1, Number(dayStr),
-        Number(hoursStr), Number(minutesStr), Number(secondsStr)
-    );
-    return date.getTime();
-}
-
-/**
- * @param {string} wktGeometry
- * @returns {Coordinates[]}
- */
-function parseWKTGeometry(wktGeometry) {
-    const tmpCoordsStr = wktGeometry.match(/LINESTRING \((.*)\)/i);
-    if (!tmpCoordsStr) {
-        return null;
-    }
-    return tmpCoordsStr[1].split(',').map(str => {
-        const sp = str.trim().split(' ');
-        return new Coordinates(Number(sp[1]), Number(sp[0]));
-    });
-}
-
-/**
- * @param {string} iso8601Duration
- * @see https://stackoverflow.com/a/29153059/2239938
- */
-function parseDuration(iso8601Duration) {
-    const iso8601DurationRegex = /(-)?P(?:([.,\d]+)Y)?(?:([.,\d]+)M)?(?:([.,\d]+)W)?(?:([.,\d]+)D)?T(?:([.,\d]+)H)?(?:([.,\d]+)M)?(?:([.,\d]+)S)?/;
-
-    var matches = iso8601Duration.match(iso8601DurationRegex);
-
-    // const sign = typeof matches[1] === 'undefined' ? '+' : '-',
-    const years = typeof matches[2] === 'undefined' ? 0 : Number(matches[2]);
-    const months = typeof matches[3] === 'undefined' ? 0 : Number(matches[3]);
-    const weeks = typeof matches[4] === 'undefined' ? 0 : Number(matches[4]);
-    const days = typeof matches[5] === 'undefined' ? 0 : Number(matches[5]);
-    const hours = typeof matches[6] === 'undefined' ? 0 : Number(matches[6]);
-    const minutes = typeof matches[7] === 'undefined' ? 0 : Number(matches[7]);
-    const seconds = typeof matches[8] === 'undefined' ? 0 : Number(matches[8]);
-
-    return seconds
-        + minutes * 60
-        + hours * 3600
-        + days * 86400
-        + weeks * (86400 * 7)
-        + months * (86400 * 30)
-        + years * (86400 * 365.25);
-}
-
-/**
- * Generate multi itineraries from Cityway JSON
- * @param {object} json JSON file provided by Cityway.
- * @returns {?RouterResponse}
- * @example https://preprod.api.lia2.cityway.fr/journeyplanner/api/opt/PlanTrips/json?DepartureLatitude=49.51509388236216&DepartureLongitude=0.09341749619366316&ArrivalLatitude=49.5067090188444&ArrivalLongitude=0.1694842115417831&DepartureType=COORDINATES&ArrivalType=COORDINATES
- */
-function createRouterResponseFromJson(json) {
-
-    if (json.StatusCode !== 200 || !json.Data || !json.Data.length) {
-        return null;
-    }
-
-    const routerResponse = new RouterResponse();
-    routerResponse.routerName = 'cityway';
-
-
-    // Do not know if it the best approach, but it works...
-    const allJsonTrips = json.Data.reduce((acc, dataObj) => {
-        acc.push(...dataObj.response.trips.Trip);
-        return acc;
-    }, []);
-
-    for (const trip of allJsonTrips) {
-
-        const itinerary = new Itinerary();
-
-        itinerary.duration = parseDuration(trip.Duration);
-        itinerary.startTime = jsonDateToTimestamp(trip.Departure.Time);
-        itinerary.from = jsonToCoordinates(trip.Departure.Site.Position);
-        itinerary.endTime = jsonDateToTimestamp(trip.Arrival.Time);
-        itinerary.to = jsonToCoordinates(trip.Arrival.Site.Position);
-        routerResponse.itineraries.push(itinerary);
-
-        for (const jsonSection of trip.sections.Section) {
-
-            const jsonLeg = jsonSection.Leg ? jsonSection.Leg : jsonSection.PTRide;
-
-            const leg = new Leg();
-
-            leg.mode = jsonLeg.TransportMode;
-            leg.duration = parseDuration(jsonLeg.Duration);
-            leg.startTime = jsonDateToTimestamp(jsonLeg.Departure.Time);
-            leg.endTime = jsonDateToTimestamp(jsonLeg.Arrival.Time);
-            leg.coords = [];
-
-            if (leg.mode === 'WALK' || leg.mode === 'BICYCLE') {
-
-                leg.from = {
-                    name: jsonLeg.Departure.Site.Name,
-                    coords: jsonToCoordinates(jsonLeg.Departure.Site.Position)
-                };
-                leg.to = {
-                    name: jsonLeg.Arrival.Site.Name,
-                    coords: jsonToCoordinates(jsonLeg.Arrival.Site.Position)
-                };
-
-                leg.steps = [];
-                for (const jsonPathLink of jsonLeg.pathLinks.PathLink) {
-                    const step = new Step();
-                    let stepCoords;
-                    if (jsonPathLink.Geometry) {
-                        stepCoords = parseWKTGeometry(jsonPathLink.Geometry);
-                    } else {
-                        stepCoords = [leg.from.coords, leg.to.coords];
-                    }
-                    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 (leg.mode === 'BUS' || leg.mode === 'TRAMWAY' || leg.mode === 'FUNICULAR') {
-
-                leg.from = {
-                    name: jsonLeg.Departure.StopPlace.Name,
-                    coords: jsonToCoordinates(jsonLeg.Departure.StopPlace.Position)
-                };
-                leg.to = {
-                    name: jsonLeg.Arrival.StopPlace.Name,
-                    coords: jsonToCoordinates(jsonLeg.Arrival.StopPlace.Position)
-                };
-
-                let transportName = jsonLeg.Line.Number;
-                if (leg.mode === 'TRAMWAY') {
-                    leg.mode = '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 = 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: ${leg.mode}`);
-            }
-
-            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);
-    }
-
-    routerResponse.from = routerResponse.itineraries[0].from;
-    routerResponse.to = routerResponse.itineraries[routerResponse.itineraries.length - 1].to;
-
-    return routerResponse;
-}
-
-var CitywayUtils = /*#__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) {
-
-        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 { CitywayUtils, Itinerary, ItineraryInfo, ItineraryInfoManager, Leg, LevelChange, OsmElement, OsmModel, OsmNetworkUtils, OsmNode, OsmParser, OsmRouter, OsmRouterOptions, OsmRouterUtils, OsmWay, OsrmUtils, OtpUtils, RouterResponse, Step };
+export { OsmElement, OsmModel, OsmNode, OsmParser, OsmWay };
 //# sourceMappingURL=wemap-osm.es.js.map