@wemap/routers 10.11.0 → 10.11.2

package/dist/index.js

@@ -0,0 +1,1990 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const geo = require("@wemap/geo");
+const maths = require("@wemap/maths");
+const osm = require("@wemap/osm");
+const Logger = require("@wemap/logger");
+const Polyline = require("@mapbox/polyline");
+const pointInPolygon = require("@turf/boolean-point-in-polygon");
+const convexHullFn = require("@turf/convex");
+const helpers = require("@turf/helpers");
+const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
+const Logger__default = /* @__PURE__ */ _interopDefaultLegacy(Logger);
+const Polyline__default = /* @__PURE__ */ _interopDefaultLegacy(Polyline);
+const pointInPolygon__default = /* @__PURE__ */ _interopDefaultLegacy(pointInPolygon);
+const convexHullFn__default = /* @__PURE__ */ _interopDefaultLegacy(convexHullFn);
+function getDurationFromLength(length, speed = 5) {
+  return length / (speed * 1e3 / 3600);
+}
+function areLevelChangeEquals(l1, l2) {
+  return l1 === l2 || l1.difference === l2.difference && l1.direction === l2.direction && l1.type === l2.type;
+}
+class StepInfo {
+  constructor({
+    coords,
+    distance,
+    name,
+    levelChange,
+    extras,
+    duration
+  }) {
+    __publicField(this, "coords");
+    __publicField(this, "name");
+    __publicField(this, "distance");
+    __publicField(this, "duration");
+    __publicField(this, "levelChange");
+    __publicField(this, "extras");
+    this.coords = coords;
+    this.name = name || null;
+    this.distance = typeof distance === "number" ? distance : null;
+    this.duration = typeof duration === "number" ? duration : null;
+    this.levelChange = levelChange || null;
+    this.extras = extras || null;
+  }
+  static equals(obj1, obj2) {
+    return obj1.coords.equals(obj2.coords) && obj1.distance === obj2.distance && obj1.duration === obj2.duration && obj1.name === obj2.name && (obj1.levelChange === obj2.levelChange || obj1.levelChange && obj2.levelChange && areLevelChangeEquals(obj1.levelChange, obj2.levelChange));
+  }
+  equals(obj) {
+    return StepInfo.equals(this, obj);
+  }
+  toJson() {
+    return {
+      coords: this.coords.toCompressedJson(),
+      ...this.distance !== null && { distance: this.distance },
+      ...this.duration !== null && { duration: this.duration },
+      ...this.name !== null && { name: this.name },
+      ...this.levelChange !== null && { levelChange: this.levelChange },
+      ...this.extras && Object.keys(this.extras).length !== 0 && { extras: this.extras }
+    };
+  }
+  static fromJson(json) {
+    return new StepInfo(Object.assign({}, json, {
+      coords: geo.Coordinates.fromCompressedJson(json.coords)
+    }));
+  }
+}
+const SKIP_STEP_ANGLE_MAX = maths.deg2rad(20);
+function generateSteps(leg, rules) {
+  const steps = [];
+  const { from, to, coords: coordsArray } = leg;
+  let currentStep = null;
+  let previousBearing = from.coords.bearingTo(coordsArray[0]);
+  for (let i = 0; i < coordsArray.length - 1; i++) {
+    const isFirstStep = i === 0;
+    const currentCoords = coordsArray[i];
+    const nextCoords = coordsArray[i + 1];
+    const edgeLevel = geo.Level.union(currentCoords.level, nextCoords.level);
+    const nextBearing = currentCoords.bearingTo(nextCoords);
+    const angle = maths.diffAngle(previousBearing, nextBearing + Math.PI);
+    let splitByAngle = Math.abs(maths.diffAngle(Math.PI, angle)) >= SKIP_STEP_ANGLE_MAX;
+    const splitByLevel = geo.Level.isRange(edgeLevel) && !geo.Level.isRange(currentCoords.level);
+    splitByAngle = splitByAngle && !(currentCoords.level && geo.Level.isRange(currentCoords.level));
+    const customRules = rules == null ? void 0 : rules(currentCoords, nextCoords);
+    const splitStepCondition = splitByAngle || splitByLevel || (customRules == null ? void 0 : customRules.createNewStep);
+    if (isFirstStep || splitStepCondition) {
+      let levelChange;
+      if (splitByLevel) {
+        const difference = geo.Level.diff(currentCoords.level, nextCoords.level);
+        const direction = difference > 0 ? "up" : "down";
+        levelChange = { difference, direction, type: customRules == null ? void 0 : customRules.levelChangeType };
+      }
+      if (currentStep && currentStep.duration === 0) {
+        currentStep.duration = null;
+      }
+      currentStep = new StepInfo({
+        coords: currentCoords,
+        name: customRules == null ? void 0 : customRules.stepName,
+        extras: customRules == null ? void 0 : customRules.stepExtras,
+        levelChange,
+        distance: 0,
+        duration: 0
+      });
+      steps.push(currentStep);
+    }
+    currentStep.distance += currentCoords.distanceTo(nextCoords);
+    if (customRules == null ? void 0 : customRules.duration) {
+      currentStep.duration += customRules == null ? void 0 : customRules.duration;
+    }
+    previousBearing = nextBearing;
+  }
+  const lastCoords = coordsArray[coordsArray.length - 1];
+  if (!geo.Coordinates.equals(lastCoords, to.coords)) {
+    steps.push(new StepInfo({ coords: lastCoords }));
+  }
+  return steps;
+}
+function isRoutingModePublicTransport(routingMode) {
+  return [
+    "AIRPLANE",
+    "BOAT",
+    "BUS",
+    "FERRY",
+    "FUNICULAR",
+    "METRO",
+    "TRAIN",
+    "TRAM"
+  ].includes(routingMode);
+}
+class Leg {
+  constructor({
+    from,
+    to,
+    coords,
+    mode,
+    duration,
+    startTime,
+    endTime,
+    transportInfo,
+    ...otherParams
+  }) {
+    __publicField(this, "from");
+    __publicField(this, "to");
+    __publicField(this, "coords");
+    __publicField(this, "distance");
+    __publicField(this, "mode");
+    __publicField(this, "duration");
+    __publicField(this, "startTime");
+    __publicField(this, "endTime");
+    __publicField(this, "stepsInfo");
+    __publicField(this, "transportInfo");
+    this.from = {
+      name: from.name || null,
+      coords: from.coords
+    };
+    this.to = {
+      name: to.name || null,
+      coords: to.coords
+    };
+    this.coords = coords;
+    this.mode = mode;
+    this.distance = geo.Utils.calcDistance(coords);
+    this.duration = typeof duration === "number" ? duration : getDurationFromLength(this.distance);
+    this.startTime = typeof startTime === "number" ? startTime : null;
+    this.endTime = typeof endTime === "number" ? endTime : null;
+    this.transportInfo = transportInfo || null;
+    this.stepsInfo = "stepsInfo" in otherParams ? otherParams.stepsInfo : generateSteps(this, otherParams.stepsGenerationRules);
+  }
+  isPublicTransport() {
+    return isRoutingModePublicTransport(this.mode);
+  }
+  toNetwork() {
+    return geo.Network.fromCoordinates([this.coords]);
+  }
+  static equals(obj1, obj2) {
+    var _a, _b;
+    const intermediate = obj1.mode === obj2.mode && obj1.duration === obj2.duration && obj1.startTime === obj2.startTime && obj1.endTime === obj2.endTime && obj1.from.name === obj2.from.name && obj1.from.coords.equals(obj2.from.coords) && obj1.to.name === obj2.to.name && obj1.to.coords.equals(obj2.to.coords) && obj1.coords.length === obj2.coords.length && (obj1.stepsInfo === obj2.stepsInfo || ((_a = obj1.stepsInfo) == null ? void 0 : _a.length) === ((_b = obj2.stepsInfo) == null ? void 0 : _b.length));
+    if (!intermediate) {
+      return false;
+    }
+    let i;
+    for (i = 0; i < obj1.coords.length; i++) {
+      if (!obj1.coords[i].equals(obj2.coords[i])) {
+        return false;
+      }
+    }
+    if (obj1.stepsInfo && obj2.stepsInfo) {
+      for (i = 0; i < obj1.stepsInfo.length; i++) {
+        if (!obj1.stepsInfo[i].equals(obj2.stepsInfo[i])) {
+          return false;
+        }
+      }
+    }
+    if (obj1.transportInfo !== obj2.transportInfo) {
+      if (obj1.transportInfo === null || obj2.transportInfo === null) {
+        return false;
+      }
+      if (obj1.transportInfo.name !== obj2.transportInfo.name || obj1.transportInfo.routeColor !== obj2.transportInfo.routeColor || obj1.transportInfo.routeTextColor !== obj2.transportInfo.routeTextColor || obj1.transportInfo.directionName !== obj2.transportInfo.directionName) {
+        return false;
+      }
+    }
+    return true;
+  }
+  equals(obj) {
+    return Leg.equals(this, obj);
+  }
+  toJson() {
+    return {
+      mode: this.mode,
+      from: {
+        coords: this.from.coords.toCompressedJson(),
+        ...this.from.name && { name: this.from.name }
+      },
+      to: {
+        coords: this.to.coords.toCompressedJson(),
+        ...this.to.name && { name: this.to.name }
+      },
+      duration: this.duration,
+      coords: this.coords.map((coords) => coords.toCompressedJson()),
+      steps: this.stepsInfo.map((stepInfo) => stepInfo.toJson()),
+      ...this.startTime !== null && { startTime: this.startTime },
+      ...this.endTime !== null && { endTime: this.endTime },
+      ...this.transportInfo !== null && { transportInfo: this.transportInfo }
+    };
+  }
+  static fromJson(json) {
+    var _a;
+    const leg = new Leg(Object.assign({}, json, {
+      from: {
+        coords: geo.Coordinates.fromCompressedJson(json.from.coords),
+        name: json.from.name || null
+      },
+      to: {
+        coords: geo.Coordinates.fromCompressedJson(json.to.coords),
+        name: json.to.name || null
+      },
+      coords: json.coords.map(geo.Coordinates.fromCompressedJson),
+      stepsInfo: ((_a = json.steps) == null ? void 0 : _a.map(StepInfo.fromJson)) || null,
+      stepsGenerationRules: void 0
+    }));
+    return leg;
+  }
+  static fromGraphItinerary(graphItinerary, mode = "WALK", stepsGenerationRules) {
+    return new Leg({
+      from: { coords: graphItinerary.start },
+      to: { coords: graphItinerary.end },
+      coords: graphItinerary.nodes.map((node) => node.coords),
+      duration: graphItinerary.edgesWeights.reduce((acc, weight) => acc + weight, 0),
+      mode,
+      stepsGenerationRules
+    });
+  }
+  multiplyLevel(levelFactor) {
+    this.from.coords.level = geo.Level.multiplyBy(this.from.coords.level, levelFactor);
+    this.to.coords.level = geo.Level.multiplyBy(this.to.coords.level, levelFactor);
+    for (const coords of this.coords) {
+      coords.level = geo.Level.multiplyBy(coords.level, levelFactor);
+    }
+    this.stepsInfo.forEach((step) => {
+      step.coords.level = geo.Level.multiplyBy(step.coords.level, levelFactor);
+    });
+  }
+  getSteps(itinerarySteps) {
+    return this.stepsInfo.map((stepInfo) => itinerarySteps.find((_step) => _step.coords.equals(stepInfo.coords)));
+  }
+}
+class Itinerary {
+  constructor({
+    from,
+    to,
+    duration,
+    legs,
+    startTime,
+    endTime
+  }) {
+    __publicField(this, "from");
+    __publicField(this, "to");
+    __publicField(this, "duration");
+    __publicField(this, "legs");
+    __publicField(this, "_mode", null);
+    __publicField(this, "startTime");
+    __publicField(this, "endTime");
+    __publicField(this, "_coords", null);
+    __publicField(this, "_steps", null);
+    __publicField(this, "_distance", null);
+    this.from = from;
+    this.to = to;
+    this.legs = legs;
+    this.duration = typeof duration === "number" ? duration : this.legs.reduce((dur, leg) => dur + leg.duration, 0);
+    this.startTime = typeof startTime === "number" ? startTime : null;
+    this.endTime = typeof endTime === "number" ? endTime : null;
+  }
+  set coords(_) {
+    throw new Error("Itinerary.coords cannot be set. They are calculated from Itinerary.legs.");
+  }
+  get coords() {
+    if (!this._coords) {
+      this._coords = this.legs.map((leg) => leg.coords).flat().filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equals(coords));
+    }
+    return this._coords;
+  }
+  set steps(_) {
+    throw new Error("Itinerary.step cannot be set. They are calculated from Itinerary.legs.");
+  }
+  get steps() {
+    if (this._steps) {
+      return this._steps;
+    }
+    const itineraryCoords = this.coords.filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equals(coords));
+    const stepsInfo = this.legs.map((leg) => leg.stepsInfo).flat();
+    const steps = stepsInfo.map((stepInfo, stepId) => {
+      const coordsId = itineraryCoords.findIndex((coords) => coords.equals(stepInfo.coords));
+      if (coordsId === -1) {
+        throw new Error("Cannot find step coordinates in itinerary coordinates.");
+      }
+      const coordsBeforeStep = coordsId === 0 ? this.from : itineraryCoords[coordsId - 1];
+      const coordsAfterStep = coordsId === itineraryCoords.length - 1 ? this.to : itineraryCoords[coordsId + 1];
+      const previousBearing = coordsBeforeStep.bearingTo(stepInfo.coords);
+      const nextBearing = stepInfo.coords.bearingTo(coordsAfterStep);
+      let distance = 0;
+      const coordsToStopCalculation = stepId !== stepsInfo.length - 1 ? stepsInfo[stepId + 1].coords : itineraryCoords[itineraryCoords.length - 1];
+      let currentCoordsId = coordsId;
+      while (!itineraryCoords[currentCoordsId].equals(coordsToStopCalculation)) {
+        distance += itineraryCoords[currentCoordsId].distanceTo(itineraryCoords[currentCoordsId + 1]);
+        currentCoordsId++;
+      }
+      if (currentCoordsId === itineraryCoords.length - 1) {
+        distance += itineraryCoords[currentCoordsId].distanceTo(this.to);
+      }
+      return {
+        ...stepInfo,
+        number: stepId + 1,
+        previousBearing,
+        nextBearing,
+        angle: maths.diffAngle(previousBearing, nextBearing + Math.PI),
+        firstStep: stepId === 0,
+        lastStep: stepId === stepsInfo.length - 1,
+        distance,
+        duration: stepInfo.duration || getDurationFromLength(distance),
+        previousStep: null,
+        nextStep: null
+      };
+    });
+    return steps;
+  }
+  set mode(_) {
+    throw new Error("Itinerary.mode cannot be set. They are calculated from Itinerary.legs.");
+  }
+  get mode() {
+    if (!this._mode) {
+      let isPublicTransport = false;
+      let isBicycle = false;
+      let isDriving = false;
+      this.legs.forEach((leg) => {
+        isPublicTransport = isPublicTransport || isRoutingModePublicTransport(leg.mode);
+        isBicycle = isBicycle || leg.mode === "BIKE";
+        isDriving = isDriving || leg.mode === "CAR";
+      });
+      if (isPublicTransport) {
+        this._mode = "PT";
+      } else if (isDriving) {
+        this._mode = "CAR";
+      } else if (isBicycle) {
+        this._mode = "BIKE";
+      } else {
+        this._mode = "WALK";
+      }
+    }
+    return this._mode;
+  }
+  set distance(_) {
+    throw new Error("Itinerary.distance cannot be set. They are calculated from Itinerary.legs.");
+  }
+  get distance() {
+    if (this._distance === null) {
+      this._distance = geo.Utils.calcDistance(this.coords);
+    }
+    return this._distance;
+  }
+  toNetwork() {
+    return geo.Network.fromCoordinates([this.coords]);
+  }
+  static fromItineraries(...itineraries) {
+    let duration = 0;
+    const legs = [];
+    itineraries.forEach((_itinerary) => {
+      duration += _itinerary.duration;
+      legs.push(..._itinerary.legs);
+    });
+    return new Itinerary({
+      from: itineraries[0].from,
+      to: itineraries[itineraries.length - 1].to,
+      duration,
+      legs
+    });
+  }
+  static fromOrderedPointsArray(points, start, end) {
+    const pointToCoordinates = (point) => new geo.Coordinates(point[0], point[1], null, point[2]);
+    return this.fromOrderedCoordinates(
+      points.map(pointToCoordinates),
+      pointToCoordinates(start),
+      pointToCoordinates(end)
+    );
+  }
+  static fromOrderedCoordinates(coords, from, to, mode = "WALK") {
+    const leg = new Leg({
+      from: { coords: from },
+      to: { coords: to },
+      coords,
+      mode
+    });
+    return new Itinerary({ from, to, legs: [leg] });
+  }
+  static equals(obj1, obj2) {
+    const intermediate = obj1.from.equals(obj2.from) && obj1.to.equals(obj2.to) && obj1.distance === obj2.distance && obj1.duration === obj2.duration && obj1.startTime === obj2.startTime && obj1.endTime === obj2.endTime && obj1.legs.length === obj2.legs.length;
+    if (!intermediate) {
+      return false;
+    }
+    for (let i = 0; i < obj1.legs.length; i++) {
+      if (!obj1.legs[i].equals(obj2.legs[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  equals(obj) {
+    return Itinerary.equals(this, obj);
+  }
+  toJson() {
+    return {
+      from: this.from.toCompressedJson(),
+      to: this.to.toCompressedJson(),
+      duration: this.duration,
+      mode: this.mode,
+      legs: this.legs.map((leg) => leg.toJson()),
+      ...this.startTime !== null && { startTime: this.startTime },
+      ...this.endTime !== null && { endTime: this.endTime }
+    };
+  }
+  static fromJson(json) {
+    return new Itinerary({
+      from: geo.Coordinates.fromCompressedJson(json.from),
+      to: geo.Coordinates.fromCompressedJson(json.to),
+      duration: json.duration,
+      legs: json.legs.map(Leg.fromJson),
+      startTime: json.startTime,
+      endTime: json.endTime
+    });
+  }
+  static fromGraphItinerary(graphItinerary, mode = "WALK", stepsGenerationRules) {
+    const leg = Leg.fromGraphItinerary(graphItinerary, mode, stepsGenerationRules);
+    return new Itinerary({
+      from: graphItinerary.start,
+      to: graphItinerary.end,
+      duration: leg.duration,
+      legs: [leg]
+    });
+  }
+  multiplyLevel(levelFactor) {
+    this.from.level = geo.Level.multiplyBy(this.from.level, levelFactor);
+    this.to.level = geo.Level.multiplyBy(this.to.level, levelFactor);
+    this.legs.forEach((leg) => leg.multiplyLevel(levelFactor));
+  }
+  forceUnknownLevelTo0() {
+    this.from.level = this.from.level || 0;
+    this.to.level = this.to.level || 0;
+    for (const leg of this.legs) {
+      leg.from.coords.level = leg.from.coords.level || 0;
+      leg.to.coords.level = leg.to.coords.level || 0;
+      for (const coords of leg.coords) {
+        coords.level = coords.level || 0;
+      }
+      if (leg.stepsInfo) {
+        for (const step of leg.stepsInfo) {
+          step.coords.level = step.coords.level || 0;
+        }
+      }
+    }
+    if (this._coords) {
+      for (const coords of this._coords) {
+        coords.level = coords.level || 0;
+      }
+    }
+  }
+  toGeoJson() {
+    return {
+      type: "Feature",
+      properties: {},
+      geometry: {
+        type: "MultiLineString",
+        coordinates: this.legs.map((leg) => leg.coords.map(({ lat, lng }) => [lng, lat]))
+      }
+    };
+  }
+}
+class RouterResponse {
+  constructor({
+    routerName,
+    from,
+    to,
+    itineraries,
+    error
+  }) {
+    __publicField(this, "routerName");
+    __publicField(this, "from");
+    __publicField(this, "to");
+    __publicField(this, "itineraries");
+    __publicField(this, "error");
+    this.routerName = routerName;
+    this.from = from;
+    this.to = to;
+    this.itineraries = itineraries || [];
+    this.error = error || null;
+  }
+  static equals(obj1, obj2) {
+    const intermediate = obj1.routerName === obj2.routerName && obj1.from.equals(obj2.from) && obj1.to.equals(obj2.to) && obj1.itineraries.length === obj2.itineraries.length;
+    if (!intermediate) {
+      return false;
+    }
+    for (let i = 0; i < obj1.itineraries.length; i++) {
+      if (!obj1.itineraries[i].equals(obj2.itineraries[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  equals(obj) {
+    return RouterResponse.equals(this, obj);
+  }
+  toJson() {
+    return {
+      routerName: this.routerName,
+      from: this.from.toCompressedJson(),
+      to: this.to.toCompressedJson(),
+      ...this.itineraries.length && { itineraries: this.itineraries.map((itinerary) => itinerary.toJson()) },
+      ...this.error && { error: this.error }
+    };
+  }
+  static fromJson(json) {
+    var _a;
+    return new RouterResponse({
+      routerName: json.routerName,
+      from: geo.Coordinates.fromCompressedJson(json.from),
+      to: geo.Coordinates.fromCompressedJson(json.to),
+      itineraries: (_a = json.itineraries) == null ? void 0 : _a.map(Itinerary.fromJson),
+      error: json.error
+    });
+  }
+  multiplyLevel(levelFactor) {
+    this.from.level = geo.Level.multiplyBy(this.from.level, levelFactor);
+    this.to.level = geo.Level.multiplyBy(this.to.level, levelFactor);
+    for (const itinerary of this.itineraries) {
+      itinerary.multiplyLevel(levelFactor);
+    }
+  }
+}
+const _WemapOsmRouterOptions = class extends osm.OsmGraphRouterOptions {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "weightEdgeFn", (edge) => edge.builtFrom instanceof osm.OsmNode && edge.builtFrom.isElevator ? 30 : getDurationFromLength(edge.length));
+  }
+  static get WITHOUT_STAIRS() {
+    const options = new _WemapOsmRouterOptions();
+    options.acceptEdgeFn = (edge) => {
+      var _a;
+      return ((_a = edge.builtFrom) == null ? void 0 : _a.tags.highway) !== "steps";
+    };
+    return options;
+  }
+};
+let WemapOsmRouterOptions = _WemapOsmRouterOptions;
+__publicField(WemapOsmRouterOptions, "DEFAULT", new _WemapOsmRouterOptions());
+const buildStepsRules = (graphItinerary) => (currentCoords, nextCoords) => {
+  var _a, _b, _c, _d, _e;
+  const edges = graphItinerary.edges;
+  const nodes = graphItinerary.nodes;
+  const node = geo.GraphUtils.getNodeByCoords(nodes, currentCoords);
+  const nextNode = geo.GraphUtils.getNodeByCoords(nodes, nextCoords);
+  if (!node || !nextNode)
+    return {};
+  const edge = geo.GraphUtils.getEdgeByNodes(edges, node, nextNode);
+  if (!edge)
+    return {};
+  const edgeId = edges.findIndex((_edge) => _edge === edge);
+  const isSubwayEntrance = node ? ((_a = node.builtFrom) == null ? void 0 : _a.tags.railway) === "subway_entrance" : false;
+  const isGate = node ? ((_b = node.builtFrom) == null ? void 0 : _b.tags.barrier) === "gate" || ((_c = node.builtFrom) == null ? void 0 : _c.tags.aeroway) === "gate" : false;
+  let levelChangeType = null;
+  if (edge.builtFrom instanceof osm.OsmNode && edge.builtFrom.isElevator) {
+    levelChangeType = "elevator";
+  } else if (edge.builtFrom instanceof osm.OsmNode || edge.builtFrom instanceof osm.OsmWay && edge.builtFrom.isConveying) {
+    levelChangeType = "conveyor";
+  } else if (edge.builtFrom instanceof osm.OsmWay && edge.builtFrom.areStairs) {
+    levelChangeType = "stairs";
+  }
+  return {
+    createNewStep: isSubwayEntrance,
+    stepName: (_d = edge.builtFrom) == null ? void 0 : _d.tags.name,
+    duration: graphItinerary.edgesWeights[edgeId],
+    stepExtras: {
+      ...isSubwayEntrance && { isSubwayEntrance: true },
+      ...isSubwayEntrance && ((_e = node.builtFrom) == null ? void 0 : _e.tags.ref) && { subwayEntranceRef: node.builtFrom.tags.ref },
+      ...isGate && { isGate: true }
+    },
+    ...levelChangeType && { levelChangeType }
+  };
+};
+class WemapOsmRouter extends osm.OsmGraphRouter {
+  constructor(network) {
+    super(network);
+  }
+  static get rname() {
+    return "wemap";
+  }
+  getShortestPath(start, end, options = new WemapOsmRouterOptions()) {
+    return super.getShortestPath(start, end, options);
+  }
+  getItinerary(start, end, options = new WemapOsmRouterOptions()) {
+    const graphItinerary = this.getShortestPath(start, end, options);
+    return Itinerary.fromGraphItinerary(graphItinerary, "WALK", buildStepsRules(graphItinerary));
+  }
+}
+class RemoteRouter {
+}
+class RemoteRouterServerUnreachable extends Error {
+  constructor(name, endpointUrl) {
+    super(`Remote router server ${name} is unreachable. URL: ${endpointUrl}`);
+  }
+}
+class RoutingModeCorrespondanceNotFound extends Error {
+  constructor(routerName, routingMode) {
+    super(`routing mode "${routingMode}" correspondance not found for router "${routerName}"`);
+    this.routerName = routerName;
+    this.routingMode = routingMode;
+  }
+}
+function dateWithTimeZone(year, month, day, hour, minute, second, timeZone = "Europe/Paris") {
+  const date = new Date(Date.UTC(year, month, day, hour, minute, second));
+  const utcDate = new Date(date.toLocaleString("en-US", { timeZone: "UTC" }));
+  const tzDate = new Date(date.toLocaleString("en-US", { timeZone }));
+  const offset = utcDate.getTime() - tzDate.getTime();
+  date.setTime(date.getTime() + offset);
+  return date;
+}
+function isRoutingError(e) {
+  return e instanceof RemoteRouterServerUnreachable || e instanceof RoutingModeCorrespondanceNotFound || e instanceof geo.NoRouteFoundError;
+}
+function jsonToCoordinates$2(json) {
+  return new geo.Coordinates(json.Lat, json.Long);
+}
+function jsonDateToTimestamp(jsonDate) {
+  const [dateStr, timeStr] = jsonDate.split(" ");
+  const [dayStr, monthStr, yearStr] = dateStr.split("/");
+  const [hoursStr, minutesStr, secondsStr] = timeStr.split(":");
+  return dateWithTimeZone(
+    Number(yearStr),
+    Number(monthStr) - 1,
+    Number(dayStr),
+    Number(hoursStr),
+    Number(minutesStr),
+    Number(secondsStr)
+  ).getTime();
+}
+const inputModeCorrespondance$2 = /* @__PURE__ */ new Map();
+inputModeCorrespondance$2.set("CAR", "Car");
+inputModeCorrespondance$2.set("WALK", "Walk");
+inputModeCorrespondance$2.set("BIKE", "Bike");
+inputModeCorrespondance$2.set("BUS", "PT");
+inputModeCorrespondance$2.set("MULTI", "PT");
+const routingModeCorrespondance$1 = /* @__PURE__ */ new Map();
+routingModeCorrespondance$1.set("WALK", "WALK");
+routingModeCorrespondance$1.set("BICYCLE", "BIKE");
+routingModeCorrespondance$1.set("TRAMWAY", "TRAM");
+routingModeCorrespondance$1.set("METRO", "METRO");
+routingModeCorrespondance$1.set("FUNICULAR", "FUNICULAR");
+routingModeCorrespondance$1.set("BUS", "BUS");
+routingModeCorrespondance$1.set("COACH", "BUS");
+routingModeCorrespondance$1.set("SCHOOL", "BUS");
+routingModeCorrespondance$1.set("BUS_PMR", "BUS");
+routingModeCorrespondance$1.set("MINIBUS", "BUS");
+routingModeCorrespondance$1.set("TROLLEY_BUS", "BUS");
+routingModeCorrespondance$1.set("TAXIBUS", "BUS");
+routingModeCorrespondance$1.set("SHUTTLE", "BUS");
+routingModeCorrespondance$1.set("TRAIN", "TRAIN");
+routingModeCorrespondance$1.set("HST", "TRAIN");
+routingModeCorrespondance$1.set("LOCAL_TRAIN", "TRAIN");
+routingModeCorrespondance$1.set("AIR", "AIRPLANE");
+routingModeCorrespondance$1.set("FERRY", "BOAT");
+routingModeCorrespondance$1.set("TAXI", "UNKNOWN");
+routingModeCorrespondance$1.set("CAR_POOL", "UNKNOWN");
+routingModeCorrespondance$1.set("PRIVATE_VEHICLE", "CAR");
+routingModeCorrespondance$1.set("SCOOTER", "MOTO");
+const planTripType = /* @__PURE__ */ new Map();
+planTripType.set(0, "BUS");
+planTripType.set(1, "WALK");
+planTripType.set(2, "BIKE");
+planTripType.set(3, "CAR");
+planTripType.set(4, "UNKNOWN");
+planTripType.set(5, "UNKNOWN");
+planTripType.set(6, "UNKNOWN");
+planTripType.set(7, "UNKNOWN");
+planTripType.set(8, "UNKNOWN");
+planTripType.set(9, "UNKNOWN");
+planTripType.set(10, "UNKNOWN");
+planTripType.set(11, "UNKNOWN");
+planTripType.set(12, "UNKNOWN");
+planTripType.set(13, "UNKNOWN");
+planTripType.set(14, "UNKNOWN");
+function parseWKTGeometry(wktGeometry) {
+  const tmpCoordsStr = wktGeometry.match(/LINESTRING ?\((.*)\)/i);
+  const tmpCoordsPt = wktGeometry.match(/POINT ?\((.*)\)/i);
+  if (tmpCoordsPt) {
+    const [lng, lat] = tmpCoordsPt[1].split(" ");
+    return [new geo.Coordinates(Number(lat), Number(lng))];
+  }
+  return tmpCoordsStr[1].split(",").map((str) => {
+    const sp = str.trim().split(" ");
+    return new geo.Coordinates(Number(sp[1]), Number(sp[0]));
+  });
+}
+class CitywayRemoteRouter extends RemoteRouter {
+  get rname() {
+    return "cityway";
+  }
+  async getItineraries(endpointUrl, mode, waypoints) {
+    const url = this.getURL(endpointUrl, mode, waypoints);
+    const res = await fetch(url).catch(() => {
+      throw new RemoteRouterServerUnreachable(this.rname, url);
+    });
+    const jsonResponse = await res.json().catch(() => {
+      throw new RemoteRouterServerUnreachable(this.rname, url);
+    });
+    return this.createRouterResponseFromJson(jsonResponse, waypoints[0], waypoints[1]);
+  }
+  getURL(endpointUrl, mode, waypoints) {
+    const citywayMode = inputModeCorrespondance$2.get(mode);
+    if (!citywayMode) {
+      throw new RoutingModeCorrespondanceNotFound(this.rname, mode);
+    }
+    if (waypoints.length > 2) {
+      Logger__default.default.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+    }
+    const fromPlace = `DepartureLatitude=${waypoints[0].latitude}&DepartureLongitude=${waypoints[0].longitude}`;
+    const toPlace = `ArrivalLatitude=${waypoints[1].latitude}&ArrivalLongitude=${waypoints[1].longitude}`;
+    const queryMode = `TripModes=${citywayMode}`;
+    const url = new URL(endpointUrl);
+    let { search } = url;
+    search = (search ? `${search}&` : "?") + `${fromPlace}&${toPlace}&${queryMode}`;
+    return `${url.origin}${url.pathname}${search}`;
+  }
+  createRouterResponseFromJson(json, from, to) {
+    const routerResponse = new RouterResponse({ routerName: this.rname, from, to });
+    if (json.StatusCode !== 200 || !json.Data || !json.Data.length) {
+      return routerResponse;
+    }
+    const allJsonTrips = json.Data.map(
+      (dataObj) => dataObj.response.trips.Trip.map((trip) => ({
+        ...trip,
+        ...dataObj.hasOwnProperty("PlanTripType") && { PlanTripType: dataObj.PlanTripType }
+      }))
+    ).flat();
+    itineraryLoop:
+      for (const trip of allJsonTrips) {
+        if (trip.hasOwnProperty("PlanTripType") && planTripType.get(trip.PlanTripType) === "UNKNOWN") {
+          continue;
+        }
+        const legs = [];
+        for (const jsonSection of trip.sections.Section) {
+          const jsonLeg = jsonSection.Leg ? jsonSection.Leg : jsonSection.PTRide;
+          const legMode = routingModeCorrespondance$1.get(jsonLeg.TransportMode);
+          const legCoords = [];
+          let legFrom, legTo;
+          let transportInfo;
+          let stepsInfo;
+          if (legMode === "UNKNOWN") {
+            continue itineraryLoop;
+          }
+          if (legMode === "WALK" || legMode === "BIKE" || legMode === "CAR") {
+            legFrom = {
+              name: jsonLeg.Departure.Site.Name,
+              coords: jsonToCoordinates$2(jsonLeg.Departure.Site.Position)
+            };
+            legTo = {
+              name: jsonLeg.Arrival.Site.Name,
+              coords: jsonToCoordinates$2(jsonLeg.Arrival.Site.Position)
+            };
+            stepsInfo = [];
+            for (const jsonPathLink of jsonLeg.pathLinks.PathLink) {
+              let stepCoords;
+              if (jsonPathLink.Geometry && jsonPathLink.Geometry !== "Null") {
+                stepCoords = parseWKTGeometry(jsonPathLink.Geometry);
+              } else {
+                stepCoords = [legFrom.coords, legTo.coords];
+              }
+              stepCoords.forEach((coords, idx) => {
+                if (idx !== 0 || legCoords.length === 0 || !legCoords[legCoords.length - 1].equals(coords)) {
+                  legCoords.push(coords);
+                }
+              });
+              stepsInfo.push(new StepInfo({
+                coords: stepCoords[0],
+                distance: jsonPathLink.Distance,
+                name: jsonPathLink.Departure.Site.Name
+              }));
+            }
+          } else if (isRoutingModePublicTransport(legMode)) {
+            legFrom = {
+              name: jsonLeg.Departure.StopPlace.Name,
+              coords: jsonToCoordinates$2(jsonLeg.Departure.StopPlace.Position)
+            };
+            legTo = {
+              name: jsonLeg.Arrival.StopPlace.Name,
+              coords: jsonToCoordinates$2(jsonLeg.Arrival.StopPlace.Position)
+            };
+            let transportName = jsonLeg.Line.Number;
+            if (legMode === "TRAM" && transportName.toLowerCase().includes("tram")) {
+              transportName = transportName.substr(5);
+            }
+            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 || legCoords.length === 0 || !legCoords[legCoords.length - 1].equals(coords)) {
+                  legCoords.push(coords);
+                }
+              });
+            }
+            stepsInfo = [new StepInfo({
+              coords: legCoords[0],
+              name: jsonLeg.Line.Name,
+              distance: jsonLeg.Distance
+            })];
+          } else {
+            Logger__default.default.warn(`[CitywayParser] Unknown leg mode: ${jsonLeg.TransportMode}`);
+            continue;
+          }
+          const leg = new Leg({
+            mode: legMode,
+            duration: this.parseDuration(jsonLeg.Duration),
+            startTime: jsonDateToTimestamp(jsonLeg.Departure.Time),
+            endTime: jsonDateToTimestamp(jsonLeg.Arrival.Time),
+            coords: legCoords,
+            from: legFrom,
+            to: legTo,
+            transportInfo
+          });
+          legs.push(leg);
+        }
+        const itinerary = new Itinerary({
+          duration: this.parseDuration(trip.Duration),
+          startTime: jsonDateToTimestamp(trip.Departure.Time),
+          from: jsonToCoordinates$2(trip.Departure.Site.Position),
+          endTime: jsonDateToTimestamp(trip.Arrival.Time),
+          to: jsonToCoordinates$2(trip.Arrival.Site.Position),
+          legs
+        });
+        routerResponse.itineraries.push(itinerary);
+      }
+    return routerResponse;
+  }
+  parseDuration(iso8601Duration) {
+    const iso8601DurationRegex = /(-)?P(?:([.,\d]+)Y)?(?:([.,\d]+)M)?(?:([.,\d]+)W)?(?:([.,\d]+)D)?T(?:([.,\d]+)H)?(?:([.,\d]+)M)?(?:([.,\d]+)S)?/;
+    const matches = iso8601Duration.match(iso8601DurationRegex);
+    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);
+  }
+}
+const CitywayRemoteRouter$1 = new CitywayRemoteRouter();
+class DeutscheBahnRemoteRouter extends RemoteRouter {
+  get rname() {
+    return "deutsche-bahn";
+  }
+  async getItineraries(endpointUrl, mode, waypoints) {
+    const url = this.getURL(endpointUrl, mode, waypoints);
+    const res = await fetch(url).catch(() => {
+      throw new RemoteRouterServerUnreachable(this.rname, url);
+    });
+    const jsonResponse = await res.json().catch(() => {
+      throw new RemoteRouterServerUnreachable(this.rname, url);
+    });
+    return this.createRouterResponseFromJson(jsonResponse, waypoints[0], waypoints[1]);
+  }
+  getURL(endpointUrl, mode, waypoints) {
+    let url = endpointUrl + "/route/v1/walking/";
+    url += waypoints.map((waypoint) => {
+      if (waypoint.level !== null) {
+        const altitude = geo.Level.isRange(waypoint.level) ? waypoint.level[0] : waypoint.level;
+        return waypoint.longitude + "," + waypoint.latitude + "," + altitude;
+      }
+      return waypoint.longitude + "," + waypoint.latitude;
+    }).join(";");
+    url += "?geometries=geojson&overview=full&steps=true";
+    return url;
+  }
+  createRouterResponseFromJson(json, from, to) {
+    const routerResponse = new RouterResponse({ routerName: this.rname, from, to });
+    if (!json.segments) {
+      return routerResponse;
+    }
+    const legs = json.segments.map((segment) => {
+      const level = geo.Level.union(segment.fromLevel, segment.toLevel);
+      const coords = segment.polyline.map(
+        ({ lon, lat }) => new geo.Coordinates(lat, lon, null, level)
+      );
+      return new Leg({
+        mode: "WALK",
+        coords,
+        from: { coords: coords[0] },
+        to: { coords: coords[coords.length - 1] }
+      });
+    });
+    routerResponse.itineraries = [new Itinerary({ from, to, legs })];
+    return routerResponse;
+  }
+}
+const DeutscheBahnRemoteRouter$1 = new DeutscheBahnRemoteRouter();
+const routingModeCorrespondance = /* @__PURE__ */ new Map();
+routingModeCorrespondance.set("Air", "AIRPLANE");
+routingModeCorrespondance.set("Boat", "BOAT");
+routingModeCorrespondance.set("Bus", "BUS");
+routingModeCorrespondance.set("BusRapidTransit", "BUS");
+routingModeCorrespondance.set("Coach", "BUS");
+routingModeCorrespondance.set("Ferry", "FERRY");
+routingModeCorrespondance.set("Funicular", "FUNICULAR");
+routingModeCorrespondance.set("LocalTrain", "TRAIN");
+routingModeCorrespondance.set("LongDistanceTrain", "TRAIN");
+routingModeCorrespondance.set("Metro", "METRO");
+routingModeCorrespondance.set("M\xE9tro", "METRO");
+routingModeCorrespondance.set("RailShuttle", "TRAIN");
+routingModeCorrespondance.set("RapidTransit", "BUS");
+routingModeCorrespondance.set("Shuttle", "BUS");
+routingModeCorrespondance.set("SuspendedCableCar", "FUNICULAR");
+routingModeCorrespondance.set("Taxi", "TAXI");
+routingModeCorrespondance.set("Train", "TRAIN");
+routingModeCorrespondance.set("RER", "TRAIN");
+routingModeCorrespondance.set("Tramway", "TRAM");
+routingModeCorrespondance.set("walking", "WALK");
+routingModeCorrespondance.set("bike", "BIKE");
+const TRANSPORT_IDS = [
+  "physical_mode:Air",
+  "physical_mode:Boat",
+  "physical_mode:Bus",
+  "physical_mode:BusRapidTransit",
+  "physical_mode:Coach",
+  "physical_mode:Ferry",
+  "physical_mode:Funicular",
+  "physical_mode:LocalTrain",
+  "physical_mode:LongDistanceTrain",
+  "physical_mode:Metro",
+  "physical_mode:RailShuttle",
+  "physical_mode:RapidTransit",
+  "physical_mode:Shuttle",
+  "physical_mode:SuspendedCableCar",
+  "physical_mode:Taxi",
+  "physical_mode:Train",
+  "physical_mode:Tramway"
+];
+const apiKey = "qWHj6ax6DMttG8DX6tH9CQARaiTgQ1Di";
+function jsonToCoordinates$1(json) {
+  return new geo.Coordinates(Number(json.lat), Number(json.lon));
+}
+function last(array) {
+  return array[array.length - 1];
+}
+function dateStringToTimestamp(stringDate, timeZone) {
+  const yearStr = stringDate.substr(0, 4);
+  const monthStr = stringDate.substr(4, 2);
+  const dayStr = stringDate.substr(6, 2);
+  const hoursStr = stringDate.substr(9, 2);
+  const minutesStr = stringDate.substr(11, 2);
+  const secondsStr = stringDate.substr(13, 2);
+  return dateWithTimeZone(
+    Number(yearStr),
+    Number(monthStr) - 1,
+    Number(dayStr),
+    Number(hoursStr),
+    Number(minutesStr),
+    Number(secondsStr),
+    timeZone
+  ).getTime();
+}
+class IdfmRemoteRouter extends RemoteRouter {
+  get rname() {
+    return "idfm";
+  }
+  async getItineraries(endpointUrl, mode, waypoints) {
+    const url = this.getURL(endpointUrl, mode, waypoints);
+    const res = await fetch(url, {
+      method: "GET",
+      headers: { apiKey }
+    }).catch(() => {
+      throw new RemoteRouterServerUnreachable(this.rname, url);
+    });
+    const jsonResponse = await res.json().catch(() => {
+      throw new RemoteRouterServerUnreachable(this.rname, url);
+    });
+    if (jsonResponse && jsonResponse.error) {
+      return new RouterResponse({
+        routerName: this.rname,
+        from: waypoints[0],
+        to: waypoints[1],
+        error: jsonResponse.error.message || "no details."
+      });
+    }
+    return this.createRouterResponseFromJson(jsonResponse, waypoints[0], waypoints[1]);
+  }
+  getURL(endpointUrl, mode, waypoints) {
+    if (waypoints.length > 2) {
+      Logger__default.default.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+    }
+    const fromPlace = `from=${waypoints[0].longitude};${waypoints[0].latitude}`;
+    const toPlace = `to=${waypoints[1].longitude};${waypoints[1].latitude}`;
+    const url = new URL(endpointUrl);
+    let { search } = url;
+    search = (search ? `${search}&` : "?") + `${fromPlace}&${toPlace}`;
+    let query = "";
+    switch (mode) {
+      case "WALK":
+        query = this.getWalkingQuery();
+        break;
+      case "BIKE":
+        query = this.getBikeQuery();
+        break;
+      case "CAR":
+        query = this.getCarQuery();
+        break;
+    }
+    return `${url.origin}${url.pathname}${search}${query}`;
+  }
+  getCarQuery() {
+    const forbiddenTransport = TRANSPORT_IDS.map((id) => `forbidden_uris[]=${id}`).join("&");
+    const allowCar = "first_section_mode[]=walking&first_section_mode[]=car&last_section_mode[]=walking&last_section_mode[]=car";
+    return `&${forbiddenTransport}&${allowCar}`;
+  }
+  getWalkingQuery() {
+    const forbiddenTransport = TRANSPORT_IDS.map((id) => `forbidden_uris[]=${id}`).join("&");
+    const allowWalking = "first_section_mode[]=walking&last_section_mode[]=walking";
+    return `&${forbiddenTransport}&${allowWalking}`;
+  }
+  getBikeQuery() {
+    const forbiddenTransport = TRANSPORT_IDS.map((id) => `forbidden_uris[]=${id}`).join("&");
+    const allowBike = "first_section_mode[]=bike&last_section_mode[]=bike";
+    return `&${forbiddenTransport}&${allowBike}`;
+  }
+  getSectionCoords(section) {
+    const from = section.from.stop_point ? jsonToCoordinates$1(section.from.stop_point.coord) : jsonToCoordinates$1(section.from.address.coord);
+    const to = section.to.stop_point ? jsonToCoordinates$1(section.to.stop_point.coord) : jsonToCoordinates$1(section.to.address.coord);
+    return {
+      from,
+      to
+    };
+  }
+  findStepsCoord(legCoords, steps) {
+    const coords = legCoords;
+    const duplicatedCoords = [...coords];
+    let previousStep = steps[0];
+    let accumulatedIndex = 0;
+    const outputSteps = [];
+    for (const [idx, step] of steps.entries()) {
+      let newCoords;
+      let _idCoordsInLeg;
+      if (idx === 0) {
+        _idCoordsInLeg = 0;
+        newCoords = coords[0];
+      } else if (idx === steps.length - 1) {
+        _idCoordsInLeg = coords.length - 1;
+        newCoords = last(coords);
+      } else if (duplicatedCoords.length === 1) {
+        accumulatedIndex++;
+        _idCoordsInLeg = accumulatedIndex;
+        newCoords = duplicatedCoords[0];
+        coords[_idCoordsInLeg] = newCoords;
+      } else {
+        const result = geo.Utils.trimRoute(duplicatedCoords, duplicatedCoords[0], previousStep.distance);
+        accumulatedIndex += result.length - 1;
+        duplicatedCoords.splice(0, result.length - 1);
+        _idCoordsInLeg = accumulatedIndex;
+        newCoords = last(result);
+        coords[_idCoordsInLeg] = newCoords;
+      }
+      outputSteps.push({
+        ...step,
+        coords: newCoords
+      });
+      previousStep = step;
+    }
+    return outputSteps;
+  }
+  createRouterResponseFromJson(json, from, to) {
+    var _a;
+    const routerResponse = new RouterResponse({ routerName: this.rname, from, to });
+    if (!json || !json.journeys) {
+      return routerResponse;
+    }
+    const timeZone = json.context.timezone;
+    for (const jsonItinerary of json.journeys) {
+      const legs = [];
+      for (const jsonSection of jsonItinerary.sections) {
+        if (jsonSection.type === "waiting" || jsonSection.type === "transfer") {
+          continue;
+        }
+        const { from: fromSection, to: toSection } = this.getSectionCoords(jsonSection);
+        let existingCoords = [];
+        const legCoords = jsonSection.geojson.coordinates.reduce((acc, [lon, lat]) => {
+          if (!existingCoords.includes(`${lon}-${lat}`)) {
+            existingCoords = existingCoords.concat(`${lon}-${lat}`);
+            acc.push(new geo.Coordinates(lat, lon));
+          }
+          return acc;
+        }, []);
+        let stepsInfo;
+        if (jsonSection.path) {
+          const idfmIntermediateSteps = [];
+          for (const jsonPathLink of jsonSection.path) {
+            idfmIntermediateSteps.push({
+              name: jsonPathLink.name,
+              distance: jsonPathLink.length
+            });
+          }
+          stepsInfo = this.findStepsCoord(legCoords, idfmIntermediateSteps);
+        }
+        const leg = new Leg({
+          mode: routingModeCorrespondance.get(jsonSection.mode),
+          duration: jsonSection.duration,
+          startTime: dateStringToTimestamp(jsonSection.departure_date_time, timeZone),
+          endTime: dateStringToTimestamp(jsonSection.arrival_date_time, timeZone),
+          from: {
+            name: jsonSection.from.name,
+            coords: fromSection
+          },
+          to: {
+            name: jsonSection.to.name,
+            coords: toSection
+          },
+          coords: legCoords,
+          stepsInfo
+        });
+        if (jsonSection.type === "public_transport") {
+          leg.transportInfo = {
+            name: jsonSection.display_informations.code,
+            routeColor: jsonSection.display_informations.color,
+            routeTextColor: jsonSection.display_informations.text_color,
+            directionName: jsonSection.display_informations.direction
+          };
+          leg.mode = routingModeCorrespondance.get(jsonSection.display_informations.physical_mode);
+          const legStep = new StepInfo({
+            coords: leg.coords[0],
+            name: (_a = leg.transportInfo) == null ? void 0 : _a.directionName,
+            distance: jsonSection.geojson.properties[0].length
+          });
+          leg.stepsInfo = [legStep];
+        }
+        legs.push(leg);
+      }
+      const itinerary = new Itinerary({
+        duration: jsonItinerary.duration,
+        startTime: dateStringToTimestamp(jsonItinerary.departure_date_time, timeZone),
+        endTime: dateStringToTimestamp(jsonItinerary.arrival_date_time, timeZone),
+        from: this.getSectionCoords(jsonItinerary.sections[0]).from,
+        to: this.getSectionCoords(last(jsonItinerary.sections)).to,
+        legs
+      });
+      routerResponse.itineraries.push(itinerary);
+    }
+    return routerResponse;
+  }
+}
+const IdfmRemoteRouter$1 = new IdfmRemoteRouter();
+const inputModeCorrespondance$1 = /* @__PURE__ */ new Map();
+inputModeCorrespondance$1.set("CAR", "driving");
+inputModeCorrespondance$1.set("WALK", "walking");
+inputModeCorrespondance$1.set("BIKE", "bike");
+inputModeCorrespondance$1.set("BUS", "bus");
+inputModeCorrespondance$1.set("MULTI", "walking");
+class OsrmRemoteRouter extends RemoteRouter {
+  get rname() {
+    return "osrm";
+  }
+  async getItineraries(endpointUrl, mode, waypoints) {
+    const url = this.getURL(endpointUrl, mode, waypoints);
+    const res = await fetch(url).catch(() => {
+      throw new RemoteRouterServerUnreachable(this.rname, url);
+    });
+    const jsonResponse = await res.json().catch(() => {
+      throw new RemoteRouterServerUnreachable(this.rname, url);
+    });
+    const from = waypoints[0];
+    const to = waypoints[waypoints.length - 1];
+    return this.createRouterResponseFromJson(jsonResponse, from, to);
+  }
+  getURL(endpointUrl, mode, waypoints) {
+    const osrmMode = inputModeCorrespondance$1.get(mode);
+    if (!osrmMode) {
+      throw new RoutingModeCorrespondanceNotFound(this.rname, mode);
+    }
+    let url = endpointUrl + "/route/v1/" + osrmMode + "/";
+    url += waypoints.map((waypoint) => [waypoint.longitude + "," + waypoint.latitude]).join(";");
+    url += "?geometries=geojson&overview=full&steps=true";
+    return url;
+  }
+  coordinatesToJson({ lat, lng, level }) {
+    if (level === null) {
+      return [lng, lat];
+    }
+    if (geo.Level.isRange(level)) {
+      return [lng, lat, level[0]];
+    }
+    return [lng, lat, level];
+  }
+  jsonToCoordinates(json) {
+    const coords = new geo.Coordinates(json[1], json[0]);
+    if (json.length > 2) {
+      coords.level = json[2];
+    }
+    return coords;
+  }
+  getModifierFromAngle(_angle) {
+    const angle = maths.positiveMod(maths.rad2deg(_angle), 360);
+    if (angle > 0 && angle < 60) {
+      return "sharp right";
+    }
+    if (angle >= 60 && angle < 140) {
+      return "right";
+    }
+    if (angle >= 140 && angle < 160) {
+      return "slight right";
+    }
+    if (angle >= 160 && angle <= 200) {
+      return "straight";
+    }
+    if (angle > 200 && angle <= 220) {
+      return "slight left";
+    }
+    if (angle > 220 && angle <= 300) {
+      return "left";
+    }
+    if (angle > 300 && angle < 360) {
+      return "sharp left";
+    }
+    return "u turn";
+  }
+  noRouteFoundJson(message) {
+    return {
+      "code": "NoRoute",
+      message
+    };
+  }
+  itineraryToOsrmJson(itinerary) {
+    const lastLegId = itinerary.legs.length - 1;
+    const itinerarySteps = itinerary.steps;
+    const jsonLegs = itinerary.legs.map(({ distance, duration, coords }, idLeg) => {
+      const legSteps = itinerarySteps.filter(
+        (step) => coords.find((_coords) => _coords.equals(step.coords))
+      );
+      const lastStepId = legSteps.length - 1;
+      return {
+        distance,
+        duration: duration || 0,
+        steps: legSteps.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.equals(step.coords));
+          const nextStepCoordsIdx = idStep === lastStepId ? stepCoordsIdx : coords.findIndex((p) => p.equals(arr[idStep + 1].coords));
+          const osrmStep = {
+            geometry: {
+              type: "LineString",
+              coordinates: coords.slice(stepCoordsIdx, nextStepCoordsIdx + 1).map(this.coordinatesToJson)
+            },
+            distance: step.distance,
+            duration: step.duration || 0,
+            ...step.name && { name: step.name },
+            maneuver: {
+              bearing_before: maths.rad2deg(step.previousBearing),
+              bearing_after: maths.rad2deg(step.nextBearing),
+              location: this.coordinatesToJson(step.coords),
+              modifier: this.getModifierFromAngle(step.angle),
+              type
+            }
+          };
+          return osrmStep;
+        })
+      };
+    });
+    return {
+      "code": "Ok",
+      "routes": [
+        {
+          "geometry": {
+            "type": "LineString",
+            "coordinates": itinerary.coords.map(this.coordinatesToJson)
+          },
+          "legs": jsonLegs,
+          "distance": itinerary.distance,
+          "duration": itinerary.duration,
+          "weight_name": "routability",
+          "weight": 0
+        }
+      ],
+      "waypoints": []
+    };
+  }
+  createRouterResponseFromJson(json, from, to, routingMode = "walking") {
+    const routerResponse = new RouterResponse({ routerName: this.rname, from, to });
+    const { routes: jsonRoutes } = json;
+    if (!jsonRoutes) {
+      return routerResponse;
+    }
+    const routingModeCorrespondance2 = /* @__PURE__ */ new Map();
+    routingModeCorrespondance2.set("walking", "WALK");
+    routingModeCorrespondance2.set("driving", "CAR");
+    routingModeCorrespondance2.set("bicycle", "BIKE");
+    const mode = routingModeCorrespondance2.get(routingMode) || "WALK";
+    routerResponse.itineraries = jsonRoutes.map((jsonItinerary) => {
+      const legs = jsonItinerary.legs.map((jsonLeg) => {
+        var _a;
+        const legCoords = jsonLeg.steps.map((step) => step.geometry.coordinates.map(this.jsonToCoordinates)).flat().filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equals(coords));
+        const stepsInfo = (_a = jsonLeg.steps) == null ? void 0 : _a.map(({ maneuver, name, distance, duration }) => {
+          const stepCoords = this.jsonToCoordinates(maneuver.location);
+          const distances = legCoords.map((coords) => coords.distanceTo(stepCoords));
+          const idStepCoordsInLeg = distances.indexOf(Math.min(...distances));
+          if (idStepCoordsInLeg < 0) {
+            throw new Error("Osrm Parser: Cannot find step coords in leg coordinates");
+          }
+          return new StepInfo({
+            coords: stepCoords,
+            name,
+            distance,
+            duration
+          });
+        });
+        return new Leg({
+          mode,
+          duration: jsonLeg.duration,
+          coords: legCoords,
+          from: {
+            coords: legCoords[0]
+          },
+          to: {
+            coords: legCoords[legCoords.length - 1]
+          },
+          stepsInfo
+        });
+      });
+      return new Itinerary({
+        duration: jsonItinerary.duration,
+        from,
+        to,
+        legs
+      });
+    });
+    return routerResponse;
+  }
+}
+const OsrmRemoteRouter$1 = new OsrmRemoteRouter();
+function isLegPT(leg) {
+  return leg.mode === "BUS" || leg.mode === "TRAM";
+}
+function jsonToCoordinates(json) {
+  return new geo.Coordinates(json.lat, json.lon);
+}
+const inputModeCorrespondance = /* @__PURE__ */ new Map();
+inputModeCorrespondance.set("CAR", "CAR");
+inputModeCorrespondance.set("WALK", "WALK");
+inputModeCorrespondance.set("BIKE", "BICYCLE");
+inputModeCorrespondance.set("BUS", "WALK,TRANSIT");
+inputModeCorrespondance.set("MULTI", "WALK,TRANSIT");
+class OtpRemoteRouter extends RemoteRouter {
+  get rname() {
+    return "otp";
+  }
+  async getItineraries(endpointUrl, mode, waypoints) {
+    const url = this.getURL(endpointUrl, mode, waypoints);
+    const res = await fetch(url).catch(() => {
+      throw new RemoteRouterServerUnreachable(this.rname, url);
+    });
+    const jsonResponse = await res.json().catch(() => {
+      throw new RemoteRouterServerUnreachable(this.rname, url);
+    });
+    return this.createRouterResponseFromJson(jsonResponse, waypoints[0], waypoints[1]);
+  }
+  getURL(endpointUrl, mode, waypoints) {
+    const otpMode = inputModeCorrespondance.get(mode);
+    if (!otpMode) {
+      throw new RoutingModeCorrespondanceNotFound(this.rname, mode);
+    }
+    if (waypoints.length > 2) {
+      Logger__default.default.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+    }
+    const fromPlace = `fromPlace=${waypoints[0].latitude},${waypoints[0].longitude}`;
+    const toPlace = `toPlace=${waypoints[1].latitude},${waypoints[1].longitude}`;
+    const queryMode = `mode=${otpMode}`;
+    const url = new URL(endpointUrl);
+    let { search } = url;
+    search = (search ? `${search}&` : "?") + `${fromPlace}&${toPlace}&${queryMode}`;
+    return `${url.origin}${url.pathname}${search}`;
+  }
+  createRouterResponseFromJson(json, from, to) {
+    const routerResponse = new RouterResponse({ routerName: this.rname, from, to });
+    const { plan: jsonPlan } = json;
+    if (!jsonPlan) {
+      return routerResponse;
+    }
+    const itinerariesFrom = jsonToCoordinates(jsonPlan.from);
+    const itinerariesTo = jsonToCoordinates(jsonPlan.to);
+    for (const jsonItinerary of jsonPlan.itineraries) {
+      const legs = [];
+      for (const jsonLeg of jsonItinerary.legs) {
+        const legCoords = Polyline__default.default.decode(jsonLeg.legGeometry.points).map(([lat, lon]) => new geo.Coordinates(lat, lon));
+        let transportInfo;
+        let stepsInfo;
+        if (isLegPT(jsonLeg)) {
+          transportInfo = {
+            name: jsonLeg.routeShortName,
+            routeColor: jsonLeg.routeColor,
+            routeTextColor: jsonLeg.routeTextColor,
+            directionName: jsonLeg.headsign
+          };
+          stepsInfo = [new StepInfo({
+            coords: legCoords[0],
+            name: jsonLeg.headsign
+          })];
+        } else {
+          stepsInfo = jsonLeg.steps.map((jsonStep) => {
+            const distances = legCoords.map((coords) => coords.distanceTo(jsonToCoordinates(jsonStep)));
+            const idStepCoordsInLeg = distances.indexOf(Math.min(...distances));
+            if (idStepCoordsInLeg < 0) {
+              throw new Error("OTP Parser: Cannot find closest step");
+            }
+            return new StepInfo({
+              coords: legCoords[idStepCoordsInLeg],
+              name: jsonStep.streetName
+            });
+          });
+        }
+        const leg = new Leg({
+          mode: jsonLeg.mode,
+          duration: jsonLeg.duration,
+          startTime: jsonLeg.startTime,
+          endTime: jsonLeg.endTime,
+          from: {
+            name: jsonLeg.from.name,
+            coords: jsonToCoordinates(jsonLeg.from)
+          },
+          to: {
+            name: jsonLeg.to.name,
+            coords: jsonToCoordinates(jsonLeg.to)
+          },
+          coords: legCoords,
+          transportInfo,
+          stepsInfo
+        });
+        legs.push(leg);
+      }
+      const itinerary = new Itinerary({
+        duration: jsonItinerary.duration,
+        startTime: jsonItinerary.startTime,
+        endTime: jsonItinerary.endTime,
+        from: itinerariesFrom,
+        to: itinerariesTo,
+        legs
+      });
+      routerResponse.itineraries.push(itinerary);
+    }
+    return routerResponse;
+  }
+}
+const OtpRemoteRouter$1 = new OtpRemoteRouter();
+class WemapMultiRemoteRouterPayload {
+  constructor(waypoints, mode, options = null) {
+    this.waypoints = waypoints;
+    this.mode = mode;
+    this.options = options;
+  }
+  toJson() {
+    return {
+      waypoints: this.waypoints.map((coords) => coords.toCompressedJson()),
+      mode: this.mode,
+      ...this.options && { options: this.options }
+    };
+  }
+  static fromJson(json) {
+    return new WemapMultiRemoteRouterPayload(
+      json.waypoints.map(geo.Coordinates.fromCompressedJson),
+      json.mode,
+      json.options
+    );
+  }
+}
+class WemapMultiRemoteRouter extends RemoteRouter {
+  get rname() {
+    return "wemap-meta";
+  }
+  async getItineraries(endpointUrl, mode, waypoints, options) {
+    const payload = new WemapMultiRemoteRouterPayload(
+      waypoints,
+      mode,
+      options
+    );
+    const res = await fetch(endpointUrl, {
+      method: "POST",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload.toJson())
+    }).catch(() => {
+      throw new RemoteRouterServerUnreachable(this.rname, endpointUrl);
+    });
+    const jsonResponse = await res.json().catch(() => {
+      throw new RemoteRouterServerUnreachable(this.rname, endpointUrl);
+    });
+    return RouterResponse.fromJson(jsonResponse);
+  }
+}
+const WemapMultiRemoteRouter$1 = new WemapMultiRemoteRouter();
+class RemoteRouterManager {
+  constructor() {
+    __publicField(this, "remoteRouters", [
+      CitywayRemoteRouter$1,
+      DeutscheBahnRemoteRouter$1,
+      IdfmRemoteRouter$1,
+      OsrmRemoteRouter$1,
+      OtpRemoteRouter$1,
+      WemapMultiRemoteRouter$1
+    ]);
+  }
+  getRouterByName(name) {
+    return this.remoteRouters.find((remoteRouter) => remoteRouter.rname === name);
+  }
+  async getItineraries(name, endpointUrl, mode, waypoints, options) {
+    const router = this.getRouterByName(name);
+    if (!router) {
+      throw new Error(`Unknown "${name}" remote router`);
+    }
+    return router.getItineraries(endpointUrl, mode, waypoints, options);
+  }
+  async getItinerariesWithFallback(remoteRouters, mode, waypoints, options) {
+    let routerResponse;
+    for (const { name, endpointUrl } of remoteRouters) {
+      routerResponse = await this.getItineraries(name, endpointUrl, mode, waypoints, options);
+      if (routerResponse.itineraries.length) {
+        return routerResponse;
+      }
+    }
+    if (!routerResponse) {
+      routerResponse = new RouterResponse({
+        routerName: remoteRouters.map((rr) => rr.name),
+        from: waypoints[0],
+        to: waypoints[waypoints.length]
+      });
+    }
+    return routerResponse;
+  }
+}
+const RemoteRouterManager$1 = new RemoteRouterManager();
+const getRouterNameArray = (routerResponse) => Array.isArray(routerResponse.routerName) ? routerResponse.routerName : [routerResponse.routerName];
+class WemapMultiRouter {
+  constructor() {
+    __publicField(this, "maps", []);
+  }
+  get rname() {
+    return "wemap-meta";
+  }
+  addIOMap(customNetworkMap) {
+    this.maps.push(customNetworkMap);
+  }
+  removeIOMap(customNetworkMap) {
+    this.maps = this.maps.filter((map) => map !== customNetworkMap);
+  }
+  async getItineraries(mode, waypoints, options) {
+    var _a;
+    if (waypoints.length > 2) {
+      Logger__default.default.warn(`WemapMultiRouter uses only the first 2 waypoints (asked ${waypoints.length})`);
+    }
+    const start = waypoints[0];
+    const end = waypoints[1];
+    const routerResponse = new RouterResponse({
+      routerName: this.rname,
+      from: start,
+      to: end
+    });
+    const remoteRouters = ((_a = options.remoteRouters) == null ? void 0 : _a.filter(({ name }) => name !== WemapMultiRemoteRouter$1.rname)) || [];
+    let ioMapsToTest = this.maps;
+    const { targetMaps } = options;
+    if (targetMaps) {
+      ioMapsToTest = this.maps.filter((map) => map.name && targetMaps.includes(map.name));
+      if (ioMapsToTest.length !== targetMaps.length) {
+        ioMapsToTest.forEach((map) => {
+          if (map.name && !targetMaps.includes(map.name)) {
+            Logger__default.default.warn(`CustomNetworkMap "${map.name}" not found in WemapMultiRouter`);
+          }
+        });
+      }
+    }
+    if (!ioMapsToTest.length) {
+      try {
+        return await RemoteRouterManager$1.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+      } catch (e) {
+        if (!isRoutingError(e)) {
+          throw e;
+        }
+        routerResponse.error = e.message;
+        return routerResponse;
+      }
+    }
+    let ioMapItinerary;
+    const mapWithStart = ioMapsToTest.find((map) => map.isPointInside(start));
+    const wemapOsmRouterOptions = !("useStairs" in options) && options.useStairs ? WemapOsmRouterOptions.DEFAULT : WemapOsmRouterOptions.WITHOUT_STAIRS;
+    if (mapWithStart && mapWithStart.isPointInside(end)) {
+      try {
+        ioMapItinerary = mapWithStart.getItineraryInsideMap(start, end, wemapOsmRouterOptions);
+      } catch (e) {
+        if (!isRoutingError(e)) {
+          throw e;
+        }
+        routerResponse.error = `${e.message} - on map ${mapWithStart.name}.`;
+        return routerResponse;
+      }
+      routerResponse.itineraries.push(ioMapItinerary);
+      routerResponse.routerName = [this.rname, WemapOsmRouter.rname];
+      return routerResponse;
+    }
+    const mapWithEnd = ioMapsToTest.find((map) => map.isPointInside(end));
+    let remoteRouterResponse;
+    if (!mapWithStart && !mapWithEnd) {
+      try {
+        return await RemoteRouterManager$1.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+      } catch (e) {
+        if (!isRoutingError(e)) {
+          throw e;
+        }
+        routerResponse.error = e.message;
+        return routerResponse;
+      }
+    }
+    if (mapWithStart && !mapWithEnd) {
+      if (!mapWithStart.entryPoints.length) {
+        routerResponse.error = `A map including the "start" but the "end" has been 
+                    found (${mapWithStart.name}), however, no "entrypoints" have been found to go out`;
+        return routerResponse;
+      }
+      try {
+        ioMapItinerary = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapOsmRouterOptions);
+        remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
+          remoteRouters,
+          mode,
+          [ioMapItinerary.to, end]
+        );
+        if (!remoteRouterResponse.itineraries.length) {
+          throw new geo.NoRouteFoundError(ioMapItinerary.to, end, remoteRouterResponse.error);
+        }
+      } catch (e) {
+        if (!isRoutingError(e)) {
+          throw e;
+        }
+        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" using wemap router on local map "${mapWithStart.name}" and an itinerary from  "entrypoints" to "end" using remote routers (${remoteRouters.map((r) => r.name).join(", ")}), but failed. Details: ${e.message}.`;
+        return routerResponse;
+      }
+      routerResponse.itineraries = remoteRouterResponse.itineraries.map(
+        (remoteRouterItinerary) => Itinerary.fromItineraries(ioMapItinerary, remoteRouterItinerary)
+      );
+      routerResponse.routerName = [this.rname, ...getRouterNameArray(remoteRouterResponse), WemapOsmRouter.rname];
+      return routerResponse;
+    }
+    if (!mapWithStart && mapWithEnd) {
+      if (!mapWithEnd.entryPoints.length) {
+        routerResponse.error = `A map including the "end" but the "start" has been 
+                    found (${mapWithEnd.name}), however, no "entrypoints" have been found to go in`;
+        return routerResponse;
+      }
+      try {
+        ioMapItinerary = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapOsmRouterOptions);
+        remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
+          remoteRouters,
+          mode,
+          [start, ioMapItinerary.from]
+        );
+        if (!remoteRouterResponse.itineraries.length) {
+          throw new geo.NoRouteFoundError(start, ioMapItinerary.from, remoteRouterResponse.error);
+        }
+      } catch (e) {
+        if (!isRoutingError(e)) {
+          throw e;
+        }
+        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" using remote routers (${remoteRouters.map((r) => r.name).join(", ")}) and an itinerary from "entrypoints" to "end" using wemap router on local map "${mapWithEnd.name}", but failed. Details: ${e.message}.`;
+        return routerResponse;
+      }
+      routerResponse.itineraries = remoteRouterResponse.itineraries.map(
+        (remoteRouterItinerary) => Itinerary.fromItineraries(remoteRouterItinerary, ioMapItinerary)
+      );
+      routerResponse.routerName = [this.rname, ...getRouterNameArray(remoteRouterResponse), WemapOsmRouter.rname];
+      return routerResponse;
+    }
+    if (mapWithStart && mapWithEnd) {
+      if (!mapWithStart.entryPoints.length) {
+        routerResponse.error = `One map including the "start" (${mapWithStart.name}) and another 
+                including the "end" (${mapWithEnd.name}) has been found, however, no "entrypoints" have 
+                been found to go out of the start map`;
+        return routerResponse;
+      }
+      if (!mapWithEnd.entryPoints.length) {
+        routerResponse.error = `One map including the "start" (${mapWithStart.name}) and another 
+                including the "end" (${mapWithEnd.name}) has been found, however, no "entrypoints" have 
+                been found to go in the second map`;
+        return routerResponse;
+      }
+      let ioMapItinerary1, ioMapItinerary2;
+      try {
+        ioMapItinerary1 = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapOsmRouterOptions);
+        ioMapItinerary2 = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapOsmRouterOptions);
+        remoteRouterResponse = await RemoteRouterManager$1.getItinerariesWithFallback(
+          remoteRouters,
+          mode,
+          [ioMapItinerary1.to, ioMapItinerary2.from]
+        );
+        if (!remoteRouterResponse.itineraries.length) {
+          throw new geo.NoRouteFoundError(ioMapItinerary1.to, ioMapItinerary2.from, remoteRouterResponse.error);
+        }
+      } catch (e) {
+        if (!isRoutingError(e)) {
+          throw e;
+        }
+        routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints1" using wemap router on local map  "${mapWithStart.name}", an itinerary from "entrypoints1" to "entrypoints2" using remote routers (${remoteRouters.map((r) => r.name).join(", ")}) and an itinerary from "entrypoints2" to "end" using wemap router on local map "${mapWithEnd.name}", but failed. Details: ${e.message}.`;
+        return routerResponse;
+      }
+      routerResponse.itineraries = remoteRouterResponse.itineraries.map(
+        (remoteRouterItinerary) => Itinerary.fromItineraries(
+          ioMapItinerary1,
+          remoteRouterItinerary,
+          ioMapItinerary2
+        )
+      );
+      routerResponse.routerName = [this.rname, ...getRouterNameArray(remoteRouterResponse), WemapOsmRouter.rname];
+      return routerResponse;
+    }
+    throw new Error("Should never happen");
+  }
+}
+class CustomNetworkMap {
+  constructor(network, entryPoints, bounds = null, name = null) {
+    __publicField(this, "name");
+    __publicField(this, "network");
+    __publicField(this, "router");
+    __publicField(this, "bounds");
+    __publicField(this, "entryPoints");
+    __publicField(this, "disabledWays", /* @__PURE__ */ new Set());
+    this.name = name;
+    this.network = network;
+    this.router = new WemapOsmRouter(network);
+    entryPoints.forEach((entryPoint) => {
+      if (!network.nodes.includes(entryPoint)) {
+        throw new Error(`Cannot find entry point ${entryPoint.coords.toString()} in network "${name}"`);
+      }
+    });
+    this.entryPoints = entryPoints;
+    if (bounds) {
+      this.bounds = helpers.polygon([bounds.map((coords) => [coords.lng, coords.lat])]);
+    } else {
+      const polygon = [network.nodes.map((node) => [node.coords.lng, node.coords.lat])];
+      const convexHull = convexHullFn__default.default({ type: "polygon", coordinates: polygon });
+      if (!convexHull) {
+        throw new Error(`Cannot calculate convexHull of network "${name}"`);
+      }
+      this.bounds = convexHull;
+    }
+  }
+  static fromOsmXml(osmXmlString, name = null) {
+    const osmModel = osm.OsmParser.parseOsmXmlString(osmXmlString);
+    const network = osm.OsmNetworkUtils.createNetworkFromOsmModel(osmModel);
+    const entryPoints = osmModel.nodes.filter(({ tags }) => tags && tags["wemap:routing-io"]).map((osmNode) => network.getNodeByCoords(osmNode.coords));
+    if (entryPoints.some((el) => el === null) || new Set(entryPoints).size !== entryPoints.length) {
+      throw new Error("Cannot parse wemap:routing-io correctly");
+    }
+    const wayBounds = osmModel.ways.find(({ tags }) => tags["wemap:routing-bounds"]);
+    if (!wayBounds) {
+      throw new Error('Search bounds is undefined. Please use OSM tag : "wemap:routing-bounds=yes"');
+    }
+    const bounds = wayBounds.nodes.map((node) => node.coords);
+    return new CustomNetworkMap(network, entryPoints, bounds, name);
+  }
+  isPointInside(coordinates) {
+    return pointInPolygon__default.default([coordinates.lng, coordinates.lat], this.bounds);
+  }
+  getOrderedEntryPointsSortedByDistance(start, end) {
+    const entryPointsCopy = [...this.entryPoints];
+    return entryPointsCopy.sort(
+      (ep1, ep2) => Number(ep1.coords.distanceTo(start)) + ep1.coords.distanceTo(end) - ep2.coords.distanceTo(start) - ep2.coords.distanceTo(end)
+    );
+  }
+  getBestItineraryFromEntryPointsToEnd(start, end, options) {
+    const sortedEntryPoints = this.getOrderedEntryPointsSortedByDistance(start, end);
+    for (const entryPoint of sortedEntryPoints) {
+      const itinerary = this.router.getItinerary(entryPoint, end, options);
+      if (itinerary) {
+        return itinerary;
+      }
+    }
+    throw new geo.NoRouteFoundError(
+      start,
+      end,
+      `No route found from entry points to ${end.toString()} in map: ${this.name}`
+    );
+  }
+  getBestItineraryFromStartToEntryPoints(start, end, options) {
+    const sortedEntryPoints = this.getOrderedEntryPointsSortedByDistance(start, end);
+    for (const entryPoint of sortedEntryPoints) {
+      const itinerary = this.router.getItinerary(start, entryPoint, options);
+      if (itinerary) {
+        return itinerary;
+      }
+    }
+    throw new geo.NoRouteFoundError(
+      start,
+      end,
+      `No route found from ${start.toString()} to entry points in map: ${this.name}`
+    );
+  }
+  getItineraryInsideMap(start, end, options) {
+    return this.router.getItinerary(start, end, options);
+  }
+  enableWay(osmId) {
+    this.network.edges.filter((edge) => {
+      var _a;
+      return ((_a = edge.builtFrom) == null ? void 0 : _a.id) === osmId;
+    }).forEach((e) => this.router.disabledEdges.delete(e));
+    this.disabledWays.delete(osmId);
+  }
+  disableWay(osmId) {
+    this.network.edges.filter((edge) => {
+      var _a;
+      return ((_a = edge.builtFrom) == null ? void 0 : _a.id) === osmId;
+    }).forEach((e) => this.router.disabledEdges.add(e));
+    this.disabledWays.add(osmId);
+  }
+}
+function getTurnInfoFromAngle(_angle) {
+  let direction, directionExtra;
+  const directionAngle = maths.rad2deg(maths.diffAngle(_angle, Math.PI));
+  const directionAngleAbs = Math.abs(directionAngle);
+  if (directionAngleAbs <= 20) {
+    direction = "straight";
+  } else {
+    direction = directionAngle > 0 ? "left" : "right";
+    if (directionAngleAbs < 55) {
+      directionExtra = "slight";
+    } else if (directionAngleAbs > 120) {
+      directionExtra = "sharp";
+    }
+  }
+  return { direction, directionExtra };
+}
+const WemapOsmRouterUtils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getTurnInfoFromAngle
+}, Symbol.toStringTag, { value: "Module" }));
+class ItineraryInfoManager {
+  constructor(itinerary = null) {
+    __publicField(this, "_itinerary", null);
+    __publicField(this, "_mapMatching", null);
+    __publicField(this, "_steps", []);
+    __publicField(this, "_coordsNextStep", []);
+    __publicField(this, "_coordsPreviousStep", []);
+    __publicField(this, "_coordsDistanceTraveled", []);
+    __publicField(this, "_coordsLeg", []);
+    this.itinerary = itinerary;
+  }
+  get itinerary() {
+    return this._itinerary;
+  }
+  set itinerary(itinerary) {
+    if (itinerary === null) {
+      this._itinerary = null;
+      return;
+    }
+    this._itinerary = itinerary;
+    this._steps = itinerary.steps;
+    const network = itinerary.toNetwork();
+    this._mapMatching = new geo.MapMatching(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 (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));
+      if (stepId < this._steps.length && this._steps[stepId].coords.equals(coords)) {
+        previousStep = this._steps[stepId];
+        nextStep = stepId === this._steps.length - 1 ? null : this._steps[stepId + 1];
+        stepId++;
+      }
+    });
+  }
+  getInfo(position) {
+    if (!this._itinerary || !this._mapMatching) {
+      return null;
+    }
+    const projection = this._mapMatching.getProjection(position);
+    if (!projection) {
+      return null;
+    }
+    let itineraryInfo = null;
+    if (projection.nearestElement instanceof geo.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)");
+      }
+      const traveledDistance = this._coordsDistanceTraveled[idx];
+      const remainingDistance = this._itinerary.distance - traveledDistance;
+      itineraryInfo = {
+        nextStep: this._coordsNextStep[idx],
+        previousStep: this._coordsPreviousStep[idx],
+        projection,
+        leg: this._coordsLeg[idx],
+        traveledDistance,
+        remainingDistance,
+        traveledPercentage: traveledDistance / this._itinerary.distance,
+        remainingPercentage: remainingDistance / this._itinerary.distance
+      };
+    } else if (projection.nearestElement instanceof geo.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)");
+      }
+      if (idx === this._itinerary.coords.length - 1 || this._itinerary.coords[idx + 1] !== projection.nearestElement.node2.coords) {
+        firstNode = projection.nearestElement.node2.coords;
+        idx--;
+      }
+      const traveledDistance = this._coordsDistanceTraveled[idx] + projection.coords.distanceTo(firstNode);
+      const remainingDistance = this._itinerary.distance - traveledDistance;
+      itineraryInfo = {
+        nextStep: this._coordsNextStep[idx + 1],
+        previousStep: this._coordsPreviousStep[idx + 1],
+        projection,
+        leg: this._coordsLeg[idx + 1],
+        traveledDistance,
+        remainingDistance,
+        traveledPercentage: traveledDistance / this._itinerary.distance,
+        remainingPercentage: remainingDistance / this._itinerary.distance
+      };
+    }
+    return itineraryInfo;
+  }
+}
+exports.CitywayRemoteRouter = CitywayRemoteRouter$1;
+exports.DeutscheBahnRemoteRouter = DeutscheBahnRemoteRouter$1;
+exports.IdfmRemoteRouter = IdfmRemoteRouter$1;
+exports.Itinerary = Itinerary;
+exports.ItineraryInfoManager = ItineraryInfoManager;
+exports.Leg = Leg;
+exports.OsrmRemoteRouter = OsrmRemoteRouter$1;
+exports.OtpRemoteRouter = OtpRemoteRouter$1;
+exports.RemoteRouterManager = RemoteRouterManager$1;
+exports.RemoteRouterServerUnreachable = RemoteRouterServerUnreachable;
+exports.RouterResponse = RouterResponse;
+exports.StepInfo = StepInfo;
+exports.WemapMetaRouterIOMap = CustomNetworkMap;
+exports.WemapMultiRemoteRouter = WemapMultiRemoteRouter$1;
+exports.WemapMultiRemoteRouterPayload = WemapMultiRemoteRouterPayload;
+exports.WemapMultiRouter = WemapMultiRouter;
+exports.WemapOsmRouter = WemapOsmRouter;
+exports.WemapOsmRouterOptions = WemapOsmRouterOptions;
+exports.WemapOsmRouterUtils = WemapOsmRouterUtils;
+exports.getDurationFromLength = getDurationFromLength;
+//# sourceMappingURL=index.js.map