venue-js 1.4.0-next.17 → 1.4.0-next.19

package/dist/data/index.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,6 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/data/index.ts
@@ -312,8 +322,8 @@ var safeFetchFeature = async (featureType, params) => {
 };
 
 // src/data/utils/geometry-validator.ts
-var isValidCoordinate = (point) => {
-  return point.length === 2 && point.every((coord) => typeof coord === "number");
+var isValidCoordinate = (point2) => {
+  return point2.length === 2 && point2.every((coord) => typeof coord === "number");
 };
 function isValidLinearRingCoordinates(ring) {
   if (ring.length < 4) {
@@ -321,16 +331,16 @@ function isValidLinearRingCoordinates(ring) {
   }
   return ring.every(isValidCoordinate) && ring[0][0] === ring[ring.length - 1][0] && ring[0][1] === ring[ring.length - 1][1];
 }
-var isValidPolygonCoordinates = (polygon) => {
-  if (Array.isArray(polygon[0]) && (polygon[0].length === 0 || typeof polygon[0][0] === "number")) {
-    return isValidLinearRingCoordinates(polygon);
+var isValidPolygonCoordinates = (polygon2) => {
+  if (Array.isArray(polygon2[0]) && (polygon2[0].length === 0 || typeof polygon2[0][0] === "number")) {
+    return isValidLinearRingCoordinates(polygon2);
   }
-  if (Array.isArray(polygon) && polygon.length > 0 && Array.isArray(polygon[0])) {
-    if (!isValidLinearRingCoordinates(polygon[0])) {
+  if (Array.isArray(polygon2) && polygon2.length > 0 && Array.isArray(polygon2[0])) {
+    if (!isValidLinearRingCoordinates(polygon2[0])) {
       return false;
     }
-    for (let i = 1; i < polygon.length; i++) {
-      if (!isValidLinearRingCoordinates(polygon[i])) {
+    for (let i = 1; i < polygon2.length; i++) {
+      if (!isValidLinearRingCoordinates(polygon2[i])) {
         return false;
       }
     }
@@ -341,16 +351,16 @@ var isValidPolygonCoordinates = (polygon) => {
 var isValidMultiPolygonCoordinates = (multipolygon) => {
   return multipolygon.every(isValidPolygonCoordinates);
 };
-var isValidLineStringCoordinates = (lineString) => {
-  if (!Array.isArray(lineString) || lineString.length < 2) {
+var isValidLineStringCoordinates = (lineString2) => {
+  if (!Array.isArray(lineString2) || lineString2.length < 2) {
     return false;
   }
-  const firstPoint = lineString[0];
-  const lastPoint = lineString[lineString.length - 1];
+  const firstPoint = lineString2[0];
+  const lastPoint = lineString2[lineString2.length - 1];
   if (firstPoint[0] === lastPoint[0] && firstPoint[1] === lastPoint[1]) {
     return false;
   }
-  return lineString.every(isValidCoordinate);
+  return lineString2.every(isValidCoordinate);
 };
 var isValidMultiPolygon = (geometry) => {
   const { type, coordinates } = geometry;
@@ -447,6 +457,19 @@ var findContainingUnit = (poi, units) => {
   );
   return unit;
 };
+var findContainingUnitAtPoint = (point2, levelId, units) => {
+  const unit = units.find(
+    (unit2) => {
+      try {
+        return unit2.properties.level_id === levelId && (0, import_boolean_point_in_polygon.booleanPointInPolygon)(point2, unit2);
+      } catch (e) {
+        console.log(`Cannot find containing unit of (point: ${point2}, levelId: ${levelId}):`, e.message);
+        return false;
+      }
+    }
+  );
+  return unit;
+};
 
 // src/data/populator/index.ts
 var createPopulator = ({
@@ -619,6 +642,19 @@ var createPopulator = ({
       }
     };
   };
+  const populateSection = async (section) => {
+    const venue = await internalFindById(section.properties.venue_id);
+    const level = await internalFindById(section.properties.level_id);
+    return {
+      ...section,
+      properties: {
+        ...section.properties,
+        venue,
+        level: await populateLevel(level),
+        ordinal: level.properties.ordinal
+      }
+    };
+  };
   const populateRelationship = async (relationship) => {
     const originId = relationship.properties.origin?.id;
     const destinationId = relationship.properties.destination?.id;
@@ -636,19 +672,6 @@ var createPopulator = ({
       }
     };
   };
-  const populateSection = async (section) => {
-    const venue = await internalFindById(section.properties.venue_id);
-    const level = await internalFindById(section.properties.level_id);
-    return {
-      ...section,
-      properties: {
-        ...section.properties,
-        venue,
-        level: await populateLevel(level),
-        ordinal: level.properties.ordinal
-      }
-    };
-  };
   const populateUnit = async (unit) => {
     const venue = await internalFindById(unit.properties.venue_id);
     const level = await internalFindById(unit.properties.level_id);
@@ -696,7 +719,7 @@ var createPopulator = ({
       console.log(`error finding level`, { model3d, level });
     }
   };
-  const populateFeature = (feature) => Promise.resolve(feature);
+  const populateFeature = (feature2) => Promise.resolve(feature2);
   return {
     address: populateAddress,
     building: populateBuilding,
@@ -725,1366 +748,1642 @@ var createPopulator = ({
   };
 };
 
-// ../../node_modules/fuse.js/dist/fuse.mjs
-function isArray(value) {
-  return !Array.isArray ? getTag(value) === "[object Array]" : Array.isArray(value);
-}
-var INFINITY = 1 / 0;
-function baseToString(value) {
-  if (typeof value == "string") {
-    return value;
-  }
-  let result = value + "";
-  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
-}
-function toString(value) {
-  return value == null ? "" : baseToString(value);
-}
-function isString(value) {
-  return typeof value === "string";
-}
-function isNumber(value) {
-  return typeof value === "number";
-}
-function isBoolean(value) {
-  return value === true || value === false || isObjectLike(value) && getTag(value) == "[object Boolean]";
-}
-function isObject(value) {
-  return typeof value === "object";
-}
-function isObjectLike(value) {
-  return isObject(value) && value !== null;
-}
-function isDefined(value) {
-  return value !== void 0 && value !== null;
-}
-function isBlank(value) {
-  return !value.trim().length;
-}
-function getTag(value) {
-  return value == null ? value === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(value);
-}
-var INCORRECT_INDEX_TYPE = "Incorrect 'index' type";
-var LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) => `Invalid value for key ${key}`;
-var PATTERN_LENGTH_TOO_LARGE = (max) => `Pattern length exceeds max of ${max}.`;
-var MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;
-var INVALID_KEY_WEIGHT_VALUE = (key) => `Property 'weight' in key '${key}' must be a positive integer`;
-var hasOwn = Object.prototype.hasOwnProperty;
-var KeyStore = class {
-  constructor(keys) {
-    this._keys = [];
-    this._keyMap = {};
-    let totalWeight = 0;
-    keys.forEach((key) => {
-      let obj = createKey(key);
-      this._keys.push(obj);
-      this._keyMap[obj.id] = obj;
-      totalWeight += obj.weight;
-    });
-    this._keys.forEach((key) => {
-      key.weight /= totalWeight;
-    });
-  }
-  get(keyId) {
-    return this._keyMap[keyId];
-  }
-  keys() {
-    return this._keys;
-  }
-  toJSON() {
-    return JSON.stringify(this._keys);
+// src/data/search/getSearchClient.ts
+var import_fuse = __toESM(require("fuse.js"));
+
+// src/data/search/utils/sanitizeInput.ts
+var sanitizeInput = (str) => str.replace(/[\u200E\u200F\u202A-\u202E\u2066-\u2069]/g, "").replace(/[\-–—_./()]+/g, "").normalize("NFC").trim();
+
+// src/data/search/getSearchClient.ts
+var getSearchClient = ({ occupants, amenities }) => {
+  const fuseAmenities = new import_fuse.default(amenities, {
+    threshold: 0.2,
+    keys: [
+      { name: "properties.name", "weight": 1, getFn: (obj) => Object.values(obj.properties.name || {}) },
+      { name: "properties.category", "weight": 1 }
+    ]
+  });
+  const fuseOccupants = new import_fuse.default(occupants, {
+    threshold: 0.25,
+    // 0.2 is too strict (can't find Mo-Mo Paradise with "momo" search string)
+    includeScore: true,
+    shouldSort: true,
+    keys: [
+      { name: "properties.name", "weight": 4, getFn: (obj) => Object.values(obj.properties.name || {}) },
+      { name: "properties.keywords", "weight": 0.5 },
+      { name: "properties.category", "weight": 0.25 },
+      { name: "properties.local_category_names", "weight": 0.25 },
+      { name: "properties.description", "weight": 0.25, getFn: (occ) => Object.values(occ.properties.description || {}) },
+      { name: "properties.unit_name", "weight": 0.25 },
+      { name: "properties.kiosk_name", "weight": 0.25 }
+    ]
+  });
+  const search = (value) => {
+    const sanitizedValue = sanitizeInput(value);
+    const matchedAmenities = fuseAmenities.search(sanitizedValue);
+    const matchedOccupants = fuseOccupants.search(sanitizedValue);
+    return [...matchedAmenities, ...matchedOccupants];
+  };
+  return {
+    search
+  };
+};
+
+// src/data/navigate/getNavigateClient.ts
+var import_boolean_point_in_polygon4 = require("@turf/boolean-point-in-polygon");
+
+// src/data/navigate/graph/prepare.ts
+var import_lodash10 = __toESM(require("lodash"));
+var import_node_dijkstra = __toESM(require("node-dijkstra"));
+var import_distance3 = require("@turf/distance");
+var import_center5 = require("@turf/center");
+
+// src/data/navigate/graph/nodemap/createTraversalNodeMap.ts
+var import_distance = require("@turf/distance");
+var import_center3 = require("@turf/center");
+var import_lodash3 = __toESM(require("lodash"));
+
+// src/data/navigate/graph/constants.ts
+var ROOM_BASEDISTANCE = 1e3;
+var TERRACE_BASEDISTANCE = 1e3;
+var ESCALATOR_BASEDISTANCE = 200;
+var RAMP_BASEDISTANCE = 200;
+var ELEVATOR_BASEDISTANCE = 500;
+var STAIR_BASEDISTANCE = 1e5;
+var BASE_POI_BASEDISTANCE = 9999999;
+var DEFAULT_UNIT_BASEDISTANCE_OPTIONS = {
+  default: { baseDistance: 0 },
+  byCategory: {
+    room: { baseDistance: ROOM_BASEDISTANCE },
+    terrace: { baseDistance: TERRACE_BASEDISTANCE },
+    escalator: { baseDistance: ESCALATOR_BASEDISTANCE, scaleDistanceByLevel: false },
+    ramp: { baseDistance: RAMP_BASEDISTANCE, scaleDistanceByLevel: false },
+    elevator: { baseDistance: ELEVATOR_BASEDISTANCE, scaleDistanceByLevel: false },
+    stairs: {
+      baseDistance: STAIR_BASEDISTANCE,
+      scaleDistanceByLevel: true
+    },
+    "stairs.emergencyexit": {
+      baseDistance: STAIR_BASEDISTANCE,
+      scaleDistanceByLevel: true
+    }
   }
 };
-function createKey(key) {
-  let path = null;
-  let id = null;
-  let src = null;
-  let weight = 1;
-  let getFn = null;
-  if (isString(key) || isArray(key)) {
-    src = key;
-    path = createKeyPath(key);
-    id = createKeyId(key);
-  } else {
-    if (!hasOwn.call(key, "name")) {
-      throw new Error(MISSING_KEY_PROPERTY("name"));
+
+// src/data/navigate/graph/utils/getDistanceOption.ts
+var getDistanceOptions = (options, category) => {
+  if (!options) return DEFAULT_UNIT_BASEDISTANCE_OPTIONS.byCategory[category];
+  return (category && options.byCategory?.[category]) ?? DEFAULT_UNIT_BASEDISTANCE_OPTIONS.byCategory[category] ?? options?.default ?? DEFAULT_UNIT_BASEDISTANCE_OPTIONS.default;
+};
+
+// src/data/utils/trace.ts
+var trace = (namespace, text, ms, color) => {
+  console.log(`[${namespace}] %c${text.padEnd(90)}   ${ms !== void 0 ? `${ms.toFixed(1).padStart(6)} ms` : ``}`, color ? `color: ${color}` : void 0);
+};
+
+// src/data/navigate/graph/nodemap/createTraversalNodeMap.ts
+var createTraversalNodeMap = (unitOpenings, options) => {
+  const { units } = options.data;
+  let counter = 0;
+  const calculateFeatureDistanceWithinUnit = (features, distanceOptions) => {
+    let relationshipGraph = {};
+    for (let currentIndex = 0; currentIndex < features.length; currentIndex++) {
+      const isLastItem = currentIndex + 1 === features.length;
+      if (isLastItem) break;
+      for (let j = currentIndex + 1; j < features.length; j++) {
+        const opening = features[currentIndex];
+        const feature2 = features[j];
+        try {
+          const distance5 = (0, import_distance.distance)(
+            (0, import_center3.center)(opening.geometry),
+            (0, import_center3.center)(feature2.geometry),
+            { units: "meters" }
+          ) + (distanceOptions?.baseDistance ?? 0);
+          if (opening.id === feature2.id) continue;
+          import_lodash3.default.set(relationshipGraph, `${opening.id}.${feature2.id}`, distance5);
+          import_lodash3.default.set(relationshipGraph, `${feature2.id}.${opening.id}`, distance5);
+          counter++;
+        } catch (error) {
+          continue;
+        }
+      }
     }
-    const name = key.name;
-    src = name;
-    if (hasOwn.call(key, "weight")) {
-      weight = key.weight;
-      if (weight <= 0) {
-        throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
+    return relationshipGraph;
+  };
+  const t0 = performance.now();
+  const nodeMap = import_lodash3.default.reduce(
+    unitOpenings,
+    (acc, openings, unitId) => {
+      const unit = units.find((unit2) => unit2.id === unitId);
+      const unitDistanceOption = getDistanceOptions(options.unitDistanceOptions, unit.properties.category);
+      return import_lodash3.default.merge(
+        acc,
+        calculateFeatureDistanceWithinUnit(openings, unitDistanceOption)
+      );
+    },
+    {}
+  );
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} traversal relationships`, t1 - t0);
+  return nodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createElevatorNodeMap.ts
+var import_lodash4 = __toESM(require("lodash"));
+var createElevatorNodeMap = (elevatorLikeRelationships, unitOpenings, options) => {
+  const t0 = performance.now();
+  const { levels, units } = options.data;
+  const distanceOptions = getDistanceOptions(options.unitDistanceOptions, "elevator");
+  const {
+    baseDistance = ELEVATOR_BASEDISTANCE,
+    scaleDistanceByLevel = false
+  } = distanceOptions;
+  let elevatorNodeMap = {};
+  let counter = 0;
+  for (const relationship of elevatorLikeRelationships) {
+    try {
+      const {
+        origin: originTypeAndId,
+        intermediary,
+        destination: destinationTypeAndId
+      } = relationship.properties;
+      const origin = units.find((unit) => unit.id === originTypeAndId.id);
+      if (!origin) return;
+      const originOpenings = compact(unitOpenings[origin.id]);
+      const originLevel = levels.find((level) => level.id === origin.properties.level_id);
+      const destination = units.find((unit) => unit.id === destinationTypeAndId.id);
+      const destinationOpenings = unitOpenings[destination.id];
+      const destinationOpeningAndLevels = destinationOpenings.map((opening) => {
+        const level = levels.find((level2) => level2.id === destination.properties.level_id);
+        return { opening, level };
+      });
+      const intermediaryOpeningAndLevels = intermediary.map((unitTypeAndId) => {
+        const openings = unitOpenings[unitTypeAndId.id];
+        const unit = units.find((unit2) => unit2.id === unitTypeAndId.id);
+        const level = levels.find((level2) => level2.id === unit.properties.level_id);
+        return openings.map((opening) => ({ opening, level }));
+      }).flat();
+      const connections = compact([...intermediaryOpeningAndLevels, ...destinationOpeningAndLevels]);
+      if (!originOpenings || originOpenings.length === 0) return;
+      for (const originOpening of originOpenings) {
+        for (const connection of connections) {
+          const { opening, level } = connection;
+          let distance5 = baseDistance;
+          if (scaleDistanceByLevel) {
+            const originOrdinal = originLevel.properties.ordinal;
+            const connectionOrdinal = level.properties.ordinal;
+            const levelDifference = Math.abs(originOrdinal - connectionOrdinal);
+            if (levelDifference > 0) distance5 *= levelDifference;
+          }
+          import_lodash4.default.set(elevatorNodeMap, `${originOpening.id}.${opening.id}`, distance5);
+          import_lodash4.default.set(elevatorNodeMap, `${opening.id}.${originOpening.id}`, distance5);
+          counter++;
+        }
       }
+    } catch (err) {
+      console.log(err);
+      console.log("cannot create elevatorNodeMap for ", { relationship });
     }
-    path = createKeyPath(name);
-    id = createKeyId(name);
-    getFn = key.getFn;
   }
-  return { path, id, weight, src, getFn };
-}
-function createKeyPath(key) {
-  return isArray(key) ? key : key.split(".");
-}
-function createKeyId(key) {
-  return isArray(key) ? key.join(".") : key;
-}
-function get(obj, path) {
-  let list = [];
-  let arr = false;
-  const deepGet = (obj2, path2, index) => {
-    if (!isDefined(obj2)) {
-      return;
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} escalator relationships`, t1 - t0);
+  return elevatorNodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createEscalatorNodeMap.ts
+var import_set = __toESM(require("lodash/set"));
+var createEscalatorNodeMap = (relationships, options) => {
+  const t0 = performance.now();
+  const distanceOptions = getDistanceOptions(options.unitDistanceOptions, "escalator");
+  let counter = 0;
+  let nodeMap = {};
+  for (const relationship of relationships) {
+    const {
+      properties: { direction, origin, destination }
+    } = relationship;
+    (0, import_set.default)(nodeMap, `${origin.id}.${destination.id}`, distanceOptions.baseDistance);
+    if (direction === "undirected") {
+      (0, import_set.default)(nodeMap, `${destination.id}.${origin.id}`, distanceOptions.baseDistance);
     }
-    if (!path2[index]) {
-      list.push(obj2);
-    } else {
-      let key = path2[index];
-      const value = obj2[key];
-      if (!isDefined(value)) {
-        return;
-      }
-      if (index === path2.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {
-        list.push(toString(value));
-      } else if (isArray(value)) {
-        arr = true;
-        for (let i = 0, len = value.length; i < len; i += 1) {
-          deepGet(value[i], path2, index + 1);
+    counter++;
+  }
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} escalator relationships`, t1 - t0);
+  return nodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createRampNodeMap.ts
+var import_set2 = __toESM(require("lodash/set"));
+var createRampNodeMap = (relationships, options) => {
+  const t0 = performance.now();
+  const distanceOptions = getDistanceOptions(options.unitDistanceOptions, "ramp");
+  let counter = 0;
+  let nodeMap = {};
+  relationships.forEach((relationship) => {
+    const {
+      properties: { origin, destination }
+    } = relationship;
+    (0, import_set2.default)(nodeMap, `${origin.id}.${destination.id}`, distanceOptions.baseDistance);
+    (0, import_set2.default)(nodeMap, `${destination.id}.${origin.id}`, distanceOptions.baseDistance);
+    counter++;
+  });
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} ramp relationships`, t1 - t0);
+  return nodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createStairNodeMap.ts
+var import_lodash6 = __toESM(require("lodash"));
+var createStairNodeMap = (elevatorLikeRelationships, unitOpenings, options) => {
+  const t0 = performance.now();
+  const { levels = [], openings = [], units = [] } = options.data;
+  const { baseDistance, scaleDistanceByLevel } = getDistanceOptions(options.unitDistanceOptions, "stairs");
+  let elevatorNodeMap = {};
+  let counter = 0;
+  for (const relationship of elevatorLikeRelationships) {
+    try {
+      const {
+        origin: { id: originId },
+        intermediary,
+        destination: { id: destinationId }
+      } = relationship.properties;
+      const origin = openings.find((opening) => opening.id === originId);
+      if (!origin) return;
+      const originLevel = levels.find((level) => level.id === origin.properties.level_id);
+      const destination = openings.find((opening) => opening.id === destinationId);
+      const destinationOpeningAndLevel = {
+        opening: destination,
+        level: levels.find((level) => level.id === destination.properties.level_id)
+      };
+      const intermediaryOpeningAndLevels = intermediary.map((unitTypeAndId) => {
+        const openings2 = unitOpenings[unitTypeAndId.id];
+        const unit = units.find((unit2) => unit2.id === unitTypeAndId.id);
+        const level = levels.find((level2) => level2.id === unit.properties.level_id);
+        return openings2.map((opening) => ({ opening, level }));
+      }).flat();
+      const connections = [...intermediaryOpeningAndLevels, destinationOpeningAndLevel];
+      if (!origin) return;
+      for (const connection of connections) {
+        const { opening, level } = connection;
+        let distance5 = baseDistance;
+        if (scaleDistanceByLevel) {
+          const originOrdinal = originLevel.properties.ordinal;
+          const connectionOrdinal = level.properties.ordinal;
+          const levelDifference = Math.abs(originOrdinal - connectionOrdinal);
+          if (levelDifference > 0) distance5 *= levelDifference;
         }
-      } else if (path2.length) {
-        deepGet(value, path2, index + 1);
+        import_lodash6.default.set(elevatorNodeMap, `${origin.id}.${opening.id}`, distance5);
+        import_lodash6.default.set(elevatorNodeMap, `${opening.id}.${origin.id}`, distance5);
+        counter++;
       }
+    } catch (err) {
+      console.warn(
+        "Failed to create stairNodeMap",
+        {
+          relationshipId: relationship.id,
+          featureType: relationship.feature_type,
+          error: err instanceof Error ? err.message : err,
+          stack: err instanceof Error ? err.stack : void 0
+        }
+      );
     }
-  };
-  deepGet(obj, isString(path) ? path.split(".") : path, 0);
-  return arr ? list : list[0];
-}
-var MatchOptions = {
-  // Whether the matches should be included in the result set. When `true`, each record in the result
-  // set will include the indices of the matched characters.
-  // These can consequently be used for highlighting purposes.
-  includeMatches: false,
-  // When `true`, the matching function will continue to the end of a search pattern even if
-  // a perfect match has already been located in the string.
-  findAllMatches: false,
-  // Minimum number of characters that must be matched before a result is considered a match
-  minMatchCharLength: 1
+  }
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} stairs relationships`, t1 - t0);
+  return elevatorNodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createOccupantNodeMap.ts
+var import_lodash7 = __toESM(require("lodash"));
+var createOccupantNodeMap = (occupants) => {
+  const t0 = performance.now();
+  let nodeMap = {};
+  let counter = 0;
+  occupants.forEach((occupant) => {
+    const { unit_id, unit_ids = [], kiosk_id, kiosk_ids = [] } = occupant.properties;
+    const occupantRoomIds = compact([unit_id, ...unit_ids]);
+    const occupantKioskIds = compact([kiosk_id, ...kiosk_ids]);
+    for (const roomId of occupantRoomIds) {
+      import_lodash7.default.set(nodeMap, `${roomId}.${occupant.id}`, 1e-3);
+      import_lodash7.default.set(nodeMap, `${occupant.id}.${roomId}`, 1e-3);
+      counter++;
+    }
+    for (const kioskId of occupantKioskIds) {
+      import_lodash7.default.set(nodeMap, `${kioskId}.${occupant.id}`, 1e-3);
+      import_lodash7.default.set(nodeMap, `${occupant.id}.${kioskId}`, 1e-3);
+      counter++;
+    }
+  });
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} occupants relationships`, t1 - t0);
+  return nodeMap;
 };
-var BasicOptions = {
-  // When `true`, the algorithm continues searching to the end of the input even if a perfect
-  // match is found before the end of the same input.
-  isCaseSensitive: false,
-  // When `true`, the algorithm will ignore diacritics (accents) in comparisons
-  ignoreDiacritics: false,
-  // When true, the matching function will continue to the end of a search pattern even if
-  includeScore: false,
-  // List of properties that will be searched. This also supports nested properties.
-  keys: [],
-  // Whether to sort the result list, by score
-  shouldSort: true,
-  // Default sort function: sort by ascending score, ascending index
-  sortFn: (a, b) => a.score === b.score ? a.idx < b.idx ? -1 : 1 : a.score < b.score ? -1 : 1
+
+// src/data/navigate/graph/nodemap/createPOINodeMaps.ts
+var import_center4 = require("@turf/center");
+var import_distance2 = require("@turf/distance");
+var import_lodash9 = __toESM(require("lodash"));
+var createPOINodeMap = (features, getFeatureUnit, unitOpenings) => {
+  const t0 = performance.now();
+  let nodeMap = {};
+  let counter = 0;
+  features.forEach((feat) => {
+    try {
+      const locatedOnUnitId = getFeatureUnit(feat);
+      const openings = unitOpenings[locatedOnUnitId];
+      const center7 = (0, import_center4.center)(feat);
+      for (const opening of openings) {
+        try {
+          const openingCenter = (0, import_center4.center)(opening);
+          const dis = (0, import_distance2.distance)(center7, openingCenter, { units: "meters" }) + BASE_POI_BASEDISTANCE;
+          import_lodash9.default.set(nodeMap, `${opening.id}.${feat.id}`, dis);
+          import_lodash9.default.set(nodeMap, `${feat.id}.${opening.id}`, dis);
+          counter++;
+        } catch (err) {
+          console.log(err, opening);
+        }
+      }
+    } catch (err) {
+      console.log(err);
+      console.log(`cannot connect poi to openings`, err.message, { feat });
+    }
+  });
+  const type = features.length > 0 ? features[0].feature_type : "-";
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} ${type} relationships`, t1 - t0);
+  return nodeMap;
 };
-var FuzzyOptions = {
-  // Approximately where in the text is the pattern expected to be found?
-  location: 0,
-  // At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match
-  // (of both letters and location), a threshold of '1.0' would match anything.
-  threshold: 0.6,
-  // Determines how close the match must be to the fuzzy location (specified above).
-  // An exact letter match which is 'distance' characters away from the fuzzy location
-  // would score as a complete mismatch. A distance of '0' requires the match be at
-  // the exact location specified, a threshold of '1000' would require a perfect match
-  // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.
-  distance: 100
+
+// src/data/navigate/graph/utils/mergeNodeMap.ts
+var mergeNodeMap = (nodeMaps) => {
+  const out = {};
+  for (const nodeMap of nodeMaps) {
+    for (const from in nodeMap) {
+      out[from] = {
+        ...out[from] ?? {},
+        ...nodeMap[from]
+      };
+    }
+  }
+  return out;
 };
-var AdvancedOptions = {
-  // When `true`, it enables the use of unix-like search commands
-  useExtendedSearch: false,
-  // The get function to use when fetching an object's properties.
-  // The default will search nested paths *ie foo.bar.baz*
-  getFn: get,
-  // When `true`, search will ignore `location` and `distance`, so it won't matter
-  // where in the string the pattern appears.
-  // More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score
-  ignoreLocation: false,
-  // When `true`, the calculation for the relevance score (used for sorting) will
-  // ignore the field-length norm.
-  // More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm
-  ignoreFieldNorm: false,
-  // The weight to determine how much field length norm effects scoring.
-  fieldNormWeight: 1
+
+// src/data/navigate/graph/utils/createUnitOpenings.ts
+var import_uniqBy = __toESM(require("lodash/uniqBy"));
+var createUnitOpenings = (relationships, units, openings) => {
+  const openingConnections = {};
+  const relationshipMap = /* @__PURE__ */ new Map();
+  relationships.forEach((relationship) => {
+    const originId = relationship.properties.origin?.id || null;
+    const destinationId = relationship.properties.destination?.id || null;
+    if (!relationshipMap.has(originId)) {
+      relationshipMap.set(originId, []);
+    }
+    if (!relationshipMap.has(destinationId)) {
+      relationshipMap.set(destinationId, []);
+    }
+    relationshipMap.get(originId).push(relationship);
+    relationshipMap.get(destinationId).push(relationship);
+  });
+  units.forEach((unit) => {
+    const unitId = unit.id;
+    const connectedRelationshop = relationshipMap.get(unitId) || [];
+    const relationshipIntermediaryTypeAndId = connectedRelationshop.map(
+      (relationship) => relationship.properties.intermediary[0]
+      // Assuming intermediary is always an array
+    );
+    const relationshipIntermediary = relationshipIntermediaryTypeAndId.map(({ id }) => {
+      return openings.find((opening) => opening.id === id);
+    });
+    openingConnections[unitId] = (0, import_uniqBy.default)(
+      [...openingConnections[unitId] || [], ...relationshipIntermediary],
+      "id"
+    );
+  });
+  return openingConnections;
 };
-var Config = {
-  ...BasicOptions,
-  ...MatchOptions,
-  ...FuzzyOptions,
-  ...AdvancedOptions
+
+// src/data/navigate/parsers.ts
+var parseOrdinalCoordinate = (id) => {
+  return id.slice(0, -1).split(",").map(Number);
 };
-var SPACE = /[^ ]+/g;
-function norm(weight = 1, mantissa = 3) {
-  const cache = /* @__PURE__ */ new Map();
-  const m = Math.pow(10, mantissa);
-  return {
-    get(value) {
-      const numTokens = value.match(SPACE).length;
-      if (cache.has(numTokens)) {
-        return cache.get(numTokens);
+
+// src/data/navigate/graph/prepare.ts
+var prepareGraph = (options) => {
+  const {
+    data: {
+      amenities = [],
+      anchors = [],
+      occupants = [],
+      relationships = [],
+      openings = [],
+      units = [],
+      kiosks = [],
+      levels = []
+    }
+  } = options;
+  const {
+    traversal: traversalRelationships = [],
+    escalator: escalatorRelationships = [],
+    ramp: rampRelationships = [],
+    elevator: elevatorRelationships = [],
+    stairs: stairsRelationships = []
+  } = import_lodash10.default.groupBy(relationships, "properties.category");
+  const unitOpenings = createUnitOpenings(traversalRelationships, units, openings);
+  const traversalNodeMap = createTraversalNodeMap(unitOpenings, options);
+  const escalatorNodeMap = createEscalatorNodeMap(escalatorRelationships, options);
+  const rampNodeMap = createRampNodeMap(rampRelationships, options);
+  const elevatorNodeMap = createElevatorNodeMap(
+    elevatorRelationships,
+    unitOpenings,
+    options
+  );
+  const stairNodeMap = createStairNodeMap(
+    stairsRelationships,
+    unitOpenings,
+    options
+  );
+  const amenityNodeMap = createPOINodeMap(amenities, (amenity) => amenity.properties.unit_ids[0], unitOpenings);
+  const anchorsNodeMap = createPOINodeMap(anchors, (anchor) => anchor.properties.unit_id, unitOpenings);
+  const walkwayUnits = units.filter((unit) => unit.properties.category === "walkway");
+  const kioskNodeMap = createPOINodeMap(kiosks, (kiosk) => findContainingUnit(kiosk, walkwayUnits)?.id, unitOpenings);
+  const unitNodeMap = createPOINodeMap(units, (unit) => unit.id, unitOpenings);
+  const occupantNodeMap = createOccupantNodeMap(occupants);
+  const defaultGraph = new import_node_dijkstra.default(mergeNodeMap([
+    traversalNodeMap,
+    escalatorNodeMap,
+    rampNodeMap,
+    elevatorNodeMap,
+    stairNodeMap,
+    amenityNodeMap,
+    anchorsNodeMap,
+    kioskNodeMap,
+    unitNodeMap,
+    occupantNodeMap
+  ]));
+  const accessibleGraph = new import_node_dijkstra.default(mergeNodeMap([
+    traversalNodeMap,
+    rampNodeMap,
+    elevatorNodeMap,
+    amenityNodeMap,
+    anchorsNodeMap,
+    kioskNodeMap,
+    unitNodeMap,
+    occupantNodeMap
+  ]));
+  const addCoordinateOrdinalNode = (params, locatedOnUnit) => {
+    const [lat, lng, ordinal] = parseOrdinalCoordinate(params);
+    if (locatedOnUnit) {
+      const openings2 = unitOpenings[locatedOnUnit.id];
+      for (const opening of openings2) {
+        const openingCenter = (0, import_center5.center)(opening);
+        const dis = (0, import_distance3.distance)([lat, lng], openingCenter, { units: "meters" });
+        defaultGraph.addNode(params, { [opening.id]: dis }).addNode(opening.id, { [params]: dis });
+        accessibleGraph.addNode(params, { [opening.id]: dis }).addNode(opening.id, { [params]: dis });
       }
-      const norm2 = 1 / Math.pow(numTokens, 0.5 * weight);
-      const n = parseFloat(Math.round(norm2 * m) / m);
-      cache.set(numTokens, n);
-      return n;
-    },
-    clear() {
-      cache.clear();
     }
   };
+  return { defaultGraph, accessibleGraph, unitOpenings, addCoordinateOrdinalNode };
+};
+
+// src/data/navigate/steps/createStepUtils.ts
+var import_lodash12 = require("lodash");
+var import_intersectionBy = __toESM(require("lodash/intersectionBy"));
+var import_center9 = require("@turf/center");
+
+// src/data/navigate/description/describe.ts
+var t = (template, locale, options) => {
+  return template.replace(`{{intermediary}}`, options.intermediary ?? "").replace(`{{toward}}`, options.toward?.[locale] ?? "").replace(`{{landmark}}`, options.landmark?.[locale] ?? "");
+};
+var describeVerticalStep = (fromLevel, toLevel, intermediary) => {
+  const dir = fromLevel.properties.ordinal < toLevel.properties.ordinal ? "up" : "down";
+  const template = `Take the {{intermediary}} ${dir} to {{toward}}`;
+  return {
+    template,
+    text: t(template, "en", { intermediary, toward: toLevel.properties.name })
+  };
+};
+var describeHorizontalStep = (intermediary, toward, landmark) => {
+  const template = `Follow the path ${intermediary === "walkway" ? `along the walkway` : `through {{intermediary}}`} ${toward ? `toward {{toward}}` : ``} ${landmark ? `near {{landmark}}` : ``}`.trim();
+  return {
+    text: t(template, "en", { intermediary, toward, landmark }),
+    template
+  };
+};
+
+// src/data/navigate/steps/path/index.ts
+var import_lodash11 = __toESM(require("lodash"));
+
+// src/data/navigate/constants.ts
+var OBSTACLE_FEATURE_TYPES = [
+  "kiosk"
+  /* , "fixture" */
+];
+var OBSTACLE_CATEGORIES = [
+  "fixture.water",
+  "fixture.stage",
+  "nonpublic",
+  "opentobelow",
+  "elevator",
+  "escalator",
+  "stairs",
+  "stairs.emergencyexit",
+  "room",
+  "unspecified",
+  "structure",
+  "brick",
+  "concrete",
+  "drywall",
+  "glass",
+  "wood",
+  "column"
+];
+var WALKABLE_CATEGORY = [
+  "walkway",
+  "parking",
+  "room",
+  "terrace",
+  "unenclosedarea",
+  "vegetation",
+  "unspecified"
+];
+
+// node_modules/@turf/helpers/dist/esm/index.js
+var earthRadius = 63710088e-1;
+var factors = {
+  centimeters: earthRadius * 100,
+  centimetres: earthRadius * 100,
+  degrees: 360 / (2 * Math.PI),
+  feet: earthRadius * 3.28084,
+  inches: earthRadius * 39.37,
+  kilometers: earthRadius / 1e3,
+  kilometres: earthRadius / 1e3,
+  meters: earthRadius,
+  metres: earthRadius,
+  miles: earthRadius / 1609.344,
+  millimeters: earthRadius * 1e3,
+  millimetres: earthRadius * 1e3,
+  nauticalmiles: earthRadius / 1852,
+  radians: 1,
+  yards: earthRadius * 1.0936
+};
+function feature(geom, properties, options = {}) {
+  const feat = { type: "Feature" };
+  if (options.id === 0 || options.id) {
+    feat.id = options.id;
+  }
+  if (options.bbox) {
+    feat.bbox = options.bbox;
+  }
+  feat.properties = properties || {};
+  feat.geometry = geom;
+  return feat;
 }
-var FuseIndex = class {
-  constructor({
-    getFn = Config.getFn,
-    fieldNormWeight = Config.fieldNormWeight
-  } = {}) {
-    this.norm = norm(fieldNormWeight, 3);
-    this.getFn = getFn;
-    this.isCreated = false;
-    this.setIndexRecords();
+function point(coordinates, properties, options = {}) {
+  if (!coordinates) {
+    throw new Error("coordinates is required");
   }
-  setSources(docs = []) {
-    this.docs = docs;
+  if (!Array.isArray(coordinates)) {
+    throw new Error("coordinates must be an Array");
   }
-  setIndexRecords(records = []) {
-    this.records = records;
+  if (coordinates.length < 2) {
+    throw new Error("coordinates must be at least 2 numbers long");
   }
-  setKeys(keys = []) {
-    this.keys = keys;
-    this._keysMap = {};
-    keys.forEach((key, idx) => {
-      this._keysMap[key.id] = idx;
-    });
+  if (!isNumber(coordinates[0]) || !isNumber(coordinates[1])) {
+    throw new Error("coordinates must contain numbers");
   }
-  create() {
-    if (this.isCreated || !this.docs.length) {
-      return;
+  const geom = {
+    type: "Point",
+    coordinates
+  };
+  return feature(geom, properties, options);
+}
+function polygon(coordinates, properties, options = {}) {
+  for (const ring of coordinates) {
+    if (ring.length < 4) {
+      throw new Error(
+        "Each LinearRing of a Polygon must have 4 or more Positions."
+      );
     }
-    this.isCreated = true;
-    if (isString(this.docs[0])) {
-      this.docs.forEach((doc, docIndex) => {
-        this._addString(doc, docIndex);
-      });
-    } else {
-      this.docs.forEach((doc, docIndex) => {
-        this._addObject(doc, docIndex);
-      });
+    if (ring[ring.length - 1].length !== ring[0].length) {
+      throw new Error("First and last Position are not equivalent.");
     }
-    this.norm.clear();
-  }
-  // Adds a doc to the end of the index
-  add(doc) {
-    const idx = this.size();
-    if (isString(doc)) {
-      this._addString(doc, idx);
-    } else {
-      this._addObject(doc, idx);
+    for (let j = 0; j < ring[ring.length - 1].length; j++) {
+      if (ring[ring.length - 1][j] !== ring[0][j]) {
+        throw new Error("First and last Position are not equivalent.");
+      }
     }
   }
-  // Removes the doc at the specified index of the index
-  removeAt(idx) {
-    this.records.splice(idx, 1);
-    for (let i = idx, len = this.size(); i < len; i += 1) {
-      this.records[i].i -= 1;
-    }
+  const geom = {
+    type: "Polygon",
+    coordinates
+  };
+  return feature(geom, properties, options);
+}
+function lineString(coordinates, properties, options = {}) {
+  if (coordinates.length < 2) {
+    throw new Error("coordinates must be an array of two or more positions");
   }
-  getValueForItemAtKeyId(item, keyId) {
-    return item[this._keysMap[keyId]];
+  const geom = {
+    type: "LineString",
+    coordinates
+  };
+  return feature(geom, properties, options);
+}
+function featureCollection(features, options = {}) {
+  const fc = { type: "FeatureCollection" };
+  if (options.id) {
+    fc.id = options.id;
   }
-  size() {
-    return this.records.length;
+  if (options.bbox) {
+    fc.bbox = options.bbox;
   }
-  _addString(doc, docIndex) {
-    if (!isDefined(doc) || isBlank(doc)) {
-      return;
+  fc.features = features;
+  return fc;
+}
+function isNumber(num) {
+  return !isNaN(num) && num !== null && !Array.isArray(num);
+}
+function isObject(input) {
+  return input !== null && typeof input === "object" && !Array.isArray(input);
+}
+
+// node_modules/@turf/invariant/dist/esm/index.js
+function getCoord(coord) {
+  if (!coord) {
+    throw new Error("coord is required");
+  }
+  if (!Array.isArray(coord)) {
+    if (coord.type === "Feature" && coord.geometry !== null && coord.geometry.type === "Point") {
+      return [...coord.geometry.coordinates];
+    }
+    if (coord.type === "Point") {
+      return [...coord.coordinates];
     }
-    let record = {
-      v: doc,
-      i: docIndex,
-      n: this.norm.get(doc)
-    };
-    this.records.push(record);
-  }
-  _addObject(doc, docIndex) {
-    let record = { i: docIndex, $: {} };
-    this.keys.forEach((key, keyIndex) => {
-      let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);
-      if (!isDefined(value)) {
-        return;
-      }
-      if (isArray(value)) {
-        let subRecords = [];
-        const stack = [{ nestedArrIndex: -1, value }];
-        while (stack.length) {
-          const { nestedArrIndex, value: value2 } = stack.pop();
-          if (!isDefined(value2)) {
-            continue;
-          }
-          if (isString(value2) && !isBlank(value2)) {
-            let subRecord = {
-              v: value2,
-              i: nestedArrIndex,
-              n: this.norm.get(value2)
-            };
-            subRecords.push(subRecord);
-          } else if (isArray(value2)) {
-            value2.forEach((item, k) => {
-              stack.push({
-                nestedArrIndex: k,
-                value: item
-              });
-            });
-          } else ;
-        }
-        record.$[keyIndex] = subRecords;
-      } else if (isString(value) && !isBlank(value)) {
-        let subRecord = {
-          v: value,
-          n: this.norm.get(value)
-        };
-        record.$[keyIndex] = subRecord;
-      }
-    });
-    this.records.push(record);
   }
-  toJSON() {
-    return {
-      keys: this.keys,
-      records: this.records
-    };
+  if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
+    return [...coord];
   }
-};
-function createIndex(keys, docs, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
-  const myIndex = new FuseIndex({ getFn, fieldNormWeight });
-  myIndex.setKeys(keys.map(createKey));
-  myIndex.setSources(docs);
-  myIndex.create();
-  return myIndex;
+  throw new Error("coord must be GeoJSON Point or an Array of numbers");
 }
-function parseIndex(data, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
-  const { keys, records } = data;
-  const myIndex = new FuseIndex({ getFn, fieldNormWeight });
-  myIndex.setKeys(keys);
-  myIndex.setIndexRecords(records);
-  return myIndex;
+function getGeom(geojson) {
+  if (geojson.type === "Feature") {
+    return geojson.geometry;
+  }
+  return geojson;
 }
-function computeScore$1(pattern, {
-  errors = 0,
-  currentLocation = 0,
-  expectedLocation = 0,
-  distance = Config.distance,
-  ignoreLocation = Config.ignoreLocation
-} = {}) {
-  const accuracy = errors / pattern.length;
-  if (ignoreLocation) {
-    return accuracy;
+function getType(geojson, _name) {
+  if (geojson.type === "FeatureCollection") {
+    return "FeatureCollection";
   }
-  const proximity = Math.abs(expectedLocation - currentLocation);
-  if (!distance) {
-    return proximity ? 1 : accuracy;
+  if (geojson.type === "GeometryCollection") {
+    return "GeometryCollection";
   }
-  return accuracy + proximity / distance;
+  if (geojson.type === "Feature" && geojson.geometry !== null) {
+    return geojson.geometry.type;
+  }
+  return geojson.type;
 }
-function convertMaskToIndices(matchmask = [], minMatchCharLength = Config.minMatchCharLength) {
-  let indices = [];
-  let start = -1;
-  let end = -1;
-  let i = 0;
-  for (let len = matchmask.length; i < len; i += 1) {
-    let match = matchmask[i];
-    if (match && start === -1) {
-      start = i;
-    } else if (!match && start !== -1) {
-      end = i - 1;
-      if (end - start + 1 >= minMatchCharLength) {
-        indices.push([start, end]);
+
+// src/data/navigate/steps/path/index.ts
+var import_difference = __toESM(require("@turf/difference"));
+var import_envelope = __toESM(require("@turf/envelope"));
+var import_boolean_overlap = __toESM(require("@turf/boolean-overlap"));
+var import_boolean_intersects = __toESM(require("@turf/boolean-intersects"));
+
+// ../../node_modules/@turf/meta/dist/esm/index.js
+function coordEach(geojson, callback, excludeWrapCoord) {
+  if (geojson === null) return;
+  var j, k, l, geometry, stopG, coords, geometryMaybeCollection, wrapShrink = 0, coordIndex = 0, isGeometryCollection, type = geojson.type, isFeatureCollection = type === "FeatureCollection", isFeature = type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
+  for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
+    geometryMaybeCollection = isFeatureCollection ? geojson.features[featureIndex].geometry : isFeature ? geojson.geometry : geojson;
+    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+    for (var geomIndex = 0; geomIndex < stopG; geomIndex++) {
+      var multiFeatureIndex = 0;
+      var geometryIndex = 0;
+      geometry = isGeometryCollection ? geometryMaybeCollection.geometries[geomIndex] : geometryMaybeCollection;
+      if (geometry === null) continue;
+      coords = geometry.coordinates;
+      var geomType = geometry.type;
+      wrapShrink = excludeWrapCoord && (geomType === "Polygon" || geomType === "MultiPolygon") ? 1 : 0;
+      switch (geomType) {
+        case null:
+          break;
+        case "Point":
+          if (callback(
+            coords,
+            coordIndex,
+            featureIndex,
+            multiFeatureIndex,
+            geometryIndex
+          ) === false)
+            return false;
+          coordIndex++;
+          multiFeatureIndex++;
+          break;
+        case "LineString":
+        case "MultiPoint":
+          for (j = 0; j < coords.length; j++) {
+            if (callback(
+              coords[j],
+              coordIndex,
+              featureIndex,
+              multiFeatureIndex,
+              geometryIndex
+            ) === false)
+              return false;
+            coordIndex++;
+            if (geomType === "MultiPoint") multiFeatureIndex++;
+          }
+          if (geomType === "LineString") multiFeatureIndex++;
+          break;
+        case "Polygon":
+        case "MultiLineString":
+          for (j = 0; j < coords.length; j++) {
+            for (k = 0; k < coords[j].length - wrapShrink; k++) {
+              if (callback(
+                coords[j][k],
+                coordIndex,
+                featureIndex,
+                multiFeatureIndex,
+                geometryIndex
+              ) === false)
+                return false;
+              coordIndex++;
+            }
+            if (geomType === "MultiLineString") multiFeatureIndex++;
+            if (geomType === "Polygon") geometryIndex++;
+          }
+          if (geomType === "Polygon") multiFeatureIndex++;
+          break;
+        case "MultiPolygon":
+          for (j = 0; j < coords.length; j++) {
+            geometryIndex = 0;
+            for (k = 0; k < coords[j].length; k++) {
+              for (l = 0; l < coords[j][k].length - wrapShrink; l++) {
+                if (callback(
+                  coords[j][k][l],
+                  coordIndex,
+                  featureIndex,
+                  multiFeatureIndex,
+                  geometryIndex
+                ) === false)
+                  return false;
+                coordIndex++;
+              }
+              geometryIndex++;
+            }
+            multiFeatureIndex++;
+          }
+          break;
+        case "GeometryCollection":
+          for (j = 0; j < geometry.geometries.length; j++)
+            if (coordEach(geometry.geometries[j], callback, excludeWrapCoord) === false)
+              return false;
+          break;
+        default:
+          throw new Error("Unknown Geometry Type");
       }
-      start = -1;
     }
   }
-  if (matchmask[i - 1] && i - start >= minMatchCharLength) {
-    indices.push([start, i - 1]);
-  }
-  return indices;
 }
-var MAX_BITS = 32;
-function search(text, pattern, patternAlphabet, {
-  location = Config.location,
-  distance = Config.distance,
-  threshold = Config.threshold,
-  findAllMatches = Config.findAllMatches,
-  minMatchCharLength = Config.minMatchCharLength,
-  includeMatches = Config.includeMatches,
-  ignoreLocation = Config.ignoreLocation
-} = {}) {
-  if (pattern.length > MAX_BITS) {
-    throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS));
-  }
-  const patternLen = pattern.length;
-  const textLen = text.length;
-  const expectedLocation = Math.max(0, Math.min(location, textLen));
-  let currentThreshold = threshold;
-  let bestLocation = expectedLocation;
-  const computeMatches = minMatchCharLength > 1 || includeMatches;
-  const matchMask = computeMatches ? Array(textLen) : [];
-  let index;
-  while ((index = text.indexOf(pattern, bestLocation)) > -1) {
-    let score = computeScore$1(pattern, {
-      currentLocation: index,
-      expectedLocation,
-      distance,
-      ignoreLocation
-    });
-    currentThreshold = Math.min(score, currentThreshold);
-    bestLocation = index + patternLen;
-    if (computeMatches) {
-      let i = 0;
-      while (i < patternLen) {
-        matchMask[index + i] = 1;
-        i += 1;
-      }
+
+// ../../node_modules/@turf/bbox/dist/esm/index.js
+function bbox(geojson, options = {}) {
+  if (geojson.bbox != null && true !== options.recompute) {
+    return geojson.bbox;
+  }
+  const result = [Infinity, Infinity, -Infinity, -Infinity];
+  coordEach(geojson, (coord) => {
+    if (result[0] > coord[0]) {
+      result[0] = coord[0];
     }
-  }
-  bestLocation = -1;
-  let lastBitArr = [];
-  let finalScore = 1;
-  let binMax = patternLen + textLen;
-  const mask = 1 << patternLen - 1;
-  for (let i = 0; i < patternLen; i += 1) {
-    let binMin = 0;
-    let binMid = binMax;
-    while (binMin < binMid) {
-      const score2 = computeScore$1(pattern, {
-        errors: i,
-        currentLocation: expectedLocation + binMid,
-        expectedLocation,
-        distance,
-        ignoreLocation
-      });
-      if (score2 <= currentThreshold) {
-        binMin = binMid;
-      } else {
-        binMax = binMid;
-      }
-      binMid = Math.floor((binMax - binMin) / 2 + binMin);
-    }
-    binMax = binMid;
-    let start = Math.max(1, expectedLocation - binMid + 1);
-    let finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;
-    let bitArr = Array(finish + 2);
-    bitArr[finish + 1] = (1 << i) - 1;
-    for (let j = finish; j >= start; j -= 1) {
-      let currentLocation = j - 1;
-      let charMatch = patternAlphabet[text.charAt(currentLocation)];
-      if (computeMatches) {
-        matchMask[currentLocation] = +!!charMatch;
-      }
-      bitArr[j] = (bitArr[j + 1] << 1 | 1) & charMatch;
-      if (i) {
-        bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];
-      }
-      if (bitArr[j] & mask) {
-        finalScore = computeScore$1(pattern, {
-          errors: i,
-          currentLocation,
-          expectedLocation,
-          distance,
-          ignoreLocation
-        });
-        if (finalScore <= currentThreshold) {
-          currentThreshold = finalScore;
-          bestLocation = currentLocation;
-          if (bestLocation <= expectedLocation) {
-            break;
-          }
-          start = Math.max(1, 2 * expectedLocation - bestLocation);
-        }
-      }
+    if (result[1] > coord[1]) {
+      result[1] = coord[1];
     }
-    const score = computeScore$1(pattern, {
-      errors: i + 1,
-      currentLocation: expectedLocation,
-      expectedLocation,
-      distance,
-      ignoreLocation
-    });
-    if (score > currentThreshold) {
-      break;
+    if (result[2] < coord[0]) {
+      result[2] = coord[0];
     }
-    lastBitArr = bitArr;
-  }
-  const result = {
-    isMatch: bestLocation >= 0,
-    // Count exact matches (those with a score of 0) to be "almost" exact
-    score: Math.max(1e-3, finalScore)
-  };
-  if (computeMatches) {
-    const indices = convertMaskToIndices(matchMask, minMatchCharLength);
-    if (!indices.length) {
-      result.isMatch = false;
-    } else if (includeMatches) {
-      result.indices = indices;
+    if (result[3] < coord[1]) {
+      result[3] = coord[1];
     }
-  }
+  });
   return result;
 }
-function createPatternAlphabet(pattern) {
-  let mask = {};
-  for (let i = 0, len = pattern.length; i < len; i += 1) {
-    const char = pattern.charAt(i);
-    mask[char] = (mask[char] || 0) | 1 << len - i - 1;
-  }
-  return mask;
-}
-var stripDiacritics = String.prototype.normalize ? ((str) => str.normalize("NFD").replace(/[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]/g, "")) : ((str) => str);
-var BitapSearch = class {
-  constructor(pattern, {
-    location = Config.location,
-    threshold = Config.threshold,
-    distance = Config.distance,
-    includeMatches = Config.includeMatches,
-    findAllMatches = Config.findAllMatches,
-    minMatchCharLength = Config.minMatchCharLength,
-    isCaseSensitive = Config.isCaseSensitive,
-    ignoreDiacritics = Config.ignoreDiacritics,
-    ignoreLocation = Config.ignoreLocation
-  } = {}) {
-    this.options = {
-      location,
-      threshold,
-      distance,
-      includeMatches,
-      findAllMatches,
-      minMatchCharLength,
-      isCaseSensitive,
-      ignoreDiacritics,
-      ignoreLocation
-    };
-    pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
-    pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;
-    this.pattern = pattern;
-    this.chunks = [];
-    if (!this.pattern.length) {
-      return;
-    }
-    const addChunk = (pattern2, startIndex) => {
-      this.chunks.push({
-        pattern: pattern2,
-        alphabet: createPatternAlphabet(pattern2),
-        startIndex
-      });
-    };
-    const len = this.pattern.length;
-    if (len > MAX_BITS) {
-      let i = 0;
-      const remainder = len % MAX_BITS;
-      const end = len - remainder;
-      while (i < end) {
-        addChunk(this.pattern.substr(i, MAX_BITS), i);
-        i += MAX_BITS;
+var index_default = bbox;
+
+// src/data/navigate/steps/path/turf/shortestPath.ts
+var import_boolean_point_in_polygon3 = __toESM(require("@turf/boolean-point-in-polygon"));
+var import_distance4 = __toESM(require("@turf/distance"));
+var import_transform_scale = __toESM(require("@turf/transform-scale"));
+var import_union = __toESM(require("@turf/union"));
+var import_bbox_polygon = __toESM(require("@turf/bbox-polygon"));
+var import_clean_coords = require("@turf/clean-coords");
+var import_pathfinding = __toESM(require("pathfinding"));
+var import_set3 = __toESM(require("lodash/set"));
+
+// src/data/navigate/steps/path/turf/stringPull.ts
+function stringPull(grid, path) {
+  const isWalkable = (x, y) => grid.isInside(x, y) && grid.isWalkableAt(x, y);
+  function hasLOS(a, b) {
+    let x0 = a[0], y0 = a[1];
+    const x1 = b[0], y1 = b[1];
+    if (!isWalkable(x0, y0) || !isWalkable(x1, y1)) return false;
+    const dx = Math.abs(x1 - x0);
+    const dy = Math.abs(y1 - y0);
+    const sx = x0 < x1 ? 1 : -1;
+    const sy = y0 < y1 ? 1 : -1;
+    let err = dx - dy;
+    while (true) {
+      if (!isWalkable(x0, y0)) return false;
+      if (x0 === x1 && y0 === y1) break;
+      const e2 = err * 2;
+      let nx = x0;
+      let ny = y0;
+      let movedX = false;
+      let movedY = false;
+      if (e2 > -dy) {
+        err -= dy;
+        nx += sx;
+        movedX = true;
       }
-      if (remainder) {
-        const startIndex = len - MAX_BITS;
-        addChunk(this.pattern.substr(startIndex), startIndex);
+      if (e2 < dx) {
+        err += dx;
+        ny += sy;
+        movedY = true;
       }
-    } else {
-      addChunk(this.pattern, 0);
-    }
-  }
-  searchIn(text) {
-    const { isCaseSensitive, ignoreDiacritics, includeMatches } = this.options;
-    text = isCaseSensitive ? text : text.toLowerCase();
-    text = ignoreDiacritics ? stripDiacritics(text) : text;
-    if (this.pattern === text) {
-      let result2 = {
-        isMatch: true,
-        score: 0
-      };
-      if (includeMatches) {
-        result2.indices = [[0, text.length - 1]];
+      if (movedX && movedY) {
+        if (!isWalkable(nx, y0) || !isWalkable(x0, ny)) return false;
       }
-      return result2;
+      x0 = nx;
+      y0 = ny;
     }
-    const {
-      location,
-      distance,
-      threshold,
-      findAllMatches,
-      minMatchCharLength,
-      ignoreLocation
-    } = this.options;
-    let allIndices = [];
-    let totalScore = 0;
-    let hasMatches = false;
-    this.chunks.forEach(({ pattern, alphabet, startIndex }) => {
-      const { isMatch, score, indices } = search(text, pattern, alphabet, {
-        location: location + startIndex,
-        distance,
-        threshold,
-        findAllMatches,
-        minMatchCharLength,
-        includeMatches,
-        ignoreLocation
-      });
-      if (isMatch) {
-        hasMatches = true;
-      }
-      totalScore += score;
-      if (isMatch && indices) {
-        allIndices = [...allIndices, ...indices];
-      }
-    });
-    let result = {
-      isMatch: hasMatches,
-      score: hasMatches ? totalScore / this.chunks.length : 1
-    };
-    if (hasMatches && includeMatches) {
-      result.indices = allIndices;
-    }
-    return result;
-  }
-};
-var BaseMatch = class {
-  constructor(pattern) {
-    this.pattern = pattern;
-  }
-  static isMultiMatch(pattern) {
-    return getMatch(pattern, this.multiRegex);
-  }
-  static isSingleMatch(pattern) {
-    return getMatch(pattern, this.singleRegex);
+    return true;
   }
-  search() {
+  if (path.length <= 2) return path;
+  const out = [path[0]];
+  let i = 0;
+  while (i < path.length - 1) {
+    let best = i + 1;
+    for (let j = i + 2; j < path.length; j++) {
+      if (hasLOS(path[i], path[j])) best = j;
+      else break;
+    }
+    out.push(path[best]);
+    i = best;
   }
-};
-function getMatch(pattern, exp) {
-  const matches = pattern.match(exp);
-  return matches ? matches[1] : null;
+  return out;
 }
-var ExactMatch = class extends BaseMatch {
-  constructor(pattern) {
-    super(pattern);
-  }
-  static get type() {
-    return "exact";
-  }
-  static get multiRegex() {
-    return /^="(.*)"$/;
-  }
-  static get singleRegex() {
-    return /^=(.*)$/;
-  }
-  search(text) {
-    const isMatch = text === this.pattern;
-    return {
-      isMatch,
-      score: isMatch ? 0 : 1,
-      indices: [0, this.pattern.length - 1]
-    };
-  }
-};
-var InverseExactMatch = class extends BaseMatch {
-  constructor(pattern) {
-    super(pattern);
-  }
-  static get type() {
-    return "inverse-exact";
-  }
-  static get multiRegex() {
-    return /^!"(.*)"$/;
-  }
-  static get singleRegex() {
-    return /^!(.*)$/;
-  }
-  search(text) {
-    const index = text.indexOf(this.pattern);
-    const isMatch = index === -1;
-    return {
-      isMatch,
-      score: isMatch ? 0 : 1,
-      indices: [0, text.length - 1]
-    };
-  }
-};
-var PrefixExactMatch = class extends BaseMatch {
-  constructor(pattern) {
-    super(pattern);
-  }
-  static get type() {
-    return "prefix-exact";
-  }
-  static get multiRegex() {
-    return /^\^"(.*)"$/;
-  }
-  static get singleRegex() {
-    return /^\^(.*)$/;
-  }
-  search(text) {
-    const isMatch = text.startsWith(this.pattern);
-    return {
-      isMatch,
-      score: isMatch ? 0 : 1,
-      indices: [0, this.pattern.length - 1]
-    };
-  }
-};
-var InversePrefixExactMatch = class extends BaseMatch {
-  constructor(pattern) {
-    super(pattern);
-  }
-  static get type() {
-    return "inverse-prefix-exact";
-  }
-  static get multiRegex() {
-    return /^!\^"(.*)"$/;
-  }
-  static get singleRegex() {
-    return /^!\^(.*)$/;
-  }
-  search(text) {
-    const isMatch = !text.startsWith(this.pattern);
-    return {
-      isMatch,
-      score: isMatch ? 0 : 1,
-      indices: [0, text.length - 1]
-    };
-  }
-};
-var SuffixExactMatch = class extends BaseMatch {
-  constructor(pattern) {
-    super(pattern);
-  }
-  static get type() {
-    return "suffix-exact";
-  }
-  static get multiRegex() {
-    return /^"(.*)"\$$/;
-  }
-  static get singleRegex() {
-    return /^(.*)\$$/;
-  }
-  search(text) {
-    const isMatch = text.endsWith(this.pattern);
-    return {
-      isMatch,
-      score: isMatch ? 0 : 1,
-      indices: [text.length - this.pattern.length, text.length - 1]
-    };
-  }
-};
-var InverseSuffixExactMatch = class extends BaseMatch {
-  constructor(pattern) {
-    super(pattern);
-  }
-  static get type() {
-    return "inverse-suffix-exact";
-  }
-  static get multiRegex() {
-    return /^!"(.*)"\$$/;
-  }
-  static get singleRegex() {
-    return /^!(.*)\$$/;
-  }
-  search(text) {
-    const isMatch = !text.endsWith(this.pattern);
-    return {
-      isMatch,
-      score: isMatch ? 0 : 1,
-      indices: [0, text.length - 1]
-    };
-  }
-};
-var FuzzyMatch = class extends BaseMatch {
-  constructor(pattern, {
-    location = Config.location,
-    threshold = Config.threshold,
-    distance = Config.distance,
-    includeMatches = Config.includeMatches,
-    findAllMatches = Config.findAllMatches,
-    minMatchCharLength = Config.minMatchCharLength,
-    isCaseSensitive = Config.isCaseSensitive,
-    ignoreDiacritics = Config.ignoreDiacritics,
-    ignoreLocation = Config.ignoreLocation
-  } = {}) {
-    super(pattern);
-    this._bitapSearch = new BitapSearch(pattern, {
-      location,
-      threshold,
-      distance,
-      includeMatches,
-      findAllMatches,
-      minMatchCharLength,
-      isCaseSensitive,
-      ignoreDiacritics,
-      ignoreLocation
-    });
-  }
-  static get type() {
-    return "fuzzy";
-  }
-  static get multiRegex() {
-    return /^"(.*)"$/;
-  }
-  static get singleRegex() {
-    return /^(.*)$/;
-  }
-  search(text) {
-    return this._bitapSearch.searchIn(text);
-  }
-};
-var IncludeMatch = class extends BaseMatch {
-  constructor(pattern) {
-    super(pattern);
-  }
-  static get type() {
-    return "include";
-  }
-  static get multiRegex() {
-    return /^'"(.*)"$/;
-  }
-  static get singleRegex() {
-    return /^'(.*)$/;
-  }
-  search(text) {
-    let location = 0;
-    let index;
-    const indices = [];
-    const patternLen = this.pattern.length;
-    while ((index = text.indexOf(this.pattern, location)) > -1) {
-      location = index + patternLen;
-      indices.push([index, location - 1]);
+
+// src/data/navigate/steps/path/turf/pruneSmallAngle.ts
+function pruneSmallAngles(path, minDeg = 10) {
+  if (path.length <= 2) return path;
+  const out = [path[0]];
+  for (let i = 1; i < path.length - 1; i++) {
+    const a = out[out.length - 1];
+    const b = path[i];
+    const c = path[i + 1];
+    const abx = b[0] - a[0], aby = b[1] - a[1];
+    const bcx = c[0] - b[0], bcy = c[1] - b[1];
+    const dot = abx * bcx + aby * bcy;
+    const ab = Math.hypot(abx, aby);
+    const bc = Math.hypot(bcx, bcy);
+    const angle = Math.acos(dot / (ab * bc)) * 180 / Math.PI;
+    if (angle > minDeg) out.push(b);
+  }
+  out.push(path[path.length - 1]);
+  return out;
+}
+
+// src/data/navigate/steps/path/turf/pruneShortSegments.ts
+function pruneShortSegments(path, minLen = 5) {
+  const out = [path[0]];
+  for (let i = 1; i < path.length; i++) {
+    const [x0, y0] = out[out.length - 1];
+    const [x1, y1] = path[i];
+    if (Math.hypot(x1 - x0, y1 - y0) >= minLen) {
+      out.push(path[i]);
     }
-    const isMatch = !!indices.length;
-    return {
-      isMatch,
-      score: isMatch ? 0 : 1,
-      indices
-    };
   }
-};
-var searchers = [
-  ExactMatch,
-  IncludeMatch,
-  PrefixExactMatch,
-  InversePrefixExactMatch,
-  InverseSuffixExactMatch,
-  SuffixExactMatch,
-  InverseExactMatch,
-  FuzzyMatch
-];
-var searchersLen = searchers.length;
-var SPACE_RE = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;
-var OR_TOKEN = "|";
-function parseQuery(pattern, options = {}) {
-  return pattern.split(OR_TOKEN).map((item) => {
-    let query = item.trim().split(SPACE_RE).filter((item2) => item2 && !!item2.trim());
-    let results = [];
-    for (let i = 0, len = query.length; i < len; i += 1) {
-      const queryItem = query[i];
-      let found = false;
-      let idx = -1;
-      while (!found && ++idx < searchersLen) {
-        const searcher = searchers[idx];
-        let token = searcher.isMultiMatch(queryItem);
-        if (token) {
-          results.push(new searcher(token, options));
-          found = true;
-        }
-      }
-      if (found) {
-        continue;
-      }
-      idx = -1;
-      while (++idx < searchersLen) {
-        const searcher = searchers[idx];
-        let token = searcher.isSingleMatch(queryItem);
-        if (token) {
-          results.push(new searcher(token, options));
-          break;
-        }
-      }
-    }
-    return results;
-  });
+  return out;
 }
-var MultiMatchSet = /* @__PURE__ */ new Set([FuzzyMatch.type, IncludeMatch.type]);
-var ExtendedSearch = class {
-  constructor(pattern, {
-    isCaseSensitive = Config.isCaseSensitive,
-    ignoreDiacritics = Config.ignoreDiacritics,
-    includeMatches = Config.includeMatches,
-    minMatchCharLength = Config.minMatchCharLength,
-    ignoreLocation = Config.ignoreLocation,
-    findAllMatches = Config.findAllMatches,
-    location = Config.location,
-    threshold = Config.threshold,
-    distance = Config.distance
-  } = {}) {
-    this.query = null;
-    this.options = {
-      isCaseSensitive,
-      ignoreDiacritics,
-      includeMatches,
-      minMatchCharLength,
-      findAllMatches,
-      ignoreLocation,
-      location,
-      threshold,
-      distance
-    };
-    pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
-    pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;
-    this.pattern = pattern;
-    this.query = parseQuery(this.pattern, this.options);
-  }
-  static condition(_, options) {
-    return options.useExtendedSearch;
-  }
-  searchIn(text) {
-    const query = this.query;
-    if (!query) {
-      return {
-        isMatch: false,
-        score: 1
-      };
-    }
-    const { includeMatches, isCaseSensitive, ignoreDiacritics } = this.options;
-    text = isCaseSensitive ? text : text.toLowerCase();
-    text = ignoreDiacritics ? stripDiacritics(text) : text;
-    let numMatches = 0;
-    let allIndices = [];
-    let totalScore = 0;
-    for (let i = 0, qLen = query.length; i < qLen; i += 1) {
-      const searchers2 = query[i];
-      allIndices.length = 0;
-      numMatches = 0;
-      for (let j = 0, pLen = searchers2.length; j < pLen; j += 1) {
-        const searcher = searchers2[j];
-        const { isMatch, indices, score } = searcher.search(text);
-        if (isMatch) {
-          numMatches += 1;
-          totalScore += score;
-          if (includeMatches) {
-            const type = searcher.constructor.type;
-            if (MultiMatchSet.has(type)) {
-              allIndices = [...allIndices, ...indices];
-            } else {
-              allIndices.push(indices);
-            }
-          }
-        } else {
-          totalScore = 0;
-          numMatches = 0;
-          allIndices.length = 0;
-          break;
-        }
-      }
-      if (numMatches) {
-        let result = {
-          isMatch: true,
-          score: totalScore / numMatches
-        };
-        if (includeMatches) {
-          result.indices = allIndices;
-        }
-        return result;
+
+// src/data/navigate/steps/path/turf/clearance.ts
+function buildClearanceGrid(matrix) {
+  const h = matrix.length;
+  const w = matrix[0].length;
+  const INF = 1e9;
+  const dist = Array.from({ length: h }, () => Array(w).fill(INF));
+  const q = [];
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      if (matrix[y][x] === 1) {
+        dist[y][x] = 0;
+        q.push([x, y]);
       }
     }
-    return {
-      isMatch: false,
-      score: 1
-    };
   }
-};
-var registeredSearchers = [];
-function register(...args) {
-  registeredSearchers.push(...args);
-}
-function createSearcher(pattern, options) {
-  for (let i = 0, len = registeredSearchers.length; i < len; i += 1) {
-    let searcherClass = registeredSearchers[i];
-    if (searcherClass.condition(pattern, options)) {
-      return new searcherClass(pattern, options);
+  const dirs = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1],
+    [1, 1],
+    [1, -1],
+    [-1, 1],
+    [-1, -1]
+  ];
+  let qi = 0;
+  while (qi < q.length) {
+    const [x, y] = q[qi++];
+    const d0 = dist[y][x];
+    for (const [dx, dy] of dirs) {
+      const nx = x + dx, ny = y + dy;
+      if (nx < 0 || ny < 0 || nx >= w || ny >= h) continue;
+      const nd = d0 + 1;
+      if (nd < dist[ny][nx]) {
+        dist[ny][nx] = nd;
+        q.push([nx, ny]);
+      }
     }
   }
-  return new BitapSearch(pattern, options);
+  return dist;
 }
-var LogicalOperator = {
-  AND: "$and",
-  OR: "$or"
-};
-var KeyType = {
-  PATH: "$path",
-  PATTERN: "$val"
-};
-var isExpression = (query) => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
-var isPath = (query) => !!query[KeyType.PATH];
-var isLeaf = (query) => !isArray(query) && isObject(query) && !isExpression(query);
-var convertToExplicit = (query) => ({
-  [LogicalOperator.AND]: Object.keys(query).map((key) => ({
-    [key]: query[key]
-  }))
-});
-function parse(query, options, { auto = true } = {}) {
-  const next = (query2) => {
-    let keys = Object.keys(query2);
-    const isQueryPath = isPath(query2);
-    if (!isQueryPath && keys.length > 1 && !isExpression(query2)) {
-      return next(convertToExplicit(query2));
-    }
-    if (isLeaf(query2)) {
-      const key = isQueryPath ? query2[KeyType.PATH] : keys[0];
-      const pattern = isQueryPath ? query2[KeyType.PATTERN] : query2[key];
-      if (!isString(pattern)) {
-        throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));
-      }
-      const obj = {
-        keyId: createKeyId(key),
-        pattern
-      };
-      if (auto) {
-        obj.searcher = createSearcher(pattern, options);
+function snapPointToClearancePeak(p, clearance, isWalkableCell, radius = 4) {
+  const [px, py] = p;
+  let best = p;
+  let bestScore = clearance[py]?.[px] ?? -Infinity;
+  for (let dy = -radius; dy <= radius; dy++) {
+    for (let dx = -radius; dx <= radius; dx++) {
+      const x = px + dx;
+      const y = py + dy;
+      if (!isWalkableCell(x, y)) continue;
+      const score = clearance[y][x];
+      const penalty = Math.hypot(dx, dy) * 5e-3;
+      const finalScore = score - penalty;
+      if (finalScore > bestScore) {
+        bestScore = finalScore;
+        best = [x, y];
       }
-      return obj;
     }
-    let node = {
-      children: [],
-      operator: keys[0]
-    };
-    keys.forEach((key) => {
-      const value = query2[key];
-      if (isArray(value)) {
-        value.forEach((item) => {
-          node.children.push(next(item));
-        });
-      }
-    });
-    return node;
-  };
-  if (!isExpression(query)) {
-    query = convertToExplicit(query);
   }
-  return next(query);
+  return best;
 }
-function computeScore(results, { ignoreFieldNorm = Config.ignoreFieldNorm }) {
-  results.forEach((result) => {
-    let totalScore = 1;
-    result.matches.forEach(({ key, norm: norm2, score }) => {
-      const weight = key ? key.weight : null;
-      totalScore *= Math.pow(
-        score === 0 && weight ? Number.EPSILON : score,
-        (weight || 1) * (ignoreFieldNorm ? 1 : norm2)
-      );
-    });
-    result.score = totalScore;
-  });
+function centerlineSnapPath(path, clearance, isWalkableCell, radius = 4) {
+  const snapped = path.map((p) => snapPointToClearancePeak(p, clearance, isWalkableCell, radius));
+  return snapped;
 }
-function transformMatches(result, data) {
-  const matches = result.matches;
-  data.matches = [];
-  if (!isDefined(matches)) {
-    return;
+
+// src/data/navigate/steps/path/turf/shortestPath.ts
+function shortestPath(start, end, options) {
+  options = options || {};
+  if (!isObject(options)) throw new Error("options is invalid");
+  let resolution = options.resolution;
+  const smoothenPath = options.smoothenPath;
+  let obstacles = options.obstacles || featureCollection([]);
+  if (!start) throw new Error("start is required");
+  if (!end) throw new Error("end is required");
+  if (resolution && !isNumber(resolution) || resolution <= 0)
+    throw new Error("options.resolution must be a number, greater than 0");
+  const startCoord = getCoord(start);
+  const endCoord = getCoord(end);
+  start = point(startCoord);
+  end = point(endCoord);
+  switch (getType(obstacles)) {
+    case "FeatureCollection":
+      if (obstacles.features.length === 0)
+        return lineString([startCoord, endCoord]);
+      break;
+    case "Polygon":
+      obstacles = featureCollection([feature(getGeom(obstacles))]);
+      break;
+    default:
+      throw new Error("invalid obstacles");
+  }
+  const collection = obstacles;
+  collection.features.push(start, end);
+  const box = index_default((0, import_transform_scale.default)((0, import_bbox_polygon.default)(index_default(collection)), 1.15));
+  if (!resolution) {
+    const width = (0, import_distance4.default)([box[0], box[1]], [box[2], box[1]], options);
+    resolution = width / 100;
+  }
+  collection.features.pop();
+  collection.features.pop();
+  const [west, south, east, north] = box;
+  const xFraction = resolution / (0, import_distance4.default)([west, south], [east, south], options);
+  const cellWidth = xFraction * (east - west);
+  const yFraction = resolution / (0, import_distance4.default)([west, south], [west, north], options);
+  const cellHeight = yFraction * (north - south);
+  const bboxHorizontalSide = east - west;
+  const bboxVerticalSide = north - south;
+  const columns = Math.floor(bboxHorizontalSide / cellWidth);
+  const rows = Math.floor(bboxVerticalSide / cellHeight);
+  const deltaX = (bboxHorizontalSide - columns * cellWidth) / 2;
+  const deltaY = (bboxVerticalSide - rows * cellHeight) / 2;
+  let closestToStart = null, closestToEnd = null, minDistStart = Infinity, minDistEnd = Infinity, currentY = north - deltaY, currentX = west + deltaX, row = 0, column = 0, distStart, distEnd, pt, isInsideObstacle;
+  const roundLoopY = Math.ceil((currentY - south) / cellHeight);
+  const roundLoopX = Math.ceil((east - currentX) / cellWidth);
+  let totalRounds = roundLoopX * roundLoopY;
+  const pointMatrix = [];
+  const matrix = [];
+  const obstacleTotal = collection.features.length;
+  const obstacleFeatures = collection.features;
+  let combinedObstacle = obstacleFeatures[0];
+  let obstacleIndex = 0;
+  for (obstacleIndex = 0; obstacleIndex < obstacleTotal; obstacleIndex++) {
+    const nextObstacleFeature = obstacleFeatures[obstacleIndex + 1];
+    if (!nextObstacleFeature) continue;
+    try {
+      combinedObstacle = (0, import_union.default)(
+        featureCollection([combinedObstacle, nextObstacleFeature])
+      );
+    } catch (e) {
+      console.log(e);
+    }
   }
-  matches.forEach((match) => {
-    if (!isDefined(match.indices) || !match.indices.length) {
-      return;
+  while (totalRounds--) {
+    pt = point([currentX, currentY]);
+    isInsideObstacle = (0, import_boolean_point_in_polygon3.default)(pt, combinedObstacle);
+    (0, import_set3.default)(matrix, `[${row}][${column}]`, isInsideObstacle ? 1 : 0);
+    (0, import_set3.default)(pointMatrix, `[${row}][${column}]`, `${currentX}|${currentY}`);
+    distStart = (0, import_distance4.default)(pt, start);
+    if (!isInsideObstacle && distStart < minDistStart) {
+      minDistStart = distStart;
+      closestToStart = { x: column, y: row };
     }
-    const { indices, value } = match;
-    let obj = {
-      indices,
-      value
-    };
-    if (match.key) {
-      obj.key = match.key.src;
+    distEnd = (0, import_distance4.default)(pt, end);
+    if (!isInsideObstacle && distEnd < minDistEnd) {
+      minDistEnd = distEnd;
+      closestToEnd = { x: column, y: row };
     }
-    if (match.idx > -1) {
-      obj.refIndex = match.idx;
+    if (column < roundLoopX) {
+      currentX += cellWidth;
+      column++;
+      continue;
     }
-    data.matches.push(obj);
-  });
-}
-function transformScore(result, data) {
-  data.score = result.score;
-}
-function format(results, docs, {
-  includeMatches = Config.includeMatches,
-  includeScore = Config.includeScore
-} = {}) {
-  const transformers = [];
-  if (includeMatches) transformers.push(transformMatches);
-  if (includeScore) transformers.push(transformScore);
-  return results.map((result) => {
-    const { idx } = result;
-    const data = {
-      item: docs[idx],
-      refIndex: idx
-    };
-    if (transformers.length) {
-      transformers.forEach((transformer) => {
-        transformer(result, data);
-      });
+    if (row < roundLoopY) {
+      currentY -= cellHeight;
+      currentX = west + deltaX;
+      column = 0;
+      row++;
     }
-    return data;
+  }
+  const finder = new import_pathfinding.default.AStarFinder({
+    allowDiagonal: true,
+    dontCrossCorners: true,
+    heuristic: import_pathfinding.default.Heuristic.euclidean
+  });
+  const grid = new import_pathfinding.default.Grid(matrix);
+  const startOnMatrix = [closestToStart.x, closestToStart.y];
+  const endOnMatrix = [closestToEnd.x, closestToEnd.y];
+  let result = finder.findPath(...startOnMatrix, ...endOnMatrix, grid);
+  if (result.length > 0) {
+    result = stringPull(grid, result);
+    const clearanceGrid = buildClearanceGrid(matrix);
+    const isWalkable = (x, y) => grid.isInside(x, y) && grid.isWalkableAt(x, y);
+    result = centerlineSnapPath(result, clearanceGrid, isWalkable);
+    result = stringPull(grid, result);
+    result = pruneSmallAngles(result);
+    result = pruneShortSegments(result);
+  }
+  result.pop();
+  result.shift();
+  const path = [startCoord];
+  result.forEach((coord) => {
+    const coords = pointMatrix[coord[1]][coord[0]].split("|");
+    path.push([+coords[0], +coords[1]]);
   });
+  path.push(endCoord);
+  return (0, import_clean_coords.cleanCoords)(lineString(path));
 }
-var Fuse = class {
-  constructor(docs, options = {}, index) {
-    this.options = { ...Config, ...options };
-    if (this.options.useExtendedSearch && false) {
-      throw new Error(EXTENDED_SEARCH_UNAVAILABLE);
-    }
-    this._keyStore = new KeyStore(this.options.keys);
-    this.setCollection(docs, index);
-  }
-  setCollection(docs, index) {
-    this._docs = docs;
-    if (index && !(index instanceof FuseIndex)) {
-      throw new Error(INCORRECT_INDEX_TYPE);
-    }
-    this._myIndex = index || createIndex(this.options.keys, this._docs, {
-      getFn: this.options.getFn,
-      fieldNormWeight: this.options.fieldNormWeight
+var shortestPath_default = shortestPath;
+
+// src/data/navigate/steps/path/index.ts
+var createStepPathUtils = (options) => {
+  const resolution = options.resolution ?? 88e-5;
+  const { units, kiosks, fixtures } = options.data;
+  const possibleObstacleFeatures = [...units, ...kiosks, ...fixtures];
+  const filterObstaclesByOrdinal = (levelId) => {
+    return possibleObstacleFeatures.filter(({ feature_type, properties, geometry }) => {
+      return properties.level_id === levelId && ["Polygon", "MultiPolygon"].includes(geometry.type) && (OBSTACLE_FEATURE_TYPES.includes(feature_type) || "category" in properties && OBSTACLE_CATEGORIES.includes(properties.category));
     });
-  }
-  add(doc) {
-    if (!isDefined(doc)) {
-      return;
+  };
+  const findObstaclesFromWalkway = (intermediaryUnit, exceptionIds = []) => {
+    const result = featureCollection([]);
+    if (!intermediaryUnit) return result;
+    const walkwayLevelId = intermediaryUnit.properties.level_id;
+    const obstacleOnLevel = filterObstaclesByOrdinal(walkwayLevelId).filter(
+      (obstacle) => !exceptionIds.includes(obstacle.id)
+    );
+    const relatedObstacleWithIntermediary = obstacleOnLevel.reduce(
+      (obstacles, feature2) => {
+        if (
+          // Prevent detecting itself as an obstacle
+          // Ex. Unable to draw a line to amenity located with in a room as room is also consider as obstacle
+          feature2.id !== intermediaryUnit.id && ((0, import_boolean_overlap.default)(intermediaryUnit, feature2) || (0, import_boolean_intersects.default)(intermediaryUnit, feature2))
+        ) {
+          const polygons = getType(feature2) === "Polygon" ? [polygon(feature2.geometry.coordinates, { id: feature2.id })] : feature2.geometry.coordinates.map((ring) => polygon(ring, { id: feature2.id }));
+          obstacles.push(...polygons);
+        }
+        return obstacles;
+      },
+      []
+    );
+    const intermediaryExtends = (0, import_envelope.default)(intermediaryUnit);
+    const walkwayPerimeter = (0, import_difference.default)(
+      featureCollection([intermediaryExtends, intermediaryUnit])
+    );
+    result.features.push(...relatedObstacleWithIntermediary, walkwayPerimeter);
+    return result;
+  };
+  const findPathOnArea = (originPoint, destinationPoint, options2) => {
+    const { obstacles = featureCollection([]), resolution: resolution2, properties } = options2 || {};
+    const stepPath = shortestPath_default(originPoint, destinationPoint, {
+      obstacles,
+      smoothenPath: false,
+      resolution: resolution2
+    });
+    stepPath.properties = properties;
+    return stepPath;
+  };
+  const findStepPath = (from, to, intermediaries) => {
+    const t0 = performance.now();
+    const relatedWalkablePlatform = intermediaries.find(
+      (feature2) => WALKABLE_CATEGORY.includes(feature2.properties.category)
+    );
+    const exceptionFeatureIds = [];
+    const obstacles = findObstaclesFromWalkway(
+      relatedWalkablePlatform,
+      import_lodash11.default.compact(exceptionFeatureIds)
+    );
+    const line = findPathOnArea(from, to, {
+      resolution,
+      obstacles
+    });
+    return line.geometry.coordinates;
+  };
+  return {
+    findStepPath
+  };
+};
+
+// src/data/navigate/landmark/createLandmarkUtils.ts
+var import_center6 = require("@turf/center");
+var import_distance5 = __toESM(require("@turf/distance"));
+var NEARBY_DISTANCE = 30;
+var createLandmarkUtils = (options) => {
+  const { data, findByIdSync } = options;
+  const { occupants } = data;
+  const occupantToLandmark = (occupant) => {
+    const locationType = occupant.properties.unit_id ? "unit" : "kiosk";
+    const locationId = locationType === "unit" ? occupant.properties.unit_id : occupant.properties.kiosk_id;
+    const location = locationType === "unit" ? findByIdSync(locationId) : findByIdSync(locationId);
+    const level = findByIdSync(location.properties.level_id);
+    return {
+      name: occupant.properties.name,
+      point: (0, import_center6.center)(location.geometry).geometry.coordinates,
+      level_id: location.properties.level_id,
+      is_priority: occupant.properties.is_landmark,
+      ordinal: level.properties.ordinal
+    };
+  };
+  const landmarks = [
+    ...occupants.map(occupantToLandmark)
+  ];
+  const findNearbyLandmarks = (point2, levelId) => {
+    if (point2 === null || levelId === null) return [];
+    return landmarks.map((landmark) => {
+      const landmarkAndDistance = {
+        landmark,
+        d: (0, import_distance5.default)(point2, landmark.point, { units: "meters" })
+      };
+      return landmarkAndDistance;
+    }).filter(({ landmark, d }) => d <= NEARBY_DISTANCE && landmark.level_id === levelId).sort((a, b) => {
+      const aPriority = a.landmark.is_priority ? 0 : 1;
+      const bPriority = b.landmark.is_priority ? 0 : 1;
+      if (aPriority !== bPriority) return aPriority - bPriority;
+      return a.d - b.d;
+    }).map(({ landmark }) => landmark);
+  };
+  const findNearestLandmark = (point2, levelId) => {
+    const nearbyLandmarks = findNearbyLandmarks(point2, levelId);
+    const nearestLandmark = nearbyLandmarks.length > 0 ? nearbyLandmarks[0] : null;
+    return nearestLandmark;
+  };
+  return { findNearbyLandmarks, findNearestLandmark };
+};
+
+// src/data/navigate/steps/utils/extractStartPoint.ts
+var import_center7 = require("@turf/center");
+
+// src/data/navigate/steps/utils/featureIdGuard.ts
+var isOccupant = (id) => !!id && id.startsWith("occupant-");
+var isUnit = (id) => !!id && id.startsWith("unit-");
+var isKiosk = (id) => !!id && id.startsWith("kiosk-");
+var isOpening = (id) => !!id && id.startsWith("opening-");
+
+// src/data/navigate/type-guard.ts
+function isCoordinateOrdinalString(id) {
+  return /^-?\d+(\.\d+)?,-?\d+(\.\d+)?,-?\d+(\.\d+)?o$/.test(id);
+}
+
+// src/data/navigate/steps/utils/extractStartPoint.ts
+var extractStartPoint = (path, options) => {
+  const { findByIdSync } = options;
+  const [a, b, c] = path;
+  if (isOccupant(a) && isUnit(b) && isOpening(c)) {
+    const occ = findByIdSync(a);
+    const opening = findByIdSync(c);
+    const level = findByIdSync(opening.properties.level_id);
+    return [
+      {
+        id: occ.id,
+        type: "start",
+        name: occ.properties.name,
+        point: (0, import_center7.center)(opening).geometry.coordinates,
+        levelId: opening.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "opening", id: opening.id }
+      },
+      path.slice(3)
+    ];
+  }
+  if (isOccupant(a) && isKiosk(b)) {
+    const occ = findByIdSync(a);
+    const kiosk = findByIdSync(c);
+    const level = findByIdSync(kiosk.properties.level_id);
+    return [
+      {
+        id: occ.id,
+        type: "start",
+        name: occ.properties.name,
+        point: (0, import_center7.center)(kiosk).geometry.coordinates,
+        levelId: kiosk.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "kiosk", id: kiosk.id }
+      },
+      path.slice(2)
+    ];
+  }
+  if (isCoordinateOrdinalString(a) && isOpening(b)) {
+    const [lat, lng, ordinal] = parseOrdinalCoordinate(a);
+    const opening = findByIdSync(b);
+    return [
+      {
+        id: a,
+        type: "start",
+        name: { en: `Your location` },
+        point: [lng, lat],
+        levelId: opening.properties.level_id,
+        ordinal,
+        source: { type: "opening", id: opening.id }
+      },
+      path.slice(1)
+    ];
+  }
+  return [null, path];
+};
+
+// src/data/navigate/steps/utils/extractEndPint.ts
+var import_center8 = require("@turf/center");
+var extractEndPoint = (path, options) => {
+  const { findByIdSync } = options;
+  const [c, b, a] = path.slice(-3);
+  if (isOccupant(a) && isUnit(b) && isOpening(c)) {
+    const occ = findByIdSync(a);
+    const opening = findByIdSync(c);
+    const level = findByIdSync(opening.properties.level_id);
+    return [
+      {
+        id: occ.id,
+        type: "end",
+        name: occ.properties.name,
+        point: (0, import_center8.center)(opening).geometry.coordinates,
+        levelId: opening.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "opening", id: opening.id }
+      },
+      path.slice(0, -3)
+    ];
+  }
+  if (isOccupant(a) && isKiosk(b)) {
+    const occ = findByIdSync(a);
+    const kiosk = findByIdSync(c);
+    const level = findByIdSync(kiosk.properties.level_id);
+    return [
+      {
+        id: occ.id,
+        type: "end",
+        name: occ.properties.name,
+        point: (0, import_center8.center)(kiosk).geometry.coordinates,
+        levelId: kiosk.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "kiosk", id: kiosk.id }
+      },
+      path.slice(0, -2)
+    ];
+  }
+  if (isCoordinateOrdinalString(a)) {
+    const [lat, lng, ordinal] = parseOrdinalCoordinate(a);
+    const opening = findByIdSync(b);
+    return [
+      {
+        id: a,
+        type: "end",
+        name: { en: `Your location` },
+        point: [lng, lat],
+        levelId: opening.properties.level_id,
+        ordinal,
+        source: { type: "opening", id: opening.id }
+      },
+      path.slice(0, -2)
+    ];
+  }
+  return [null, path];
+};
+
+// src/data/navigate/steps/utils/combineWalkwaySteps.ts
+var import_uniq = __toESM(require("lodash/uniq"));
+var combineWalkwaySteps = (steps) => {
+  let result = [];
+  for (let i = 0; i < steps.length; i++) {
+    const thisStep = steps[i];
+    if (i === steps.length - 1) {
+      result.push(thisStep);
+      continue;
     }
-    this._docs.push(doc);
-    this._myIndex.add(doc);
-  }
-  remove(predicate = () => false) {
-    const results = [];
-    for (let i = 0, len = this._docs.length; i < len; i += 1) {
-      const doc = this._docs[i];
-      if (predicate(doc, i)) {
-        this.removeAt(i);
-        i -= 1;
-        len -= 1;
-        results.push(doc);
-      }
+    const nextStep = steps[i + 1];
+    if (thisStep.intermediaryCategory === "walkway" && nextStep.intermediaryCategory === "walkway" && thisStep.from.source.type === "opening" && nextStep.from.source.type === "opening") {
+      console.log({ i, len: steps.length, thisStep, nextStep });
+      result.push({
+        from: thisStep.from,
+        to: nextStep.to,
+        levelIds: (0, import_uniq.default)([...thisStep.levelIds, ...nextStep.levelIds]),
+        ordinals: (0, import_uniq.default)([...thisStep.ordinals, ...nextStep.ordinals]),
+        intermediaryCategory: "walkway",
+        description: nextStep.description,
+        path: [
+          ...thisStep.path,
+          ...nextStep.path
+        ]
+      });
+      i++;
+    } else {
+      result.push(thisStep);
     }
-    return results;
-  }
-  removeAt(idx) {
-    this._docs.splice(idx, 1);
-    this._myIndex.removeAt(idx);
-  }
-  getIndex() {
-    return this._myIndex;
   }
-  search(query, { limit = -1 } = {}) {
-    const {
-      includeMatches,
-      includeScore,
-      shouldSort,
-      sortFn,
-      ignoreFieldNorm
-    } = this.options;
-    let results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
-    computeScore(results, { ignoreFieldNorm });
-    if (shouldSort) {
-      results.sort(sortFn);
+  return result;
+};
+
+// src/data/navigate/steps/createStepUtils.ts
+var createStepUtils = (options) => {
+  const { data: { units, relationships }, findByIdSync } = options;
+  const landmarkUtils = createLandmarkUtils(options);
+  const stepPathUtils = createStepPathUtils({ ...options, resolution: 88e-5 });
+  const findUnitBetweenOpenings = (originId, destinationId) => {
+    const origin = findByIdSync(originId);
+    const destination = findByIdSync(destinationId);
+    const matchedOne = relationships.find((rel) => rel.properties.intermediary.map((int) => int.id).includes(origin.id));
+    const matchOneUnits = [matchedOne.properties.origin, matchedOne.properties.destination];
+    const matchedTwo = relationships.find((rel) => rel.properties.intermediary.map((int) => int.id).includes(destination.id));
+    const matchTwoUnits = [matchedTwo.properties.origin, matchedTwo.properties.destination];
+    const unitIds = (0, import_intersectionBy.default)(matchOneUnits, matchTwoUnits, "id");
+    return unitIds.map(({ id }) => findByIdSync(id));
+  };
+  const findHorizontalIntermediary = (from, to) => {
+    if (from.source.type !== "opening") {
+      const unit = findContainingUnitAtPoint(from.point, from.levelId, units);
+      return unit ? [unit] : [];
     }
-    if (isNumber(limit) && limit > -1) {
-      results = results.slice(0, limit);
+    if (to.source.type !== "opening") {
+      const unit = findContainingUnitAtPoint(to.point, to.levelId, units);
+      return unit ? [unit] : [];
     }
-    return format(results, this._docs, {
-      includeMatches,
-      includeScore
+    return findUnitBetweenOpenings(from.source.id, to.source.id);
+  };
+  const findVerticalIntermediary = (from, to) => {
+    const firstOpeningId = from.source.id;
+    const secondOpeningId = to.source.id;
+    const relationship = relationships.find((rel) => {
+      return rel.properties.origin?.id === firstOpeningId && rel.properties.destination?.id === secondOpeningId || rel.properties.origin?.id === secondOpeningId && rel.properties.destination?.id === firstOpeningId;
     });
-  }
-  _searchStringList(query) {
-    const searcher = createSearcher(query, this.options);
-    const { records } = this._myIndex;
-    const results = [];
-    records.forEach(({ v: text, i: idx, n: norm2 }) => {
-      if (!isDefined(text)) {
-        return;
-      }
-      const { isMatch, score, indices } = searcher.searchIn(text);
-      if (isMatch) {
-        results.push({
-          item: text,
-          idx,
-          matches: [{ score, value: text, norm: norm2, indices }]
-        });
-      }
+    const intermediaryTypeAndId = relationship.properties.intermediary;
+    return intermediaryTypeAndId.map(({ id }) => findByIdSync(id));
+  };
+  const formatCategoryLabel = (category) => {
+    return (0, import_lodash12.capitalize)(category);
+  };
+  const getToward = (from, to, intermediary) => {
+    if (to.type === "end") return to.name;
+    const intermediaryIds = intermediary.map((int) => int.id);
+    const relationship = relationships.find((rel) => rel.properties.intermediary.map((int) => int.id).includes(to.source.id));
+    if (!relationship) return to.name;
+    const candidates = [relationship.properties.origin.id, relationship.properties.destination.id];
+    const nextUnitId = candidates.filter((id) => !intermediaryIds.includes(id))[0];
+    if (!nextUnitId) return to.name;
+    const nextUnit = findByIdSync(nextUnitId);
+    return { en: formatCategoryLabel(`${nextUnit.properties.category}`) };
+  };
+  const toWaypoints = (path) => {
+    const [startPoint, middleAndEndPoints] = extractStartPoint(path, options);
+    const [endPoint, middlePoints] = extractEndPoint(middleAndEndPoints, options);
+    const waypoints = middlePoints.map((openingId) => {
+      const opening = findByIdSync(openingId);
+      const level = findByIdSync(opening.properties.level_id);
+      const coordinates = (0, import_center9.center)(opening).geometry.coordinates;
+      const landmark = landmarkUtils.findNearestLandmark(coordinates, opening.properties.level_id);
+      return {
+        id: `${opening.properties.level_id}:${openingId}`,
+        type: "between",
+        point: coordinates,
+        name: null,
+        levelId: opening.properties.level_id,
+        ordinal: level.properties.ordinal,
+        hint: landmark ? { kind: "landmark", name: landmark.name } : void 0,
+        source: { type: "opening", id: opening.id }
+      };
     });
-    return results;
-  }
-  _searchLogical(query) {
-    const expression = parse(query, this.options);
-    const evaluate = (node, item, idx) => {
-      if (!node.children) {
-        const { keyId, searcher } = node;
-        const matches = this._findMatches({
-          key: this._keyStore.get(keyId),
-          value: this._myIndex.getValueForItemAtKeyId(item, keyId),
-          searcher
-        });
-        if (matches && matches.length) {
-          return [
-            {
-              idx,
-              item,
-              matches
-            }
-          ];
-        }
-        return [];
-      }
-      const res = [];
-      for (let i = 0, len = node.children.length; i < len; i += 1) {
-        const child = node.children[i];
-        const result = evaluate(child, item, idx);
-        if (result.length) {
-          res.push(...result);
-        } else if (node.operator === LogicalOperator.AND) {
-          return [];
-        }
-      }
-      return res;
+    return [startPoint, ...waypoints, endPoint];
+  };
+  const createHorizontalStep = (from, to) => {
+    const intermediary = findHorizontalIntermediary(from, to);
+    const intermediaryCategories = intermediary.map((unit) => unit.properties.category);
+    const intermediaryCategory = intermediaryCategories.length > 0 ? intermediaryCategories[0] : "unspecified";
+    const toward = getToward(from, to, intermediary);
+    const landmark = to.hint?.kind === "landmark" ? to.hint.name : null;
+    const path = stepPathUtils.findStepPath(from.point, to.point, intermediary);
+    const step = {
+      from,
+      to,
+      levelIds: [from.levelId],
+      ordinals: [from.ordinal],
+      intermediaryCategory,
+      description: describeHorizontalStep(intermediaryCategory, toward, landmark),
+      path: path.map((coord) => [...coord, from.ordinal * 9])
     };
-    const records = this._myIndex.records;
-    const resultMap = {};
-    const results = [];
-    records.forEach(({ $: item, i: idx }) => {
-      if (isDefined(item)) {
-        let expResults = evaluate(expression, item, idx);
-        if (expResults.length) {
-          if (!resultMap[idx]) {
-            resultMap[idx] = { idx, item, matches: [] };
-            results.push(resultMap[idx]);
-          }
-          expResults.forEach(({ matches }) => {
-            resultMap[idx].matches.push(...matches);
-          });
-        }
-      }
-    });
-    return results;
-  }
-  _searchObjectList(query) {
-    const searcher = createSearcher(query, this.options);
-    const { keys, records } = this._myIndex;
-    const results = [];
-    records.forEach(({ $: item, i: idx }) => {
-      if (!isDefined(item)) {
-        return;
-      }
-      let matches = [];
-      keys.forEach((key, keyIndex) => {
-        matches.push(
-          ...this._findMatches({
-            key,
-            value: item[keyIndex],
-            searcher
-          })
-        );
-      });
-      if (matches.length) {
-        results.push({
-          idx,
-          item,
-          matches
-        });
-      }
-    });
-    return results;
-  }
-  _findMatches({ key, value, searcher }) {
-    if (!isDefined(value)) {
-      return [];
-    }
-    let matches = [];
-    if (isArray(value)) {
-      value.forEach(({ v: text, i: idx, n: norm2 }) => {
-        if (!isDefined(text)) {
-          return;
-        }
-        const { isMatch, score, indices } = searcher.searchIn(text);
-        if (isMatch) {
-          matches.push({
-            score,
-            key,
-            value: text,
-            idx,
-            norm: norm2,
-            indices
-          });
-        }
-      });
-    } else {
-      const { v: text, n: norm2 } = value;
-      const { isMatch, score, indices } = searcher.searchIn(text);
-      if (isMatch) {
-        matches.push({ score, key, value: text, norm: norm2, indices });
-      }
+    return step;
+  };
+  const createVerticalStep = (from, to) => {
+    const intermediary = findVerticalIntermediary(from, to);
+    const intermediaryCategories = intermediary.map((unit) => unit.properties.category);
+    const intermediaryCategory = intermediaryCategories.length > 0 ? intermediaryCategories[0] : "unspecified";
+    const fromLevel = findByIdSync(from.levelId);
+    const toLevel = findByIdSync(to.levelId);
+    return {
+      from,
+      to,
+      levelIds: [from.levelId, to.levelId],
+      ordinals: [from.ordinal, to.ordinal],
+      intermediaryCategory,
+      description: describeVerticalStep(fromLevel, toLevel, intermediaryCategory),
+      path: [
+        [...from.point, from.ordinal * 9],
+        [...to.point, to.ordinal * 9]
+      ]
+    };
+  };
+  const isVertical = (from, to) => {
+    const fromLevel = findByIdSync(from.levelId);
+    const toLevel = findByIdSync(to.levelId);
+    return !!fromLevel && !!toLevel && fromLevel.properties.ordinal !== toLevel.properties.ordinal;
+  };
+  const toSteps = (waypoints) => {
+    let steps = [];
+    const t0_allSteps = performance.now();
+    for (let i = 0; i < waypoints.length - 1; i++) {
+      const from = waypoints[i];
+      const to = waypoints[i + 1];
+      const t0 = performance.now();
+      const step = isVertical(from, to) ? createVerticalStep(from, to) : createHorizontalStep(from, to);
+      steps.push(step);
+      const t1 = performance.now();
+      trace("nav", `  \u2502    \u251C\u2500 #${i}  ${from.id.padEnd(25)} \u2192 ${`(${step.intermediaryCategory})`.padEnd(12)} \u2192 ${to.id}`, t1 - t0);
+      trace("nav", `  \u2502    \u2502      ${step.description.text}`, void 0, "#bada55");
     }
-    return matches;
-  }
+    const simplifySteps = combineWalkwaySteps(steps);
+    const t1_allSteps = performance.now();
+    trace("nav", "  \u2502    \u2514\u2500 Total ", t1_allSteps - t0_allSteps);
+    return simplifySteps;
+  };
+  return {
+    // createSteps,
+    toWaypoints,
+    toSteps
+  };
 };
-Fuse.version = "7.1.0";
-Fuse.createIndex = createIndex;
-Fuse.parseIndex = parseIndex;
-Fuse.config = Config;
-{
-  Fuse.parseQuery = parse;
-}
-{
-  register(ExtendedSearch);
-}
 
-// src/data/search/utils/sanitizeInput.ts
-var sanitizeInput = (str) => str.replace(/[\u200E\u200F\u202A-\u202E\u2066-\u2069]/g, "").replace(/[\-–—_./()]+/g, "").normalize("NFC").trim();
+// src/data/navigate/utils/timeDistance.ts
+var import_length = __toESM(require("@turf/length"));
+var WALKING_SPEED = 1.4;
+var calculatePathLength = (feature2) => (0, import_length.default)(feature2, { units: "kilometers" }) * 1e3;
+var calculateTravelingDuration = (distance5) => {
+  const duration = distance5 / WALKING_SPEED;
+  const minutes = Math.round(duration / 60);
+  return minutes > 0 ? minutes : 1;
+};
+var calculateTotalDistance = (steps = []) => {
+  return steps.reduce((acc, { path }) => acc + calculatePathLength(lineString(path)), 0);
+};
+var calculateRoundedDistance = (distance5) => {
+  return Math.round(distance5 - distance5 % 25);
+};
 
-// src/data/search/getSearchClient.ts
-var getSearchClient = ({ occupants, amenities }) => {
-  const fuseAmenities = new Fuse(amenities, {
-    threshold: 0.2,
-    keys: [
-      { name: "properties.name", "weight": 1, getFn: (obj) => Object.values(obj.properties.name || {}) },
-      { name: "properties.category", "weight": 1 }
-    ]
-  });
-  const fuseOccupants = new Fuse(occupants, {
-    threshold: 0.25,
-    // 0.2 is too strict (can't find Mo-Mo Paradise with "momo" search string)
-    includeScore: true,
-    shouldSort: true,
-    keys: [
-      { name: "properties.name", "weight": 4, getFn: (obj) => Object.values(obj.properties.name || {}) },
-      { name: "properties.keywords", "weight": 0.5 },
-      { name: "properties.category", "weight": 0.25 },
-      { name: "properties.local_category_names", "weight": 0.25 },
-      { name: "properties.description", "weight": 0.25, getFn: (occ) => Object.values(occ.properties.description || {}) },
-      { name: "properties.unit_name", "weight": 0.25 },
-      { name: "properties.kiosk_name", "weight": 0.25 }
-    ]
-  });
-  const search2 = (value) => {
-    const sanitizedValue = sanitizeInput(value);
-    const matchedAmenities = fuseAmenities.search(sanitizedValue);
-    const matchedOccupants = fuseOccupants.search(sanitizedValue);
-    return [...matchedAmenities, ...matchedOccupants];
+// src/data/navigate/utils/createFindByIdSync.ts
+var createFindByIdSync = (data) => {
+  const { amenities = [], anchors = [], fixtures = [], levels = [], kiosks = [], relationships = [], occupants = [], openings = [], units } = data;
+  const featureById = /* @__PURE__ */ new Map();
+  const entries = [
+    ...amenities,
+    ...anchors,
+    ...fixtures,
+    ...levels,
+    ...kiosks,
+    ...relationships,
+    ...occupants,
+    ...openings,
+    ...units
+  ];
+  for (const f of entries) featureById.set(f.id, f);
+  const findByIdSync = (id) => {
+    return featureById.get(id);
+  };
+  return { findByIdSync };
+};
+
+// src/data/navigate/getNavigateClient.ts
+var getNavigateClient = (options) => {
+  const { data } = options;
+  const { levels, units } = data;
+  trace("nav", "\u2713 prepare");
+  const t0 = performance.now();
+  trace("nav", "  \u251C\u2500 createGraph (dijkstra)");
+  const { defaultGraph, accessibleGraph, addCoordinateOrdinalNode } = prepareGraph({ data });
+  const t1 = performance.now();
+  trace("nav", "  \u2502    \u2514\u2500 Total ", t1 - t0);
+  const t2 = performance.now();
+  const { findByIdSync } = createFindByIdSync(data);
+  const t3 = performance.now();
+  trace("nav", "  \u2514\u2500 findByIdSync", t3 - t2);
+  const findCoordinateOrdinalUnit = (params) => {
+    const [lat, lng, ordinal] = parseOrdinalCoordinate(params);
+    const levelIdsWithOrdinal = levels.filter((level) => level.properties.ordinal === ordinal).map((level) => level.id);
+    const unit = units.find((unit2) => levelIdsWithOrdinal.includes(unit2.properties.level_id) && (0, import_boolean_point_in_polygon4.booleanPointInPolygon)([lat, lng], unit2));
+    return unit;
+  };
+  const stepUtils = createStepUtils({ ...options, findByIdSync });
+  const findRoute = async (routeOriginParam, routeDestinationParam, options2) => {
+    if (!routeOriginParam || !routeDestinationParam) return null;
+    const graph = options2?.mode === "accessible" ? accessibleGraph : defaultGraph;
+    if (isCoordinateOrdinalString(routeOriginParam)) {
+      const walkwayUnit = findCoordinateOrdinalUnit(routeOriginParam);
+      addCoordinateOrdinalNode(routeOriginParam, walkwayUnit);
+    }
+    if (isCoordinateOrdinalString(routeDestinationParam)) {
+      const walkwayUnit = findCoordinateOrdinalUnit(routeDestinationParam);
+      addCoordinateOrdinalNode(routeDestinationParam, walkwayUnit);
+    }
+    try {
+      trace("nav", "\u2713 findRoute", 0);
+      const t02 = performance.now();
+      const path = graph.path(routeOriginParam, routeDestinationParam);
+      const t12 = performance.now();
+      trace("nav", "  \u251C\u2500 path (dijkstra)", t12 - t02);
+      const waypoints = stepUtils.toWaypoints(path);
+      console.log({ waypoints });
+      const t22 = performance.now();
+      trace("nav", "  \u251C\u2500 toWaypoints", t22 - t12);
+      trace("nav", "  \u251C\u2500 toSteps", 0);
+      const steps = stepUtils.toSteps(waypoints);
+      const t32 = performance.now();
+      const totalDistance = calculateTotalDistance(steps);
+      const roundedDistance = calculateRoundedDistance(totalDistance);
+      const duration = calculateTravelingDuration(totalDistance);
+      const t4 = performance.now();
+      trace("nav", "  \u2514\u2500 postProcess", t4 - t32);
+      return {
+        // origin: routeOrigin,
+        // destination: routeDestination,
+        description: null,
+        distance: roundedDistance,
+        duration,
+        steps
+      };
+    } catch (error) {
+      console.log(error);
+      throw error;
+    }
   };
   return {
-    search: search2
+    findRoute,
+    findByIdSync
   };
 };
 
 // src/data/getDataClient.ts
 var getDataClient = (options) => {
   let searchClient;
+  let navigateClient;
   const observers = /* @__PURE__ */ new Map();
   const queryClient = options.queryClient ?? new import_query_core.QueryClient();
   const { mode = "delivery", projectId, apiKey, baseUrl, previewToken } = options;
@@ -2115,17 +2414,17 @@ var getDataClient = (options) => {
   const internalFindById = async (id) => {
     if (id === null || id === void 0) return null;
     const featureType = id.slice(0, id.lastIndexOf("-"));
-    const feature = await queryClient.ensureQueryData({
+    const feature2 = await queryClient.ensureQueryData({
       queryKey: ["_deliveryapi", featureType, id],
       queryFn: async () => {
         const features = await internalFilterByType(featureType);
-        const feature2 = features.find(
+        const feature3 = features.find(
           (f) => f.id === id
         );
-        return feature2 ?? null;
+        return feature3 ?? null;
       }
     });
-    return feature;
+    return feature2;
   };
   const populator = createPopulator({ internalFindById, internalFilterByType });
   const registerObserver = (featureType, refetchInterval) => {
@@ -2174,8 +2473,8 @@ var getDataClient = (options) => {
   const createFindByIdQueryOptions = (featureType, id, params = {}, options2 = {}) => ({
     queryKey: [featureType, "detail", id, params],
     queryFn: async () => {
-      const feature = await internalFindById(id);
-      return params.populate === true ? await populator[featureType](feature) : Promise.resolve(feature);
+      const feature2 = await internalFindById(id);
+      return params.populate === true ? await populator[featureType](feature2) : Promise.resolve(feature2);
     },
     ...options2 ?? {}
   });
@@ -2193,8 +2492,8 @@ var getDataClient = (options) => {
       id,
       params
     );
-    const feature = await queryClient.ensureQueryData(findQueryOptions);
-    return feature;
+    const feature2 = await queryClient.ensureQueryData(findQueryOptions);
+    return feature2;
   }
   const searchFn = async (txt) => {
     if (!searchClient) {
@@ -2207,6 +2506,24 @@ var getDataClient = (options) => {
     }
     return searchClient.search(txt);
   };
+  const navigateFn = async (origin, destination) => {
+    if (!navigateClient) {
+      const [levels, occupants, openings, relationships, units, fixtures, kiosks, amenities, anchors] = await Promise.all([
+        filterByType("level"),
+        filterByType("occupant"),
+        filterByType("opening"),
+        filterByType("relationship"),
+        filterByType("unit"),
+        filterByType("fixture"),
+        filterByType("kiosk"),
+        filterByType("amenity"),
+        filterByType("anchor")
+      ]);
+      const haystack = { levels, occupants, openings, relationships, units, fixtures, kiosks, amenities, anchors };
+      navigateClient = getNavigateClient({ data: haystack });
+    }
+    return navigateClient.findRoute(origin, destination);
+  };
   return {
     projectId,
     queryClient,
@@ -2218,7 +2535,8 @@ var getDataClient = (options) => {
     _internalFindById: internalFindById,
     filterByType,
     findById,
-    search: searchFn
+    search: searchFn,
+    navigate: navigateFn
   };
 };
 // Annotate the CommonJS export names for ESM import in node: