@twinmatrix/spatialverse-sdk-web 0.0.2 → 0.0.3

package/lib/cjs/meta-atlas-sdk/MetaAtlasCore/routing-core/routing-helpers.js

@@ -20,24 +20,11 @@ var _helpers = require("@turf/helpers");
 var _length = _interopRequireDefault(require("@turf/length"));
 var _turf = require("@turf/turf");
 var _lodash = require("lodash");
-var _interfaces = require("./interfaces");
-var _ = _interopRequireDefault(require("."));
-var _mapObjectsHelper = require("./mapObjectsHelper");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-function _regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return _regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine2(u), _regeneratorDefine2(u, o, "Generator"), _regeneratorDefine2(u, n, function () { return this; }), _regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
-function _regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } _regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { function o(r, n) { _regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); } r ? i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2)); }, _regeneratorDefine2(e, r, n, t); }
-function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
-function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-var ManeuverType = exports.ManeuverType = /*#__PURE__*/function (ManeuverType) {
+var _interfaces = require("./interfaces.js");
+var _index = _interopRequireDefault(require("./index.js"));
+var _mapObjectsHelper = require("./mapObjectsHelper.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+let ManeuverType = exports.ManeuverType = /*#__PURE__*/function (ManeuverType) {
   ManeuverType["RouteOverview"] = "Route Overview";
   ManeuverType["SectionOverview"] = "Section Overview";
   ManeuverType["LeftHairPinTurn"] = "Left hairpin turn";
@@ -54,9 +41,9 @@ var ManeuverType = exports.ManeuverType = /*#__PURE__*/function (ManeuverType) {
   return ManeuverType;
 }({});
 function createDefaultSegment(pathSegment) {
-  var startMapObj = (0, _mapObjectsHelper.getEdge)(pathSegment.edges[0]);
-  var endMapObj = (0, _mapObjectsHelper.getEdge)(pathSegment.edges[1]);
-  var segment = {
+  const startMapObj = (0, _mapObjectsHelper.getEdge)(pathSegment.edges[0]);
+  const endMapObj = (0, _mapObjectsHelper.getEdge)(pathSegment.edges[1]);
+  const segment = {
     maneuverType: ManeuverType.Static,
     coordinates: [],
     distance: 0,
@@ -88,8 +75,8 @@ function isOverviewSegment(segment) {
   return segment.maneuverType === ManeuverType.RouteOverview || segment.maneuverType === ManeuverType.SectionOverview;
 }
 function updateFeatureHighlightState(features, isHighlighted) {
-  for (var index = 0; index < features.length; index += 1) {
-    var feature = features[index];
+  for (let index = 0; index < features.length; index += 1) {
+    const feature = features[index];
     if (isHighlighted) {
       feature.properties.highlight = true;
     } else {
@@ -99,9 +86,9 @@ function updateFeatureHighlightState(features, isHighlighted) {
   return features;
 }
 function highlightRouteSegment(pathFeatures, segmentToHighlight) {
-  var highlightNodeOnly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  for (var index = 0; index < pathFeatures.length; index += 1) {
-    var segment = pathFeatures[index];
+  let highlightNodeOnly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  for (let index = 0; index < pathFeatures.length; index += 1) {
+    const segment = pathFeatures[index];
     if (segment.properties.segmentNumber === segmentToHighlight) {
       if (highlightNodeOnly) {
         if (segment.properties.startPoint === true) {
@@ -117,53 +104,56 @@ function highlightRouteSegment(pathFeatures, segmentToHighlight) {
   return pathFeatures;
 }
 function getRouteNode(coordinates, segmentNumber, isHighlighted, patchNumber) {
-  var whereDimension = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : '';
+  let whereDimension = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : '';
   if (coordinates.length === 0) {
     return [];
   }
-  var properties = {
-    segmentNumber: segmentNumber,
+  const properties = {
+    segmentNumber,
     dimension_where: whereDimension,
-    patchNumber: patchNumber,
+    patchNumber,
     isNode: true
   };
-  var node = (0, _helpers.point)(coordinates, properties);
-  var features = [node];
+  const node = (0, _helpers.point)(coordinates, properties);
+  const features = [node];
   updateFeatureHighlightState(features, isHighlighted);
   return features;
 }
 function getRouteLine(coordinates, segmentNumber, isHighlighted, patchNumber, zone) {
-  var whereDimension = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : '';
+  let whereDimension = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : '';
   if (coordinates.length === 0) {
     return [];
   }
-  var properties = {
-    segmentNumber: segmentNumber,
+  const properties = {
+    segmentNumber,
     dimension_where: whereDimension,
-    patchNumber: patchNumber,
+    patchNumber,
     isNode: false,
-    zone: zone
+    zone
   };
   // const curved = smooth(coordinates, {iteration: 1});
-  var line = (0, _helpers.lineString)(coordinates, _objectSpread(_objectSpread({}, properties), {}, {
+  const line = (0, _helpers.lineString)(coordinates, {
+    ...properties,
     featureBelongsToLineString: true
-  }));
-  var startPoint = (0, _helpers.point)(coordinates[0], _objectSpread(_objectSpread({}, properties), {}, {
+  });
+  const startPoint = (0, _helpers.point)(coordinates[0], {
+    ...properties,
     featureBelongsToLineString: false
-  }));
-  var endPoint = (0, _helpers.point)(coordinates[coordinates.length - 1], _objectSpread(_objectSpread({}, properties), {}, {
+  });
+  const endPoint = (0, _helpers.point)(coordinates[coordinates.length - 1], {
+    ...properties,
     featureBelongsToLineString: false
-  }));
-  var features = [];
+  });
+  const features = [];
   features.push(startPoint, line, endPoint);
   updateFeatureHighlightState(features, isHighlighted);
   return features;
 }
 function getLineStringFeaturesOfRouteSegment(routeSegment) {
-  var whereDimension = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  var lineFeatures = [];
-  for (var index = 0; index < routeSegment.features.length; index += 1) {
-    var feature = routeSegment.features[index];
+  let whereDimension = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  const lineFeatures = [];
+  for (let index = 0; index < routeSegment.features.length; index += 1) {
+    const feature = routeSegment.features[index];
     if (feature.properties.featureBelongsToLineString) {
       if (whereDimension !== '') {
         if (feature.properties.dimension_where && feature.properties.dimension_where === whereDimension) {
@@ -177,9 +167,9 @@ function getLineStringFeaturesOfRouteSegment(routeSegment) {
   return lineFeatures;
 }
 function generateOverviewSegment(route) {
-  var indexOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  var overviewSegment = (0, _lodash.cloneDeep)(route.segments[1]);
-  var initialWhereDimension = route.segments.length > 1 ? route.segments[1].startEdge.whereDimension : '';
+  let indexOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  const overviewSegment = (0, _lodash.cloneDeep)(route.segments[1]);
+  const initialWhereDimension = route.segments.length > 1 ? route.segments[1].startEdge.whereDimension : '';
   overviewSegment.coordinates = [];
   overviewSegment.features = [];
   overviewSegment.time = 0;
@@ -188,14 +178,14 @@ function generateOverviewSegment(route) {
   overviewSegment.maneuverType = ManeuverType.RouteOverview;
   overviewSegment.patchNumber = indexOffset;
   overviewSegment.instructions = ['Overview'];
-  for (var index = 1; index < route.segments.length; index += 1) {
+  for (let index = 1; index < route.segments.length; index += 1) {
     if (route.segments[index].maneuverType !== ManeuverType.SectionOverview) {
-      for (var j = 0; j < route.segments[index].coordinates.length; j += 1) {
-        var coord = route.segments[index].coordinates[j];
+      for (let j = 0; j < route.segments[index].coordinates.length; j += 1) {
+        const coord = route.segments[index].coordinates[j];
         overviewSegment.coordinates.push(coord);
       }
-      for (var _j = 0; _j < route.segments[index].features.length; _j += 1) {
-        var feature = (0, _lodash.cloneDeep)(route.segments[index].features[_j]);
+      for (let j = 0; j < route.segments[index].features.length; j += 1) {
+        const feature = (0, _lodash.cloneDeep)(route.segments[index].features[j]);
         if (feature.properties && !feature.properties.isNode) {
           // isNonHighlightedOverview is used in layer styling to decide the color of lines
           // features which are not on initialWhereDimension should be colored accordingly
@@ -213,551 +203,488 @@ function generateOverviewSegment(route) {
   overviewSegment.distance = route.walkingDistance + route.transportDistance;
   return overviewSegment;
 }
-function createRoute(_x, _x2, _x3) {
-  return _createRoute.apply(this, arguments);
-}
-function _createRoute() {
-  _createRoute = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(startMapObjectId, endMapObjectId, wheelChairAccessibleRouteOnly) {
-    var shouldAddOverviewSegment,
-      indexOffset,
-      path,
-      pathSegments,
-      optimizedPath,
-      endSegment,
-      segmentIndex,
-      pathSegment,
-      currentZone,
-      _path,
-      lastManeuverType,
-      firstSegment,
-      prevPathSegment,
-      prevZone,
-      prevPath,
-      pathPoint,
-      index,
-      startPoint,
-      midPoint,
-      endPoint,
-      currentManeuverType,
-      _pathPoint,
-      _pathPoint2,
-      removeExtraChangeZoneSegment,
-      lastSegmentAdded,
-      immigrationPolygonFeatures,
-      line,
-      _index,
-      immigrationPolygonFeature,
-      intersects,
-      lineBeforeImmigration,
-      lengthOfLineBeforeImmigration,
-      segmentBeforeImmigration,
-      coordsOfLastSegment,
-      secondLastSegmentAdded,
-      immigrationLine,
-      immigrationSegment,
-      lineCoords,
-      lineAfterImmigration,
-      segmentAfterImmigration,
-      startPointWithinPolygon,
-      _immigrationLine,
-      _immigrationSegment,
-      changeZoneSegment,
-      _secondLastSegmentAdded,
-      _lineCoords,
-      _lineAfterImmigration,
-      _segmentAfterImmigration,
-      previousLine,
-      _lineCoords2,
-      _lineAfterImmigration2,
-      _segmentAfterImmigration2,
-      enterPortalSegment,
-      exitPortalSegment,
-      _lastSegmentAdded2,
-      travelPortalSegment,
-      route,
-      addOverviewSegment,
-      initialIndex,
-      dummySegment,
-      patchNumber,
-      whereDimension,
-      _index2,
-      highlight,
-      segment,
-      segmentNumber,
-      routeSegmentCoords,
-      segmentDistance,
-      startEdgeFeatures,
-      features,
-      _iterator,
-      _step,
-      feature,
-      _nextRouteSegment,
-      portalCost,
-      _portalCost,
-      _segmentDistance,
-      nextRouteSegment,
-      overviewSegment,
-      _args = arguments;
-    return _regenerator().w(function (_context) {
-      while (1) switch (_context.n) {
-        case 0:
-          shouldAddOverviewSegment = _args.length > 3 && _args[3] !== undefined ? _args[3] : true;
-          indexOffset = _args.length > 4 && _args[4] !== undefined ? _args[4] : 0;
-          path = _["default"].getRoute(startMapObjectId, endMapObjectId, wheelChairAccessibleRouteOnly);
-          pathSegments = path.routes; // Find optimized path (i.e. combine straight segments) & maneuvers list
-          optimizedPath = [];
-          for (segmentIndex = 0; pathSegments && segmentIndex < pathSegments.length; segmentIndex += 1) {
-            pathSegment = pathSegments[segmentIndex];
-            currentZone = pathSegment.geojson.properties.zone;
-            if (!pathSegment.isPortal) {
-              _path = pathSegment.geojson.geometry.coordinates; // Reset state for each segment of the path
-              lastManeuverType = ManeuverType.Static; // Only add the starting static node for the very first node of route
-              if (optimizedPath.length === 0) {
-                firstSegment = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                  maneuverType: ManeuverType.Static,
-                  coordinates: [_path[0]]
-                });
-                optimizedPath.push(firstSegment);
-              }
-              if (segmentIndex > 0 && optimizedPath.length > 0) {
-                prevPathSegment = pathSegments[segmentIndex - 1];
-                prevZone = prevPathSegment.geojson.properties.zone;
-                if (currentZone !== prevZone) {
-                  prevPath = prevPathSegment.geojson.geometry.coordinates;
-                  pathPoint = _objectSpread(_objectSpread({}, createDefaultSegment(prevPathSegment)), {}, {
-                    maneuverType: ManeuverType.ChangeZone,
-                    zone: currentZone,
-                    coordinates: [prevPath[prevPath.length - 1]]
-                  });
-                  optimizedPath.push(pathPoint);
-                  lastManeuverType = ManeuverType.ChangeZone;
-                }
-              }
-              if (_path.length > 2) {
-                for (index = 0; index < _path.length - 2; index += 1) {
-                  startPoint = _path[index];
-                  midPoint = _path[index + 1];
-                  endPoint = _path[index + 2]; // Keep updating endSegment on each iteration
-                  endSegment = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                    maneuverType: ManeuverType.Static,
-                    coordinates: [endPoint],
-                    zone: currentZone
-                  });
+async function createRoute(startMapObjectId, endMapObjectId, wheelChairAccessibleRouteOnly) {
+  let shouldAddOverviewSegment = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+  let indexOffset = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+  const path = _index.default.getRoute(startMapObjectId, endMapObjectId, wheelChairAccessibleRouteOnly);
+  const pathSegments = path.routes;
 
-                  // const line = lineString([startPoint, midPoint]);
-                  // const segmentDistance = length(line, { units: DISTANCE_UNIT });
+  // Find optimized path (i.e. combine straight segments) & maneuvers list
+  const optimizedPath = [];
+  let endSegment;
+  for (let segmentIndex = 0; pathSegments && segmentIndex < pathSegments.length; segmentIndex += 1) {
+    const pathSegment = pathSegments[segmentIndex];
+    const currentZone = pathSegment.geojson.properties.zone;
+    if (!pathSegment.isPortal) {
+      const path = pathSegment.geojson.geometry.coordinates;
 
-                  // Determine the maneuver type based on the angle of the turn
-                  currentManeuverType = void 0;
-                  currentManeuverType = ManeuverType.ContinueStraight;
-                  // if ((index === 0 || index === path.length - 3) && segmentDistance < 3) {
-                  //   currentManeuverType = ManeuverType.ContinueStraight;
-                  // }
-                  // else {
-                  //   // Calculate the bearings between the points
-                  //   const bearing1 = bearing(startPoint, midPoint);
-                  //   const bearing2 = bearing(midPoint, endPoint);
+      // Reset state for each segment of the path
+      let lastManeuverType = ManeuverType.Static;
 
-                  //   // Calculate the angle between the bearings
-                  //   let angle = bearing2 - bearing1;
-                  //   if (angle < -180) {
-                  //     angle += 360;
-                  //   } else if (angle > 180) {
-                  //     angle -= 360;
-                  //   }
+      // Only add the starting static node for the very first node of route
+      if (optimizedPath.length === 0) {
+        const firstSegment = {
+          ...createDefaultSegment(pathSegment),
+          maneuverType: ManeuverType.Static,
+          coordinates: [path[0]]
+        };
+        optimizedPath.push(firstSegment);
+      }
+      if (segmentIndex > 0 && optimizedPath.length > 0) {
+        const prevPathSegment = pathSegments[segmentIndex - 1];
+        const prevZone = prevPathSegment.geojson.properties.zone;
+        if (currentZone !== prevZone) {
+          const prevPath = prevPathSegment.geojson.geometry.coordinates;
+          const pathPoint = {
+            ...createDefaultSegment(prevPathSegment),
+            maneuverType: ManeuverType.ChangeZone,
+            zone: currentZone,
+            coordinates: [prevPath[prevPath.length - 1]]
+          };
+          optimizedPath.push(pathPoint);
+          lastManeuverType = ManeuverType.ChangeZone;
+        }
+      }
+      if (path.length > 2) {
+        for (let index = 0; index < path.length - 2; index += 1) {
+          const startPoint = path[index];
+          const midPoint = path[index + 1];
+          const endPoint = path[index + 2];
 
-                  //   if (angle < -140) {
-                  //     currentManeuverType = ManeuverType.LeftHairPinTurn;
-                  //   } else if (angle > 140) {
-                  //     currentManeuverType = ManeuverType.RightHairPinTurn;
-                  //   } else if (angle < -50) {
-                  //     currentManeuverType = ManeuverType.LeftTurn;
-                  //   } else if (angle > 50) {
-                  //     currentManeuverType = ManeuverType.RightTurn;
-                  //     // } else if (angle < -10) {
-                  //     //   currentManeuverType = 'Veer left';
-                  //     // } else if (angle > 10) {
-                  //     //   currentManeuverType = 'Veer right';
-                  //   } else {
-                  //     currentManeuverType = ManeuverType.ContinueStraight;
-                  //   }
-                  // }
-                  _pathPoint = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                    maneuverType: currentManeuverType,
-                    zone: currentZone
-                  });
-                  if (lastManeuverType === ManeuverType.ContinueStraight) {
-                    // If last iteration of loop then use the end point as segment end else use mid point
-                    // Use index + 3 because last two points are skipped by loop
-                    if (index + 3 === _path.length) {
-                      optimizedPath[optimizedPath.length - 1].coordinates.push(midPoint, endPoint);
-                    } else {
-                      optimizedPath[optimizedPath.length - 1].coordinates.push(midPoint);
-                    }
-                    optimizedPath[optimizedPath.length - 1].maneuverType = currentManeuverType;
-                  } else {
-                    _pathPoint.coordinates.push(startPoint, midPoint);
-                    optimizedPath.push(_pathPoint);
+          // Keep updating endSegment on each iteration
+          endSegment = {
+            ...createDefaultSegment(pathSegment),
+            maneuverType: ManeuverType.Static,
+            coordinates: [endPoint],
+            zone: currentZone
+          };
 
-                    // If reached end of path then add a ContinueStraight segment at end of path
-                    // Use index + 3 because last two points are skipped by loop
-                    if (index + 3 === _path.length) {
-                      // if a ContinueStraight segment was just added then extend that, else add a new ContinueStraight segment at end
-                      if (currentManeuverType === ManeuverType.ContinueStraight) {
-                        optimizedPath[optimizedPath.length - 1].coordinates.push(endPoint);
-                      } else {
-                        optimizedPath.push(_objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                          maneuverType: ManeuverType.ContinueStraight,
-                          coordinates: [midPoint, endPoint],
-                          zone: currentZone
-                        }));
-                      }
-                    }
-                  }
-                  lastManeuverType = currentManeuverType;
-                }
+          // const line = lineString([startPoint, midPoint]);
+          // const segmentDistance = length(line, { units: DISTANCE_UNIT });
+
+          // Determine the maneuver type based on the angle of the turn
+          let currentManeuverType;
+          currentManeuverType = ManeuverType.ContinueStraight;
+          // if ((index === 0 || index === path.length - 3) && segmentDistance < 3) {
+          //   currentManeuverType = ManeuverType.ContinueStraight;
+          // }
+          // else {
+          //   // Calculate the bearings between the points
+          //   const bearing1 = bearing(startPoint, midPoint);
+          //   const bearing2 = bearing(midPoint, endPoint);
+
+          //   // Calculate the angle between the bearings
+          //   let angle = bearing2 - bearing1;
+          //   if (angle < -180) {
+          //     angle += 360;
+          //   } else if (angle > 180) {
+          //     angle -= 360;
+          //   }
+
+          //   if (angle < -140) {
+          //     currentManeuverType = ManeuverType.LeftHairPinTurn;
+          //   } else if (angle > 140) {
+          //     currentManeuverType = ManeuverType.RightHairPinTurn;
+          //   } else if (angle < -50) {
+          //     currentManeuverType = ManeuverType.LeftTurn;
+          //   } else if (angle > 50) {
+          //     currentManeuverType = ManeuverType.RightTurn;
+          //     // } else if (angle < -10) {
+          //     //   currentManeuverType = 'Veer left';
+          //     // } else if (angle > 10) {
+          //     //   currentManeuverType = 'Veer right';
+          //   } else {
+          //     currentManeuverType = ManeuverType.ContinueStraight;
+          //   }
+          // }
+
+          const pathPoint = {
+            ...createDefaultSegment(pathSegment),
+            maneuverType: currentManeuverType,
+            zone: currentZone
+          };
+          if (lastManeuverType === ManeuverType.ContinueStraight) {
+            // If last iteration of loop then use the end point as segment end else use mid point
+            // Use index + 3 because last two points are skipped by loop
+            if (index + 3 === path.length) {
+              optimizedPath[optimizedPath.length - 1].coordinates.push(midPoint, endPoint);
+            } else {
+              optimizedPath[optimizedPath.length - 1].coordinates.push(midPoint);
+            }
+            optimizedPath[optimizedPath.length - 1].maneuverType = currentManeuverType;
+          } else {
+            pathPoint.coordinates.push(startPoint, midPoint);
+            optimizedPath.push(pathPoint);
+
+            // If reached end of path then add a ContinueStraight segment at end of path
+            // Use index + 3 because last two points are skipped by loop
+            if (index + 3 === path.length) {
+              // if a ContinueStraight segment was just added then extend that, else add a new ContinueStraight segment at end
+              if (currentManeuverType === ManeuverType.ContinueStraight) {
+                optimizedPath[optimizedPath.length - 1].coordinates.push(endPoint);
               } else {
-                _pathPoint2 = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
+                optimizedPath.push({
+                  ...createDefaultSegment(pathSegment),
                   maneuverType: ManeuverType.ContinueStraight,
-                  coordinates: _path,
+                  coordinates: [midPoint, endPoint],
                   zone: currentZone
                 });
-                optimizedPath.push(_pathPoint2);
               }
-              removeExtraChangeZoneSegment = function removeExtraChangeZoneSegment() {
-                // When going from public to transit, hide the ChangeZone instruction, if the next step is PassThroughImmigration.
-                if (optimizedPath.length > 0) {
-                  var _lastSegmentAdded = optimizedPath[optimizedPath.length - 1];
-                  if (_lastSegmentAdded.maneuverType === ManeuverType.ChangeZone) {
-                    if (_lastSegmentAdded.zone === _interfaces.Zone.Transit) optimizedPath.pop();
+            }
+          }
+          lastManeuverType = currentManeuverType;
+        }
+      } else {
+        const pathPoint = {
+          ...createDefaultSegment(pathSegment),
+          maneuverType: ManeuverType.ContinueStraight,
+          coordinates: path,
+          zone: currentZone
+        };
+        optimizedPath.push(pathPoint);
+      }
+      const removeExtraChangeZoneSegment = () => {
+        // When going from public to transit, hide the ChangeZone instruction, if the next step is PassThroughImmigration.
+        if (optimizedPath.length > 0) {
+          const lastSegmentAdded = optimizedPath[optimizedPath.length - 1];
+          if (lastSegmentAdded.maneuverType === ManeuverType.ChangeZone) {
+            if (lastSegmentAdded.zone === _interfaces.Zone.Transit) optimizedPath.pop();
+          }
+        }
+      };
+      // Check if there are immigration crossings
+      let lastSegmentAdded = optimizedPath.length > 0 ? optimizedPath[optimizedPath.length - 1] : undefined;
+      if (lastSegmentAdded && lastSegmentAdded.maneuverType === ManeuverType.ContinueStraight) {
+        // Will add new segment, search for immigration crossings on the current non-vertical segment
+        const immigrationPolygonFeatures = (0, _mapObjectsHelper.getImmigrationPolygonFeaturesForWhereTaxonomy)(lastSegmentAdded.startEdge.whereDimension);
+        const line = (0, _helpers.lineString)(lastSegmentAdded.coordinates);
+        for (let index = 0; index < immigrationPolygonFeatures.length; index += 1) {
+          const immigrationPolygonFeature = immigrationPolygonFeatures[index];
+          if (!(0, _turf.booleanDisjoint)(line, immigrationPolygonFeature)) {
+            const intersects = (0, _turf.lineIntersect)(line, immigrationPolygonFeature);
+            if (intersects.features.length > 1) {
+              optimizedPath.pop();
+              const lineBeforeImmigration = (0, _turf.lineSlice)((0, _turf.getCoords)(line)[0], (0, _turf.getCoord)(intersects.features[0]), line);
+              const lengthOfLineBeforeImmigration = (0, _length.default)(lineBeforeImmigration, {
+                units: 'meters'
+              });
+              // Only add if length greater then min limit
+              if (lengthOfLineBeforeImmigration >= 10) {
+                const segmentBeforeImmigration = {
+                  ...createDefaultSegment(pathSegment),
+                  maneuverType: ManeuverType.ContinueStraight,
+                  zone: currentZone,
+                  coordinates: (0, _turf.getCoords)(lineBeforeImmigration)
+                };
+                optimizedPath.push(segmentBeforeImmigration);
+              } else if (optimizedPath.length > 0) {
+                lastSegmentAdded = optimizedPath[optimizedPath.length - 1];
+                // If lastSegmentAdded is a change zone segment then move both lastSegmentAdded and also the second last segment
+                if (lastSegmentAdded.maneuverType === ManeuverType.ChangeZone) {
+                  const coordsOfLastSegment = (0, _turf.getCoords)(lineBeforeImmigration);
+                  lastSegmentAdded.coordinates = [coordsOfLastSegment[coordsOfLastSegment.length - 1]];
+                  if (optimizedPath.length > 1) {
+                    const secondLastSegmentAdded = optimizedPath[optimizedPath.length - 2];
+                    secondLastSegmentAdded.coordinates = secondLastSegmentAdded.coordinates.concat((0, _turf.getCoords)(lineBeforeImmigration));
                   }
+                } else {
+                  lastSegmentAdded.coordinates.concat((0, _turf.getCoords)(lineBeforeImmigration));
                 }
-              }; // Check if there are immigration crossings
-              lastSegmentAdded = optimizedPath.length > 0 ? optimizedPath[optimizedPath.length - 1] : undefined;
-              if (lastSegmentAdded && lastSegmentAdded.maneuverType === ManeuverType.ContinueStraight) {
-                // Will add new segment, search for immigration crossings on the current non-vertical segment
-                immigrationPolygonFeatures = (0, _mapObjectsHelper.getImmigrationPolygonFeaturesForWhereTaxonomy)(lastSegmentAdded.startEdge.whereDimension);
-                line = (0, _helpers.lineString)(lastSegmentAdded.coordinates);
-                for (_index = 0; _index < immigrationPolygonFeatures.length; _index += 1) {
-                  immigrationPolygonFeature = immigrationPolygonFeatures[_index];
-                  if (!(0, _turf.booleanDisjoint)(line, immigrationPolygonFeature)) {
-                    intersects = (0, _turf.lineIntersect)(line, immigrationPolygonFeature);
-                    if (intersects.features.length > 1) {
-                      optimizedPath.pop();
-                      lineBeforeImmigration = (0, _turf.lineSlice)((0, _turf.getCoords)(line)[0], (0, _turf.getCoord)(intersects.features[0]), line);
-                      lengthOfLineBeforeImmigration = (0, _length["default"])(lineBeforeImmigration, {
-                        units: 'meters'
-                      }); // Only add if length greater then min limit
-                      if (lengthOfLineBeforeImmigration >= 10) {
-                        segmentBeforeImmigration = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                          maneuverType: ManeuverType.ContinueStraight,
-                          zone: currentZone,
-                          coordinates: (0, _turf.getCoords)(lineBeforeImmigration)
-                        });
-                        optimizedPath.push(segmentBeforeImmigration);
-                      } else if (optimizedPath.length > 0) {
-                        lastSegmentAdded = optimizedPath[optimizedPath.length - 1];
-                        // If lastSegmentAdded is a change zone segment then move both lastSegmentAdded and also the second last segment
-                        if (lastSegmentAdded.maneuverType === ManeuverType.ChangeZone) {
-                          coordsOfLastSegment = (0, _turf.getCoords)(lineBeforeImmigration);
-                          lastSegmentAdded.coordinates = [coordsOfLastSegment[coordsOfLastSegment.length - 1]];
-                          if (optimizedPath.length > 1) {
-                            secondLastSegmentAdded = optimizedPath[optimizedPath.length - 2];
-                            secondLastSegmentAdded.coordinates = secondLastSegmentAdded.coordinates.concat((0, _turf.getCoords)(lineBeforeImmigration));
-                          }
-                        } else {
-                          lastSegmentAdded.coordinates.concat((0, _turf.getCoords)(lineBeforeImmigration));
-                        }
-                      }
-                      immigrationLine = (0, _turf.lineSlice)((0, _turf.getCoord)(intersects.features[0]), (0, _turf.getCoord)(intersects.features[1]), line);
-                      immigrationSegment = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                        maneuverType: ManeuverType.PassThroughImmigration,
-                        zone: currentZone,
-                        coordinates: (0, _turf.getCoords)(immigrationLine)
-                      }); // The lineBeforeImmigration might not have been added due to length limit
-                      // And if lineBeforeImmigration was supposed to be the the first segment then prepend this segment with coordinates of lineBeforeImmigration
-                      if (optimizedPath.length === 0) {
-                        immigrationSegment.coordinates = lineBeforeImmigration.geometry.coordinates.concat(immigrationSegment.coordinates);
-                      }
+              }
+              const immigrationLine = (0, _turf.lineSlice)((0, _turf.getCoord)(intersects.features[0]), (0, _turf.getCoord)(intersects.features[1]), line);
+              const immigrationSegment = {
+                ...createDefaultSegment(pathSegment),
+                maneuverType: ManeuverType.PassThroughImmigration,
+                zone: currentZone,
+                coordinates: (0, _turf.getCoords)(immigrationLine)
+              };
+              // The lineBeforeImmigration might not have been added due to length limit
+              // And if lineBeforeImmigration was supposed to be the the first segment then prepend this segment with coordinates of lineBeforeImmigration
+              if (optimizedPath.length === 0) {
+                immigrationSegment.coordinates = lineBeforeImmigration.geometry.coordinates.concat(immigrationSegment.coordinates);
+              }
 
-                      // When going from public to transit, hide the ChangeZone instruction, if the next step is PassThroughImmigration.
-                      removeExtraChangeZoneSegment();
-                      optimizedPath.push(immigrationSegment);
-                      lineCoords = (0, _turf.getCoords)(line);
-                      lineAfterImmigration = (0, _turf.lineSlice)((0, _turf.getCoord)(intersects.features[1]), lineCoords[lineCoords.length - 1], line);
-                      segmentAfterImmigration = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                        maneuverType: ManeuverType.ContinueStraight,
-                        zone: currentZone,
-                        coordinates: (0, _turf.getCoords)(lineAfterImmigration)
-                      });
-                      optimizedPath.push(segmentAfterImmigration);
-                      // line = segmentAfterImmigration;
-                    } else if (intersects.features.length > 0) {
-                      // check if start point outside polygon then end inside polygon - valid
-                      startPointWithinPolygon = (0, _turf.booleanPointInPolygon)((0, _turf.getCoords)(line)[0], immigrationPolygonFeature);
-                      if (startPointWithinPolygon) {
-                        optimizedPath.pop();
+              // When going from public to transit, hide the ChangeZone instruction, if the next step is PassThroughImmigration.
+              removeExtraChangeZoneSegment();
+              optimizedPath.push(immigrationSegment);
+              const lineCoords = (0, _turf.getCoords)(line);
+              const lineAfterImmigration = (0, _turf.lineSlice)((0, _turf.getCoord)(intersects.features[1]), lineCoords[lineCoords.length - 1], line);
+              const segmentAfterImmigration = {
+                ...createDefaultSegment(pathSegment),
+                maneuverType: ManeuverType.ContinueStraight,
+                zone: currentZone,
+                coordinates: (0, _turf.getCoords)(lineAfterImmigration)
+              };
+              optimizedPath.push(segmentAfterImmigration);
+              // line = segmentAfterImmigration;
+            } else if (intersects.features.length > 0) {
+              // check if start point outside polygon then end inside polygon - valid
+              const startPointWithinPolygon = (0, _turf.booleanPointInPolygon)((0, _turf.getCoords)(line)[0], immigrationPolygonFeature);
+              if (startPointWithinPolygon) {
+                optimizedPath.pop();
 
-                        // One intersection point and start point is within polygon
-                        // Means line start inside and exits the polygon
-                        _immigrationLine = (0, _turf.lineSlice)((0, _turf.getCoords)(line)[0], (0, _turf.getCoord)(intersects.features[0]), line);
-                        _immigrationSegment = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                          maneuverType: ManeuverType.PassThroughImmigration,
-                          zone: currentZone,
-                          coordinates: (0, _turf.getCoords)(_immigrationLine)
-                        });
-                        lastSegmentAdded = optimizedPath.length > 0 ? optimizedPath[optimizedPath.length - 1] : undefined;
-                        if (lastSegmentAdded && lastSegmentAdded.maneuverType === ManeuverType.ChangeZone) {
-                          // Remove change zone segment
-                          changeZoneSegment = optimizedPath.pop();
-                          if (optimizedPath.length > 1) {
-                            _secondLastSegmentAdded = optimizedPath[optimizedPath.length - 1];
-                            if (_secondLastSegmentAdded.maneuverType === ManeuverType.PassThroughImmigration) {
-                              optimizedPath.pop();
+                // One intersection point and start point is within polygon
+                // Means line start inside and exits the polygon
+                const immigrationLine = (0, _turf.lineSlice)((0, _turf.getCoords)(line)[0], (0, _turf.getCoord)(intersects.features[0]), line);
+                const immigrationSegment = {
+                  ...createDefaultSegment(pathSegment),
+                  maneuverType: ManeuverType.PassThroughImmigration,
+                  zone: currentZone,
+                  coordinates: (0, _turf.getCoords)(immigrationLine)
+                };
+                lastSegmentAdded = optimizedPath.length > 0 ? optimizedPath[optimizedPath.length - 1] : undefined;
+                if (lastSegmentAdded && lastSegmentAdded.maneuverType === ManeuverType.ChangeZone) {
+                  // Remove change zone segment
+                  const changeZoneSegment = optimizedPath.pop();
+                  if (optimizedPath.length > 1) {
+                    const secondLastSegmentAdded = optimizedPath[optimizedPath.length - 1];
+                    if (secondLastSegmentAdded.maneuverType === ManeuverType.PassThroughImmigration) {
+                      optimizedPath.pop();
 
-                              // Re add the change zone segment with updated coordinates
-                              changeZoneSegment.coordinates = [_secondLastSegmentAdded.coordinates[0]];
-                              optimizedPath.push(changeZoneSegment);
-                              _immigrationSegment.coordinates = _secondLastSegmentAdded.coordinates.concat(_immigrationSegment.coordinates);
-                            }
-                          }
-                        }
-                        // When going from public to transit, hide the ChangeZone instruction, if the next step is PassThroughImmigration.
-                        removeExtraChangeZoneSegment();
-                        optimizedPath.push(_immigrationSegment);
-                        _lineCoords = (0, _turf.getCoords)(line);
-                        _lineAfterImmigration = (0, _turf.lineSlice)((0, _turf.getCoord)(intersects.features[0]), _lineCoords[_lineCoords.length - 1], line);
-                        _segmentAfterImmigration = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                          maneuverType: ManeuverType.ContinueStraight,
-                          zone: currentZone,
-                          coordinates: (0, _turf.getCoords)(_lineAfterImmigration)
-                        });
-                        optimizedPath.push(_segmentAfterImmigration);
-                      } else {
-                        // line starts outside immigration and ends inside immigration
-                        // this is not a valid case but lines are still divided into segments as the segments are used
-                        // by the logic under case 2(startPointWithinPolygon)
-                        previousLine = (0, _turf.lineSlice)((0, _turf.getCoords)(line)[0], (0, _turf.getCoord)(intersects.features[0]), line);
-                        lastSegmentAdded.coordinates = (0, _turf.getCoords)(previousLine);
-                        _lineCoords2 = (0, _turf.getCoords)(line);
-                        _lineAfterImmigration2 = (0, _turf.lineSlice)((0, _turf.getCoord)(intersects.features[0]), _lineCoords2[_lineCoords2.length - 1], line);
-                        _segmentAfterImmigration2 = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                          maneuverType: ManeuverType.PassThroughImmigration,
-                          zone: currentZone,
-                          coordinates: (0, _turf.getCoords)(_lineAfterImmigration2)
-                        });
-                        optimizedPath.push(_segmentAfterImmigration2);
-                        // line = segmentAfterImmigration;
-                      }
+                      // Re add the change zone segment with updated coordinates
+                      changeZoneSegment.coordinates = [secondLastSegmentAdded.coordinates[0]];
+                      optimizedPath.push(changeZoneSegment);
+                      immigrationSegment.coordinates = secondLastSegmentAdded.coordinates.concat(immigrationSegment.coordinates);
                     }
                   }
                 }
-              }
-            } else {
-              // Keep updating endSegment on each iteration
-              endSegment = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                maneuverType: ManeuverType.Static,
-                coordinates: [pathSegment.geojson.geometry.coordinates[1]],
-                zone: currentZone,
-                isPortal: false
-              });
-              enterPortalSegment = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                maneuverType: ManeuverType.EnterPortal,
-                coordinates: [pathSegment.geojson.geometry.coordinates[0]]
-              }); // // Only add this EnterPortal segment if previously same what dimension portal is not being continued
-              // // This is done to ensure Take Lift at A, Exit Lift at B, Take lift at B, Exit Lift at C is generated only as Take lift at A, Exit lift at C
-              // let lastSegmentAdded = (optimizedPath.length > 0) ? optimizedPath[optimizedPath.length - 1] : undefined;
-              // if (!lastSegmentAdded
-              // || (lastSegmentAdded && lastSegmentAdded.maneuverType !== ManeuverType.ExitPortal)
-              // || (lastSegmentAdded && lastSegmentAdded.maneuverType === ManeuverType.ExitPortal && lastSegmentAdded.startEdge.whatDimension !== enterPortalSegment.startEdge.whatDimension)) {
-              //   optimizedPath.push(enterPortalSegment);
-              //   lastSegmentAdded = enterPortalSegment;
-              // }
-              optimizedPath.push(enterPortalSegment);
-              exitPortalSegment = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                maneuverType: ManeuverType.ExitPortal,
-                coordinates: [pathSegment.geojson.geometry.coordinates[1]]
-              }); // // This logic is tied to the above similar logic for EnterPortal
-              // // Only add this ExitPortal segment if previously same what dimension portal is not being continued
-              // // This is done to ensure Take Lift at A, Exit Lift at B, Take lift at B, Exit Lift at C is generated only as Take lift at A, Exit lift at C
-              // if (lastSegmentAdded && lastSegmentAdded.maneuverType !== ManeuverType.ExitPortal) {
-              //   if (pathSegment.portalPath) {
-              //     const travelPortalSegment: RouteSegment = {
-              //       ...createDefaultSegment(pathSegment),
-              //       maneuverType: ManeuverType.TravelPortal,
-              //       coordinates: pathSegment.portalPath.geometry.coordinates,
-              //       zone: currentZone,
-              //     };
-              //     optimizedPath.push(travelPortalSegment);
-              //   }
-              //   optimizedPath.push(exitPortalSegment);
-              // } else
-              optimizedPath.push(exitPortalSegment);
-              _lastSegmentAdded2 = optimizedPath.length > 0 ? optimizedPath[optimizedPath.length - 1] : undefined;
-              if (_lastSegmentAdded2 && _lastSegmentAdded2.maneuverType === ManeuverType.ExitPortal) {
-                optimizedPath.pop();
-                if (pathSegment.portalPath) {
-                  travelPortalSegment = _objectSpread(_objectSpread({}, createDefaultSegment(pathSegment)), {}, {
-                    maneuverType: ManeuverType.TravelPortal,
-                    coordinates: pathSegment.portalPath.geometry.coordinates,
-                    zone: currentZone
-                  });
-                  optimizedPath.push(travelPortalSegment);
-                }
-                optimizedPath.push(exitPortalSegment);
+                // When going from public to transit, hide the ChangeZone instruction, if the next step is PassThroughImmigration.
+                removeExtraChangeZoneSegment();
+                optimizedPath.push(immigrationSegment);
+                const lineCoords = (0, _turf.getCoords)(line);
+                const lineAfterImmigration = (0, _turf.lineSlice)((0, _turf.getCoord)(intersects.features[0]), lineCoords[lineCoords.length - 1], line);
+                const segmentAfterImmigration = {
+                  ...createDefaultSegment(pathSegment),
+                  maneuverType: ManeuverType.ContinueStraight,
+                  zone: currentZone,
+                  coordinates: (0, _turf.getCoords)(lineAfterImmigration)
+                };
+                optimizedPath.push(segmentAfterImmigration);
+              } else {
+                // line starts outside immigration and ends inside immigration
+                // this is not a valid case but lines are still divided into segments as the segments are used
+                // by the logic under case 2(startPointWithinPolygon)
+                const previousLine = (0, _turf.lineSlice)((0, _turf.getCoords)(line)[0], (0, _turf.getCoord)(intersects.features[0]), line);
+                lastSegmentAdded.coordinates = (0, _turf.getCoords)(previousLine);
+                const lineCoords = (0, _turf.getCoords)(line);
+                const lineAfterImmigration = (0, _turf.lineSlice)((0, _turf.getCoord)(intersects.features[0]), lineCoords[lineCoords.length - 1], line);
+                const segmentAfterImmigration = {
+                  ...createDefaultSegment(pathSegment),
+                  maneuverType: ManeuverType.PassThroughImmigration,
+                  zone: currentZone,
+                  coordinates: (0, _turf.getCoords)(lineAfterImmigration)
+                };
+                optimizedPath.push(segmentAfterImmigration);
+                // line = segmentAfterImmigration;
               }
             }
           }
-          if (endSegment) optimizedPath.push(endSegment);
-          route = {
-            segments: optimizedPath,
-            walkingDistance: 0,
-            transportDistance: 0,
-            walkingTime: 0,
-            transportTime: 0,
-            distanceUnit: _interfaces.DISTANCE_UNIT,
-            speed: _interfaces.WALK_SPEED
-          }; // A patch denotes the segments which are directly connected to each other i.e. no portal in between, portal enter/exit can be part of the patch
-          if (route.segments.length > 0) {
-            addOverviewSegment = shouldAddOverviewSegment;
-            initialIndex = 0;
-            if (addOverviewSegment) {
-              // Dummy overview segment at start of route
-              dummySegment = (0, _lodash.cloneDeep)(route.segments[0]);
-              dummySegment.maneuverType = ManeuverType.RouteOverview;
-              route.segments.unshift(dummySegment);
-              initialIndex = 1; // Because overview segment will be at 0th index of route
-            }
+        }
+      }
+    } else {
+      // Keep updating endSegment on each iteration
+      endSegment = {
+        ...createDefaultSegment(pathSegment),
+        maneuverType: ManeuverType.Static,
+        coordinates: [pathSegment.geojson.geometry.coordinates[1]],
+        zone: currentZone,
+        isPortal: false
+      };
+      const enterPortalSegment = {
+        ...createDefaultSegment(pathSegment),
+        maneuverType: ManeuverType.EnterPortal,
+        coordinates: [pathSegment.geojson.geometry.coordinates[0]]
+      };
+      // // Only add this EnterPortal segment if previously same what dimension portal is not being continued
+      // // This is done to ensure Take Lift at A, Exit Lift at B, Take lift at B, Exit Lift at C is generated only as Take lift at A, Exit lift at C
+      // let lastSegmentAdded = (optimizedPath.length > 0) ? optimizedPath[optimizedPath.length - 1] : undefined;
+      // if (!lastSegmentAdded
+      // || (lastSegmentAdded && lastSegmentAdded.maneuverType !== ManeuverType.ExitPortal)
+      // || (lastSegmentAdded && lastSegmentAdded.maneuverType === ManeuverType.ExitPortal && lastSegmentAdded.startEdge.whatDimension !== enterPortalSegment.startEdge.whatDimension)) {
+      //   optimizedPath.push(enterPortalSegment);
+      //   lastSegmentAdded = enterPortalSegment;
+      // }
 
-            // A patch denotes the segments which are directly connected to each other i.e. no portal in between, portal enter/exit can be part of the patch
-            patchNumber = indexOffset + initialIndex;
-            whereDimension = route.segments.length > initialIndex ? route.segments[initialIndex].startEdge.whereDimension : '';
-            for (_index2 = initialIndex; _index2 < route.segments.length; _index2 += 1) {
-              highlight = false;
-              segment = route.segments[_index2];
-              segmentNumber = indexOffset + _index2;
-              if (!segment.isPortal) {
-                // point feature if ManeuverType.Static else line feature
-                if (segment.maneuverType === ManeuverType.Static || segment.maneuverType === ManeuverType.ChangeZone) {
-                  segment.features = getRouteNode(segment.coordinates[0], segmentNumber, highlight, patchNumber, segment.endEdge.whereDimension);
-                  segment.patchNumber = patchNumber;
-                  segment.whereDimension = whereDimension;
-                } else {
-                  segment.features = getRouteLine(segment.coordinates, segmentNumber, highlight, patchNumber, segment.zone, segment.startEdge.whereDimension);
-                  segment.patchNumber = patchNumber;
-                  segment.whereDimension = whereDimension;
-                }
-                routeSegmentCoords = segment.coordinates;
-                segmentDistance = void 0;
-                if (routeSegmentCoords.length > 1) {
-                  segmentDistance = (0, _length["default"])((0, _helpers.lineString)(routeSegmentCoords), {
-                    units: route.distanceUnit
-                  });
-                } else {
-                  segmentDistance = 0;
-                }
-                segment.distance = segmentDistance;
-                if (segment.maneuverType !== ManeuverType.PassThroughImmigration) {
-                  segment.time = segment.distance / route.speed;
-                } else {
-                  segment.time = 0;
-                }
-              } else {
-                // if (
-                //   segment.maneuverType !== ManeuverType.EnterPortal
-                //   && segment.maneuverType !== ManeuverType.ExitPortal
-                // ) {
-                //   console.warn('unexpected state in createRoute');
-                // }
+      optimizedPath.push(enterPortalSegment);
+      const exitPortalSegment = {
+        ...createDefaultSegment(pathSegment),
+        maneuverType: ManeuverType.ExitPortal,
+        coordinates: [pathSegment.geojson.geometry.coordinates[1]]
+      };
+      // // This logic is tied to the above similar logic for EnterPortal
+      // // Only add this ExitPortal segment if previously same what dimension portal is not being continued
+      // // This is done to ensure Take Lift at A, Exit Lift at B, Take lift at B, Exit Lift at C is generated only as Take lift at A, Exit lift at C
+      // if (lastSegmentAdded && lastSegmentAdded.maneuverType !== ManeuverType.ExitPortal) {
+      //   if (pathSegment.portalPath) {
+      //     const travelPortalSegment: RouteSegment = {
+      //       ...createDefaultSegment(pathSegment),
+      //       maneuverType: ManeuverType.TravelPortal,
+      //       coordinates: pathSegment.portalPath.geometry.coordinates,
+      //       zone: currentZone,
+      //     };
+      //     optimizedPath.push(travelPortalSegment);
+      //   }
 
-                if (segment.maneuverType === ManeuverType.EnterPortal) {
-                  startEdgeFeatures = getRouteNode(segment.coordinates[0], segmentNumber, highlight, patchNumber, segment.startEdge.whereDimension);
-                  features = []; // eslint-disable-next-line no-restricted-syntax
-                  _iterator = _createForOfIteratorHelper(startEdgeFeatures);
-                  try {
-                    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                      feature = _step.value;
-                      features.push(feature);
-                    }
-                  } catch (err) {
-                    _iterator.e(err);
-                  } finally {
-                    _iterator.f();
-                  }
-                  segment.features = features;
-                  segment.patchNumber = patchNumber;
-                  segment.whereDimension = whereDimension;
+      //   optimizedPath.push(exitPortalSegment);
+      // } else
+      optimizedPath.push(exitPortalSegment);
+      const lastSegmentAdded = optimizedPath.length > 0 ? optimizedPath[optimizedPath.length - 1] : undefined;
+      if (lastSegmentAdded && lastSegmentAdded.maneuverType === ManeuverType.ExitPortal) {
+        optimizedPath.pop();
+        if (pathSegment.portalPath) {
+          const travelPortalSegment = {
+            ...createDefaultSegment(pathSegment),
+            maneuverType: ManeuverType.TravelPortal,
+            coordinates: pathSegment.portalPath.geometry.coordinates,
+            zone: currentZone
+          };
+          optimizedPath.push(travelPortalSegment);
+        }
+        optimizedPath.push(exitPortalSegment);
+      }
+    }
+  }
+  if (endSegment) optimizedPath.push(endSegment);
+  const route = {
+    segments: optimizedPath,
+    walkingDistance: 0,
+    transportDistance: 0,
+    walkingTime: 0,
+    transportTime: 0,
+    distanceUnit: _interfaces.DISTANCE_UNIT,
+    speed: _interfaces.WALK_SPEED
+  };
 
-                  // read next segment, if next segment is TravelPortal then do not include time of this enter portal segment
-                  _nextRouteSegment = route.segments.length >= _index2 + 2 ? route.segments[_index2 + 1] : undefined;
-                  if (_nextRouteSegment && _nextRouteSegment.maneuverType !== ManeuverType.TravelPortal) {
-                    portalCost = segment.cost;
-                    segment.time = portalCost || 0;
-                  } else {
-                    segment.time = 0;
-                  }
-                  segment.distance = 0;
-                }
-                if (segment.maneuverType === ManeuverType.TravelPortal) {
-                  segment.features = getRouteLine(segment.coordinates, segmentNumber, highlight, patchNumber, segment.zone, segment.startEdge.whereDimension);
-                  segment.patchNumber = patchNumber;
-                  segment.whereDimension = whereDimension;
-                  _portalCost = segment.cost;
-                  segment.time = _portalCost || 0;
-                  _segmentDistance = void 0;
-                  if (segment.coordinates.length > 1) {
-                    _segmentDistance = (0, _length["default"])((0, _helpers.lineString)(segment.coordinates), {
-                      units: route.distanceUnit
-                    });
-                  } else {
-                    _segmentDistance = 0;
-                  }
-                  segment.distance = _segmentDistance;
+  // A patch denotes the segments which are directly connected to each other i.e. no portal in between, portal enter/exit can be part of the patch
+  if (route.segments.length > 0) {
+    const addOverviewSegment = shouldAddOverviewSegment;
+    let initialIndex = 0;
+    if (addOverviewSegment) {
+      // Dummy overview segment at start of route
+      const dummySegment = (0, _lodash.cloneDeep)(route.segments[0]);
+      dummySegment.maneuverType = ManeuverType.RouteOverview;
+      route.segments.unshift(dummySegment);
+      initialIndex = 1; // Because overview segment will be at 0th index of route
+    }
 
-                  // Set time of previous enter portal instruction to zero, so that time in not shown in UI
-                  if (_index2 > 0) route.segments[_index2 - 1].time = 0;
-                }
-                if (segment.maneuverType === ManeuverType.ExitPortal) {
-                  // increment patch number to next value
-                  patchNumber += 1;
-                  whereDimension = segment.endEdge.whereDimension;
+    // A patch denotes the segments which are directly connected to each other i.e. no portal in between, portal enter/exit can be part of the patch
+    let patchNumber = indexOffset + initialIndex;
+    let whereDimension = route.segments.length > initialIndex ? route.segments[initialIndex].startEdge.whereDimension : '';
+    for (let index = initialIndex; index < route.segments.length; index += 1) {
+      const highlight = false;
+      const segment = route.segments[index];
+      const segmentNumber = indexOffset + index;
+      if (!segment.isPortal) {
+        // point feature if ManeuverType.Static else line feature
+        if (segment.maneuverType === ManeuverType.Static || segment.maneuverType === ManeuverType.ChangeZone) {
+          segment.features = getRouteNode(segment.coordinates[0], segmentNumber, highlight, patchNumber, segment.endEdge.whereDimension);
+          segment.patchNumber = patchNumber;
+          segment.whereDimension = whereDimension;
+        } else {
+          segment.features = getRouteLine(segment.coordinates, segmentNumber, highlight, patchNumber, segment.zone, segment.startEdge.whereDimension);
+          segment.patchNumber = patchNumber;
+          segment.whereDimension = whereDimension;
+        }
+        const routeSegmentCoords = segment.coordinates;
+        let segmentDistance;
+        if (routeSegmentCoords.length > 1) {
+          segmentDistance = (0, _length.default)((0, _helpers.lineString)(routeSegmentCoords), {
+            units: route.distanceUnit
+          });
+        } else {
+          segmentDistance = 0;
+        }
+        segment.distance = segmentDistance;
+        if (segment.maneuverType !== ManeuverType.PassThroughImmigration) {
+          segment.time = segment.distance / route.speed;
+        } else {
+          segment.time = 0;
+        }
+      } else {
+        // if (
+        //   segment.maneuverType !== ManeuverType.EnterPortal
+        //   && segment.maneuverType !== ManeuverType.ExitPortal
+        // ) {
+        //   console.warn('unexpected state in createRoute');
+        // }
 
-                  // Remove ExitPortal segment from route, because its only used to calculate patch information since ATOMS-207
-                  route.segments.splice(_index2, 1);
-                  _index2 -= 1;
-                }
+        if (segment.maneuverType === ManeuverType.EnterPortal) {
+          const startEdgeFeatures = getRouteNode(segment.coordinates[0], segmentNumber, highlight, patchNumber, segment.startEdge.whereDimension);
+          const features = [];
+          // eslint-disable-next-line no-restricted-syntax
+          for (const feature of startEdgeFeatures) {
+            features.push(feature);
+          }
+          segment.features = features;
+          segment.patchNumber = patchNumber;
+          segment.whereDimension = whereDimension;
 
-                // read next segment
-                nextRouteSegment = route.segments.length >= _index2 + 2 ? route.segments[_index2 + 1] : undefined;
-                if (nextRouteSegment && nextRouteSegment.maneuverType === ManeuverType.TravelPortal) {
-                  patchNumber += 1;
-                }
-              }
-              if (segment.maneuverType === ManeuverType.TravelPortal) {
-                route.transportDistance += segment.distance;
-                route.transportTime += segment.time;
-              } else {
-                route.walkingDistance += segment.distance;
-                route.walkingTime += segment.time;
-              }
-            }
-            if (addOverviewSegment) {
-              // Generate and add actual overview segment
-              overviewSegment = generateOverviewSegment(route, indexOffset);
-              route.segments[0] = overviewSegment;
-            }
+          // read next segment, if next segment is TravelPortal then do not include time of this enter portal segment
+          const nextRouteSegment = route.segments.length >= index + 2 ? route.segments[index + 1] : undefined;
+          if (nextRouteSegment && nextRouteSegment.maneuverType !== ManeuverType.TravelPortal) {
+            const portalCost = segment.cost;
+            segment.time = portalCost || 0;
+          } else {
+            segment.time = 0;
+          }
+          segment.distance = 0;
+        }
+        if (segment.maneuverType === ManeuverType.TravelPortal) {
+          segment.features = getRouteLine(segment.coordinates, segmentNumber, highlight, patchNumber, segment.zone, segment.startEdge.whereDimension);
+          segment.patchNumber = patchNumber;
+          segment.whereDimension = whereDimension;
+          const portalCost = segment.cost;
+          segment.time = portalCost || 0;
+          let segmentDistance;
+          if (segment.coordinates.length > 1) {
+            segmentDistance = (0, _length.default)((0, _helpers.lineString)(segment.coordinates), {
+              units: route.distanceUnit
+            });
+          } else {
+            segmentDistance = 0;
           }
-          return _context.a(2, route);
+          segment.distance = segmentDistance;
+
+          // Set time of previous enter portal instruction to zero, so that time in not shown in UI
+          if (index > 0) route.segments[index - 1].time = 0;
+        }
+        if (segment.maneuverType === ManeuverType.ExitPortal) {
+          // increment patch number to next value
+          patchNumber += 1;
+          whereDimension = segment.endEdge.whereDimension;
+
+          // Remove ExitPortal segment from route, because its only used to calculate patch information since ATOMS-207
+          route.segments.splice(index, 1);
+          index -= 1;
+        }
+
+        // read next segment
+        const nextRouteSegment = route.segments.length >= index + 2 ? route.segments[index + 1] : undefined;
+        if (nextRouteSegment && nextRouteSegment.maneuverType === ManeuverType.TravelPortal) {
+          patchNumber += 1;
+        }
+      }
+      if (segment.maneuverType === ManeuverType.TravelPortal) {
+        route.transportDistance += segment.distance;
+        route.transportTime += segment.time;
+      } else {
+        route.walkingDistance += segment.distance;
+        route.walkingTime += segment.time;
       }
-    }, _callee);
-  }));
-  return _createRoute.apply(this, arguments);
+    }
+    if (addOverviewSegment) {
+      // Generate and add actual overview segment
+      const overviewSegment = generateOverviewSegment(route, indexOffset);
+      route.segments[0] = overviewSegment;
+    }
+  }
+  return route;
 }
 function getPatch(route) {
-  var patchNumber = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  var routefeatures = [];
-  for (var index = 0; index < route.segments.length; index += 1) {
-    var routeSegment = route.segments[index];
+  let patchNumber = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  let routefeatures = [];
+  for (let index = 0; index < route.segments.length; index += 1) {
+    const routeSegment = route.segments[index];
     if (routeSegment.patchNumber === patchNumber) {
       routefeatures = routefeatures.concat(routeSegment.features);
     }
@@ -765,18 +692,17 @@ function getPatch(route) {
   return routefeatures;
 }
 function getFeaturesForPatch(route, patchNumber, overviewSegmentInfo) {
-  var routefeatures = [];
-  for (var index = 0; index < route.segments.length; index += 1) {
-    var routeSegment = route.segments[index];
+  let routefeatures = [];
+  for (let index = 0; index < route.segments.length; index += 1) {
+    const routeSegment = route.segments[index];
     if (overviewSegmentInfo.includeOverviewFeatures) {
       // Return all features in default case
       if (isOverviewSegment(routeSegment)) {
-        var nonHighlightedOverviewFeatures = [];
-        var highlightedOverviewFeatures = [];
-        for (var j = 0; j < routeSegment.features.length; j++) {
-          var _feature$properties;
-          var feature = routeSegment.features[j];
-          if (((_feature$properties = feature.properties) === null || _feature$properties === void 0 ? void 0 : _feature$properties.patchNumber) !== undefined && feature.properties.patchNumber === overviewSegmentInfo.patchNumberForOverviewFeatures) {
+        const nonHighlightedOverviewFeatures = [];
+        const highlightedOverviewFeatures = [];
+        for (let j = 0; j < routeSegment.features.length; j++) {
+          const feature = routeSegment.features[j];
+          if (feature.properties?.patchNumber !== undefined && feature.properties.patchNumber === overviewSegmentInfo.patchNumberForOverviewFeatures) {
             if (feature.properties.isNonHighlightedOverview !== undefined) {
               if (feature.properties.isNonHighlightedOverview === '1') {
                 nonHighlightedOverviewFeatures.push(feature);
@@ -788,7 +714,7 @@ function getFeaturesForPatch(route, patchNumber, overviewSegmentInfo) {
         }
         // Sort the features such that non hihglighted features come first in the array
         // because on map they should be sorted below highlighted features in z dimension
-        var overviewSegmentFeatures = nonHighlightedOverviewFeatures.concat(highlightedOverviewFeatures);
+        const overviewSegmentFeatures = nonHighlightedOverviewFeatures.concat(highlightedOverviewFeatures);
         routefeatures = routefeatures.concat(overviewSegmentFeatures);
       }
     } else if (routeSegment.patchNumber === patchNumber) {
@@ -845,12 +771,12 @@ function getPortalName(whatDimension) {
   }
 }
 function getTerminalAndLevelName(whereDimension) {
-  var regex = /^(T\d+|JEWEL)([A-Za-z]\d+[A-Za-z]?)$/;
-  var subDimension = whereDimension.split('.').slice(-2).join('').toUpperCase();
-  var match = subDimension.match(regex);
+  const regex = /^(T\d+|JEWEL)([A-Za-z]\d+[A-Za-z]?)$/;
+  const subDimension = whereDimension.split('.').slice(-2).join('').toUpperCase();
+  const match = subDimension.match(regex);
   if (match) {
-    var terminalIndicator = match[1][0];
-    var terminalName;
+    const terminalIndicator = match[1][0];
+    let terminalName;
     switch (terminalIndicator) {
       case 'T':
         terminalName = 'Terminal';
@@ -862,9 +788,9 @@ function getTerminalAndLevelName(whereDimension) {
         terminalName = 'Level';
         break;
     }
-    var terminal = terminalName === 'Terminal' ? "".concat(terminalName, " ").concat(match[1][1]) : "".concat(terminalName);
-    var levelIdentifier = match[2][0];
-    var levelName;
+    const terminal = terminalName === 'Terminal' ? `${terminalName} ${match[1][1]}` : `${terminalName}`;
+    const levelIdentifier = match[2][0];
+    let levelName;
     switch (levelIdentifier) {
       case 'L':
         levelName = 'Level';
@@ -876,7 +802,7 @@ function getTerminalAndLevelName(whereDimension) {
         levelName = 'Level';
         break;
     }
-    var level = "".concat(levelName, " ").concat(match[2].substring(1));
+    const level = `${levelName} ${match[2].substring(1)}`;
     return {
       Terminal: terminal,
       Level: level
@@ -885,7 +811,7 @@ function getTerminalAndLevelName(whereDimension) {
   return null; // Return null if the input doesn't match the expected format
 }
 function getWhereDimensionNameForPortal(portalDimension, whereDimension) {
-  var terminalAndLevelName = getTerminalAndLevelName(whereDimension);
+  const terminalAndLevelName = getTerminalAndLevelName(whereDimension);
   if (terminalAndLevelName) {
     if (isCrossTerminalPortal(portalDimension)) {
       return terminalAndLevelName.Terminal;
@@ -901,10 +827,10 @@ function getWhereDimensionNameForPortal(portalDimension, whereDimension) {
 }
 function convertSecondsToMinutes(timeInSeconds) {
   // Calculate minutes
-  var minutes = Math.floor(timeInSeconds / 60);
+  let minutes = Math.floor(timeInSeconds / 60);
 
   // Check for remaining seconds
-  var remainingSeconds = timeInSeconds % 60;
+  const remainingSeconds = timeInSeconds % 60;
 
   // If there are remaining seconds and they are greater than 30, increment minutes
   if (remainingSeconds > 30) {
@@ -914,37 +840,37 @@ function convertSecondsToMinutes(timeInSeconds) {
 }
 function formatTime(value) {
   if (value < 60) return '<1 minute';
-  return "~".concat(convertSecondsToMinutes(value), " ").concat(convertSecondsToMinutes(value) > 1 ? 'minutes' : 'minute');
+  return `~${convertSecondsToMinutes(value)} ${convertSecondsToMinutes(value) > 1 ? 'minutes' : 'minute'}`;
 }
 function generateInstructions(route) {
-  var isFirstSegment = function isFirstSegment(index) {
+  const isFirstSegment = index => {
     if (index === 0 || index === 1 && route.segments[index - 1].maneuverType === ManeuverType.RouteOverview) return true;
     return false;
   };
-  var getImmigrationInstruction = function getImmigrationInstruction(segment) {
+  const getImmigrationInstruction = segment => {
     if (segment.startEdge.whereDimension.toLowerCase().includes('l1')) {
       return 'Clear Arrival Immigration';
     }
     return 'Clear Departure Immigration';
   };
-  for (var index = 0; index < route.segments.length; index += 1) {
-    var rotueSegment = route.segments[index];
+  for (let index = 0; index < route.segments.length; index += 1) {
+    const rotueSegment = route.segments[index];
     rotueSegment.instructions = []; // clear instructions array
 
     if (rotueSegment.maneuverType === ManeuverType.RouteOverview) {
-      var instruction = 'Overview';
+      const instruction = 'Overview';
       rotueSegment.instructions.push(instruction);
     }
     if (index > 0 && rotueSegment.maneuverType === ManeuverType.ChangeZone) {
-      var _instruction = '';
+      let instruction = '';
       if (route.segments[index - 1].zone === _interfaces.Zone.Public && rotueSegment.zone === _interfaces.Zone.Transit) {
-        _instruction = getImmigrationInstruction(rotueSegment);
+        instruction = getImmigrationInstruction(rotueSegment);
       } else if (route.segments[index - 1].zone === _interfaces.Zone.Transit && rotueSegment.zone === _interfaces.Zone.Public) {
-        _instruction = 'Exit Baggage Claim Hall';
+        instruction = 'Exit Baggage Claim Hall';
       }
-      rotueSegment.instructions.push(_instruction);
+      rotueSegment.instructions.push(instruction);
     } else if (rotueSegment.maneuverType === ManeuverType.ContinueStraight || rotueSegment.maneuverType === ManeuverType.PassThroughImmigration) {
-      var postfix = rotueSegment.maneuverType === ManeuverType.ContinueStraight ? "Walk for ".concat(Math.ceil(rotueSegment.distance), " ").concat(route.distanceUnit) : getImmigrationInstruction(rotueSegment);
+      const postfix = rotueSegment.maneuverType === ManeuverType.ContinueStraight ? `Walk for ${Math.ceil(rotueSegment.distance)} ${route.distanceUnit}` : getImmigrationInstruction(rotueSegment);
 
       // 0th index if overview segment was not included, else 1st index
       // if (index === 0
@@ -957,9 +883,9 @@ function generateInstructions(route) {
       //     } \n& ${postfix}`,
       //   );
       // } else {
-      var _instruction2 = void 0;
+      let instruction;
       if (route.segments[index - 1].maneuverType === ManeuverType.ChangeZone || route.segments[index - 1].maneuverType === ManeuverType.PassThroughImmigration) {
-        _instruction2 = postfix;
+        instruction = postfix;
         // eslint-disable-next-line brace-style
       }
       // else if (route.segments[index - 1].maneuverType === ManeuverType.EnterPortal || route.segments[index - 1].maneuverType === ManeuverType.TravelPortal) {
@@ -994,36 +920,36 @@ function generateInstructions(route) {
       //   // }
       // }
       else {
-        _instruction2 = postfix;
+        instruction = postfix;
       }
-      rotueSegment.instructions.push(_instruction2);
+      rotueSegment.instructions.push(instruction);
       // }
     } else if (rotueSegment.maneuverType === ManeuverType.Static) {
       if (isFirstSegment(index)) {
-        rotueSegment.instructions.push("Start at ".concat(rotueSegment.startEdge.name));
+        rotueSegment.instructions.push(`Start at ${rotueSegment.startEdge.name}`);
       }
       if (index === route.segments.length - 1) {
-        rotueSegment.instructions.push("Arrive at ".concat(rotueSegment.endEdge.name));
+        rotueSegment.instructions.push(`Arrive at ${rotueSegment.endEdge.name}`);
       }
     } else if (rotueSegment.maneuverType === ManeuverType.EnterPortal) {
-      var _instruction3 = "Enter ".concat(rotueSegment.startEdge.name, " at ").concat(rotueSegment.startEdge.whereDimension.split('.').slice(-2).join(' ').toUpperCase());
+      let instruction = `Enter ${rotueSegment.startEdge.name} at ${rotueSegment.startEdge.whereDimension.split('.').slice(-2).join(' ').toUpperCase()}`;
       if (isNonMovingPortalTaxonomy(rotueSegment.startEdge.whatDimension)) {
-        _instruction3 = "Continue to ".concat(getWhereDimensionNameForPortal(rotueSegment.startEdge.whatDimension, rotueSegment.endEdge.whereDimension));
-        rotueSegment.instructions.push(_instruction3);
+        instruction = `Continue to ${getWhereDimensionNameForPortal(rotueSegment.startEdge.whatDimension, rotueSegment.endEdge.whereDimension)}`;
+        rotueSegment.instructions.push(instruction);
       } else if (isMovingPortalTaxonomy(rotueSegment.startEdge.whatDimension)) {
-        var nextRouteSegment = index + 1 <= route.segments.length - 1 ? route.segments[index + 1] : undefined;
+        const nextRouteSegment = index + 1 <= route.segments.length - 1 ? route.segments[index + 1] : undefined;
         if (nextRouteSegment && nextRouteSegment.maneuverType === ManeuverType.TravelPortal) {
           // push the current enter portal instruction and increment index, since we want to skip the iteration on TravelPortal segment
-          rotueSegment.instructions.push(_instruction3);
+          rotueSegment.instructions.push(instruction);
           index += 1;
-          var name = getPortalName(nextRouteSegment.startEdge.whatDimension);
-          _instruction3 = "Take ".concat(name, " to ").concat(getWhereDimensionNameForPortal(rotueSegment.startEdge.whatDimension, rotueSegment.endEdge.whereDimension));
-          nextRouteSegment.instructions.push(_instruction3);
+          const name = getPortalName(nextRouteSegment.startEdge.whatDimension);
+          instruction = `Take ${name} to ${getWhereDimensionNameForPortal(rotueSegment.startEdge.whatDimension, rotueSegment.endEdge.whereDimension)}`;
+          nextRouteSegment.instructions.push(instruction);
           if (rotueSegment.description) nextRouteSegment.instructions.push(rotueSegment.description);
         } else {
-          var _name = getPortalName(rotueSegment.startEdge.whatDimension);
-          _instruction3 = "Take ".concat(_name, " to ").concat(getWhereDimensionNameForPortal(rotueSegment.startEdge.whatDimension, rotueSegment.endEdge.whereDimension));
-          rotueSegment.instructions.push(_instruction3);
+          const name = getPortalName(rotueSegment.startEdge.whatDimension);
+          instruction = `Take ${name} to ${getWhereDimensionNameForPortal(rotueSegment.startEdge.whatDimension, rotueSegment.endEdge.whereDimension)}`;
+          rotueSegment.instructions.push(instruction);
         }
       }
     }