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

package/dist/index.mjs

@@ -410,6 +410,19 @@ var findContainingUnit = (poi, units) => {
   );
   return unit;
 };
+var findContainingUnitAtPoint = (point2, levelId, units) => {
+  const unit = units.find(
+    (unit2) => {
+      try {
+        return unit2.properties.level_id === levelId && 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 = ({
@@ -582,6 +595,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;
@@ -599,19 +625,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);
@@ -688,1366 +701,1649 @@ 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 = (max2) => `Pattern length exceeds max of ${max2}.`;
-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
+import Fuse from "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 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 search = (value) => {
+    const sanitizedValue = sanitizeInput(value);
+    const matchedAmenities = fuseAmenities.search(sanitizedValue);
+    const matchedOccupants = fuseOccupants.search(sanitizedValue);
+    return [...matchedAmenities, ...matchedOccupants];
+  };
+  return {
+    search
+  };
 };
-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"));
-    }
-    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));
-      }
+
+// src/data/navigate/getNavigateClient.ts
+import { booleanPointInPolygon as booleanPointInPolygon4 } from "@turf/boolean-point-in-polygon";
+
+// src/data/navigate/graph/prepare.ts
+import _6 from "lodash";
+import DijstraGraph from "node-dijkstra";
+import { distance as distance2 } from "@turf/distance";
+import { center as turfCenter3 } from "@turf/center";
+
+// src/data/navigate/graph/nodemap/createTraversalNodeMap.ts
+import { distance as turfDistance } from "@turf/distance";
+import { center as turfCenter } from "@turf/center";
+import _ from "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
     }
-    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;
-    }
-    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);
-        }
-      } else if (path2.length) {
-        deepGet(value, path2, index + 1);
-      }
-    }
-  };
-  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
 };
-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
-};
-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
-};
-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/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;
 };
-var Config = {
-  ...BasicOptions,
-  ...MatchOptions,
-  ...FuzzyOptions,
-  ...AdvancedOptions
+
+// 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);
 };
-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/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 = turfDistance(
+            turfCenter(opening.geometry),
+            turfCenter(feature2.geometry),
+            { units: "meters" }
+          ) + (distanceOptions?.baseDistance ?? 0);
+          if (opening.id === feature2.id) continue;
+          _.set(relationshipGraph, `${opening.id}.${feature2.id}`, distance5);
+          _.set(relationshipGraph, `${feature2.id}.${opening.id}`, distance5);
+          counter++;
+        } catch (error) {
+          continue;
+        }
       }
-      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 relationshipGraph;
   };
-}
-var FuseIndex = class {
-  constructor({
-    getFn = Config.getFn,
-    fieldNormWeight = Config.fieldNormWeight
-  } = {}) {
-    this.norm = norm(fieldNormWeight, 3);
-    this.getFn = getFn;
-    this.isCreated = false;
-    this.setIndexRecords();
-  }
-  setSources(docs = []) {
-    this.docs = docs;
-  }
-  setIndexRecords(records = []) {
-    this.records = records;
-  }
-  setKeys(keys = []) {
-    this.keys = keys;
-    this._keysMap = {};
-    keys.forEach((key, idx) => {
-      this._keysMap[key.id] = idx;
-    });
-  }
-  create() {
-    if (this.isCreated || !this.docs.length) {
-      return;
-    }
-    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);
+  const t0 = performance.now();
+  const nodeMap = _.reduce(
+    unitOpenings,
+    (acc, openings, unitId) => {
+      const unit = units.find((unit2) => unit2.id === unitId);
+      const unitDistanceOption = getDistanceOptions(options.unitDistanceOptions, unit.properties.category);
+      return _.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
+import _2 from "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 };
       });
-    }
-    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);
-    }
-  }
-  // 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;
-    }
-  }
-  getValueForItemAtKeyId(item, keyId) {
-    return item[this._keysMap[keyId]];
-  }
-  size() {
-    return this.records.length;
-  }
-  _addString(doc, docIndex) {
-    if (!isDefined(doc) || isBlank(doc)) {
-      return;
-    }
-    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;
+      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;
           }
-          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 ;
+          _2.set(elevatorNodeMap, `${originOpening.id}.${opening.id}`, distance5);
+          _2.set(elevatorNodeMap, `${opening.id}.${originOpening.id}`, distance5);
+          counter++;
         }
-        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
-    };
+    } catch (err) {
+      console.log(err);
+      console.log("cannot create elevatorNodeMap for ", { relationship });
+    }
   }
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} escalator relationships`, t1 - t0);
+  return elevatorNodeMap;
 };
-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;
-}
-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 computeScore$1(pattern, {
-  errors = 0,
-  currentLocation = 0,
-  expectedLocation = 0,
-  distance = Config.distance,
-  ignoreLocation = Config.ignoreLocation
-} = {}) {
-  const accuracy = errors / pattern.length;
-  if (ignoreLocation) {
-    return accuracy;
-  }
-  const proximity = Math.abs(expectedLocation - currentLocation);
-  if (!distance) {
-    return proximity ? 1 : accuracy;
-  }
-  return accuracy + proximity / distance;
-}
-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]);
-      }
-      start = -1;
+
+// src/data/navigate/graph/nodemap/createEscalatorNodeMap.ts
+import set from "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;
+    set(nodeMap, `${origin.id}.${destination.id}`, distanceOptions.baseDistance);
+    if (direction === "undirected") {
+      set(nodeMap, `${destination.id}.${origin.id}`, distanceOptions.baseDistance);
     }
+    counter++;
   }
-  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;
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} escalator relationships`, t1 - t0);
+  return nodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createRampNodeMap.ts
+import set2 from "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;
+    set2(nodeMap, `${origin.id}.${destination.id}`, distanceOptions.baseDistance);
+    set2(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
+import _3 from "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;
+        }
+        _3.set(elevatorNodeMap, `${origin.id}.${opening.id}`, distance5);
+        _3.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
+        }
+      );
     }
   }
-  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);
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} stairs relationships`, t1 - t0);
+  return elevatorNodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createOccupantNodeMap.ts
+import _4 from "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) {
+      _4.set(nodeMap, `${roomId}.${occupant.id}`, 1e-3);
+      _4.set(nodeMap, `${occupant.id}.${roomId}`, 1e-3);
+      counter++;
     }
-    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);
+    for (const kioskId of occupantKioskIds) {
+      _4.set(nodeMap, `${kioskId}.${occupant.id}`, 1e-3);
+      _4.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;
+};
+
+// src/data/navigate/graph/nodemap/createPOINodeMaps.ts
+import { center as turfCenter2 } from "@turf/center";
+import { distance } from "@turf/distance";
+import _5 from "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 center8 = turfCenter2(feat);
+      for (const opening of openings) {
+        try {
+          const openingCenter = turfCenter2(opening);
+          const dis = distance(center8, openingCenter, { units: "meters" }) + BASE_POI_BASEDISTANCE;
+          _5.set(nodeMap, `${opening.id}.${feat.id}`, dis);
+          _5.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 score = computeScore$1(pattern, {
-      errors: i + 1,
-      currentLocation: expectedLocation,
-      expectedLocation,
-      distance,
-      ignoreLocation
-    });
-    if (score > currentThreshold) {
-      break;
-    }
-    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;
+  });
+  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;
+};
+
+// 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 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;
+  return out;
+};
+
+// src/data/navigate/graph/utils/createUnitOpenings.ts
+import uniqBy from "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, []);
     }
-    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;
-      }
-      if (remainder) {
-        const startIndex = len - MAX_BITS;
-        addChunk(this.pattern.substr(startIndex), startIndex);
-      }
-    } else {
-      addChunk(this.pattern, 0);
+    if (!relationshipMap.has(destinationId)) {
+      relationshipMap.set(destinationId, []);
     }
-  }
-  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]];
-      }
-      return result2;
+    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] = uniqBy(
+      [...openingConnections[unitId] || [], ...relationshipIntermediary],
+      "id"
+    );
+  });
+  return openingConnections;
+};
+
+// src/data/navigate/parsers.ts
+var parseOrdinalCoordinate = (id) => {
+  return id.slice(0, -1).split(",").map(Number);
+};
+
+// src/data/navigate/graph/prepare.ts
+var prepareGraph = (options) => {
+  const {
+    data: {
+      amenities = [],
+      anchors = [],
+      occupants = [],
+      relationships = [],
+      openings = [],
+      units = [],
+      kiosks = [],
+      levels = []
     }
-    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];
+  } = options;
+  const {
+    traversal: traversalRelationships = [],
+    escalator: escalatorRelationships = [],
+    ramp: rampRelationships = [],
+    elevator: elevatorRelationships = [],
+    stairs: stairsRelationships = []
+  } = _6.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 DijstraGraph(mergeNodeMap([
+    traversalNodeMap,
+    escalatorNodeMap,
+    rampNodeMap,
+    elevatorNodeMap,
+    stairNodeMap,
+    amenityNodeMap,
+    anchorsNodeMap,
+    kioskNodeMap,
+    unitNodeMap,
+    occupantNodeMap
+  ]));
+  const accessibleGraph = new DijstraGraph(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 = turfCenter3(opening);
+        const dis = distance2([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 });
       }
-    });
-    let result = {
-      isMatch: hasMatches,
-      score: hasMatches ? totalScore / this.chunks.length : 1
-    };
-    if (hasMatches && includeMatches) {
-      result.indices = allIndices;
     }
-    return result;
-  }
+  };
+  return { defaultGraph, accessibleGraph, unitOpenings, addCoordinateOrdinalNode };
 };
-var BaseMatch = class {
-  constructor(pattern) {
-    this.pattern = pattern;
-  }
-  static isMultiMatch(pattern) {
-    return getMatch(pattern, this.multiRegex);
-  }
-  static isSingleMatch(pattern) {
-    return getMatch(pattern, this.singleRegex);
-  }
-  search() {
-  }
-};
-function getMatch(pattern, exp) {
-  const matches = pattern.match(exp);
-  return matches ? matches[1] : null;
-}
-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]
-    };
-  }
+
+// src/data/navigate/steps/createStepUtils.ts
+import { capitalize } from "lodash";
+import _intersectionBy from "lodash/intersectionBy";
+import { center as center6 } from "@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 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 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 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 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
+  };
 };
-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]
-    };
-  }
+
+// src/data/navigate/steps/path/index.ts
+import _7 from "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
 };
-var SuffixExactMatch = class extends BaseMatch {
-  constructor(pattern) {
-    super(pattern);
+function feature(geom, properties, options = {}) {
+  const feat = { type: "Feature" };
+  if (options.id === 0 || options.id) {
+    feat.id = options.id;
   }
-  static get type() {
-    return "suffix-exact";
+  if (options.bbox) {
+    feat.bbox = options.bbox;
   }
-  static get multiRegex() {
-    return /^"(.*)"\$$/;
+  feat.properties = properties || {};
+  feat.geometry = geom;
+  return feat;
+}
+function point(coordinates, properties, options = {}) {
+  if (!coordinates) {
+    throw new Error("coordinates is required");
   }
-  static get singleRegex() {
-    return /^(.*)\$$/;
+  if (!Array.isArray(coordinates)) {
+    throw new Error("coordinates must be an Array");
   }
-  search(text) {
-    const isMatch = text.endsWith(this.pattern);
-    return {
-      isMatch,
-      score: isMatch ? 0 : 1,
-      indices: [text.length - this.pattern.length, text.length - 1]
-    };
+  if (coordinates.length < 2) {
+    throw new Error("coordinates must be at least 2 numbers long");
   }
-};
-var InverseSuffixExactMatch = class extends BaseMatch {
-  constructor(pattern) {
-    super(pattern);
+  if (!isNumber(coordinates[0]) || !isNumber(coordinates[1])) {
+    throw new Error("coordinates must contain numbers");
   }
-  static get type() {
-    return "inverse-suffix-exact";
+  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."
+      );
+    }
+    if (ring[ring.length - 1].length !== ring[0].length) {
+      throw new Error("First and last Position are not equivalent.");
+    }
+    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.");
+      }
+    }
   }
-  static get multiRegex() {
-    return /^!"(.*)"\$$/;
+  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");
   }
-  static get singleRegex() {
-    return /^!(.*)\$$/;
+  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;
   }
-  search(text) {
-    const isMatch = !text.endsWith(this.pattern);
-    return {
-      isMatch,
-      score: isMatch ? 0 : 1,
-      indices: [0, text.length - 1]
-    };
+  if (options.bbox) {
+    fc.bbox = options.bbox;
   }
-};
-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
-    });
+  fc.features = features;
+  return fc;
+}
+function multiPoint(coordinates, properties, options = {}) {
+  const geom = {
+    type: "MultiPoint",
+    coordinates
+  };
+  return feature(geom, properties, options);
+}
+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];
+    }
   }
-  static get type() {
-    return "fuzzy";
+  if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
+    return [...coord];
   }
-  static get multiRegex() {
-    return /^"(.*)"$/;
+  throw new Error("coord must be GeoJSON Point or an Array of numbers");
+}
+function getGeom(geojson) {
+  if (geojson.type === "Feature") {
+    return geojson.geometry;
   }
-  static get singleRegex() {
-    return /^(.*)$/;
+  return geojson;
+}
+function getType(geojson, _name) {
+  if (geojson.type === "FeatureCollection") {
+    return "FeatureCollection";
   }
-  search(text) {
-    return this._bitapSearch.searchIn(text);
+  if (geojson.type === "GeometryCollection") {
+    return "GeometryCollection";
   }
-};
-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]);
-    }
-    const isMatch = !!indices.length;
-    return {
-      isMatch,
-      score: isMatch ? 0 : 1,
-      indices
-    };
+  if (geojson.type === "Feature" && geojson.geometry !== null) {
+    return geojson.geometry.type;
   }
-};
-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 geojson.type;
 }
-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(_6, 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);
+
+// src/data/navigate/steps/path/index.ts
+import difference from "@turf/difference";
+import envelope from "@turf/envelope";
+import booleanOverlap from "@turf/boolean-overlap";
+import booleanIntersects from "@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++;
           }
-        } 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;
+        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");
       }
     }
-    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);
-    }
+
+// ../../node_modules/@turf/bbox/dist/esm/index.js
+function bbox(geojson, options = {}) {
+  if (geojson.bbox != null && true !== options.recompute) {
+    return geojson.bbox;
   }
-  return new BitapSearch(pattern, options);
-}
-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));
+  const result = [Infinity, Infinity, -Infinity, -Infinity];
+  coordEach(geojson, (coord) => {
+    if (result[0] > coord[0]) {
+      result[0] = coord[0];
     }
-    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);
-      }
-      return obj;
+    if (result[1] > coord[1]) {
+      result[1] = coord[1];
+    }
+    if (result[2] < coord[0]) {
+      result[2] = coord[0];
+    }
+    if (result[3] < coord[1]) {
+      result[3] = coord[1];
     }
-    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);
-}
-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;
   });
+  return result;
 }
-function transformMatches(result, data) {
-  const matches = result.matches;
-  data.matches = [];
-  if (!isDefined(matches)) {
-    return;
-  }
-  matches.forEach((match) => {
-    if (!isDefined(match.indices) || !match.indices.length) {
-      return;
-    }
-    const { indices, value } = match;
-    let obj = {
-      indices,
-      value
-    };
-    if (match.key) {
-      obj.key = match.key.src;
+var index_default = bbox;
+
+// src/data/navigate/steps/path/turf/shortestPath.ts
+import booleanPointInPolygon3 from "@turf/boolean-point-in-polygon";
+import distance3 from "@turf/distance";
+import scale from "@turf/transform-scale";
+import union from "@turf/union";
+import bboxPolygon from "@turf/bbox-polygon";
+import { cleanCoords } from "@turf/clean-coords";
+import PF from "pathfinding";
+import set3 from "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 (e2 < dx) {
+        err += dx;
+        ny += sy;
+        movedY = true;
+      }
+      if (movedX && movedY) {
+        if (!isWalkable(nx, y0) || !isWalkable(x0, ny)) return false;
+      }
+      x0 = nx;
+      y0 = ny;
     }
-    if (match.idx > -1) {
-      obj.refIndex = match.idx;
+    return true;
+  }
+  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;
     }
-    data.matches.push(obj);
-  });
+    out.push(path[best]);
+    i = best;
+  }
+  return out;
 }
-function transformScore(result, data) {
-  data.score = result.score;
+
+// 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;
 }
-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);
-      });
+
+// 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]);
     }
-    return data;
-  });
+  }
+  return out;
 }
-var Fuse = class {
-  constructor(docs, options = {}, index) {
-    this.options = { ...Config, ...options };
-    if (this.options.useExtendedSearch && false) {
-      throw new Error(EXTENDED_SEARCH_UNAVAILABLE);
+
+// 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]);
+      }
     }
-    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);
+  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]);
+      }
     }
-    this._myIndex = index || createIndex(this.options.keys, this._docs, {
-      getFn: this.options.getFn,
-      fieldNormWeight: this.options.fieldNormWeight
-    });
   }
-  add(doc) {
-    if (!isDefined(doc)) {
-      return;
-    }
-    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);
+  return dist;
+}
+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 results;
-  }
-  removeAt(idx) {
-    this._docs.splice(idx, 1);
-    this._myIndex.removeAt(idx);
   }
-  getIndex() {
-    return this._myIndex;
+  return best;
+}
+function centerlineSnapPath(path, clearance, isWalkableCell, radius = 4) {
+  const snapped = path.map((p) => snapPointToClearancePeak(p, clearance, isWalkableCell, radius));
+  return snapped;
+}
+
+// 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(scale(bboxPolygon(index_default(collection)), 1.15));
+  if (!resolution) {
+    const width = distance3([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 / distance3([west, south], [east, south], options);
+  const cellWidth = xFraction * (east - west);
+  const yFraction = resolution / distance3([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 = union(
+        featureCollection([combinedObstacle, nextObstacleFeature])
+      );
+    } catch (e) {
+      console.log(e);
+    }
   }
-  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);
+  while (totalRounds--) {
+    pt = point([currentX, currentY]);
+    isInsideObstacle = booleanPointInPolygon3(pt, combinedObstacle);
+    set3(matrix, `[${row}][${column}]`, isInsideObstacle ? 1 : 0);
+    set3(pointMatrix, `[${row}][${column}]`, `${currentX}|${currentY}`);
+    distStart = distance3(pt, start);
+    if (!isInsideObstacle && distStart < minDistStart) {
+      minDistStart = distStart;
+      closestToStart = { x: column, y: row };
     }
-    if (isNumber(limit) && limit > -1) {
-      results = results.slice(0, limit);
+    distEnd = distance3(pt, end);
+    if (!isInsideObstacle && distEnd < minDistEnd) {
+      minDistEnd = distEnd;
+      closestToEnd = { x: column, y: row };
+    }
+    if (column < roundLoopX) {
+      currentX += cellWidth;
+      column++;
+      continue;
+    }
+    if (row < roundLoopY) {
+      currentY -= cellHeight;
+      currentX = west + deltaX;
+      column = 0;
+      row++;
     }
-    return format(results, this._docs, {
-      includeMatches,
-      includeScore
-    });
   }
-  _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 finder = new PF.AStarFinder({
+    allowDiagonal: true,
+    dontCrossCorners: true,
+    heuristic: PF.Heuristic.euclidean
+  });
+  const grid = new PF.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 cleanCoords(lineString(path));
+}
+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));
     });
-    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;
-    };
-    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);
-          });
+  };
+  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 && (booleanOverlap(intermediaryUnit, feature2) || booleanIntersects(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 = envelope(intermediaryUnit);
+    const walkwayPerimeter = difference(
+      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
     });
-    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
-        });
-      }
+    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,
+      _7.compact(exceptionFeatureIds)
+    );
+    const line = findPathOnArea(from, to, {
+      resolution,
+      obstacles
     });
-    return results;
+    return line.geometry.coordinates;
+  };
+  return {
+    findStepPath
+  };
+};
+
+// src/data/navigate/landmark/createLandmarkUtils.ts
+import { center as center3 } from "@turf/center";
+import distance4 from "@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: center3(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: distance4(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
+import { center as center4 } from "@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: center4(opening).geometry.coordinates,
+        levelId: opening.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "opening", id: opening.id }
+      },
+      path.slice(3)
+    ];
   }
-  _findMatches({ key, value, searcher }) {
-    if (!isDefined(value)) {
-      return [];
+  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: center4(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
+import { center as center5 } from "@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: center5(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: center5(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
+import uniq from "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;
     }
-    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
-          });
-        }
+    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: uniq([...thisStep.levelIds, ...nextStep.levelIds]),
+        ordinals: uniq([...thisStep.ordinals, ...nextStep.ordinals]),
+        intermediaryCategory: "walkway",
+        description: nextStep.description,
+        path: [
+          ...thisStep.path,
+          ...nextStep.path
+        ]
       });
+      i++;
     } 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 });
-      }
+      result.push(thisStep);
     }
-    return matches;
   }
+  return result;
 };
-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/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 = _intersectionBy(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 (to.source.type !== "opening") {
+      const unit = findContainingUnitAtPoint(to.point, to.levelId, units);
+      return unit ? [unit] : [];
+    }
+    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;
+    });
+    const intermediaryTypeAndId = relationship.properties.intermediary;
+    return intermediaryTypeAndId.map(({ id }) => findByIdSync(id));
+  };
+  const formatCategoryLabel = (category) => {
+    return 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 = center6(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 [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])
+    };
+    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");
+    }
+    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
+  };
+};
 
-// 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/timeDistance.ts
+import calculateLength from "@turf/length";
+var WALKING_SPEED = 1.4;
+var calculatePathLength = (feature2) => calculateLength(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/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) && booleanPointInPolygon4([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 QueryClient();
   const { mode = "delivery", projectId, apiKey, baseUrl, previewToken } = options;
@@ -2170,6 +2466,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,
@@ -2181,7 +2495,8 @@ var getDataClient = (options) => {
     _internalFindById: internalFindById,
     filterByType,
     findById,
-    search: searchFn
+    search: searchFn,
+    navigate: navigateFn
   };
 };
 
@@ -2196,115 +2511,9 @@ import {
 } from "maptalks-gl";
 import "@maptalks/transcoders.draco";
 import TWEEN from "@tweenjs/tween.js";
-import _5 from "lodash";
-
-// 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;
-}
-function point(coordinates, properties, options = {}) {
-  if (!coordinates) {
-    throw new Error("coordinates is required");
-  }
-  if (!Array.isArray(coordinates)) {
-    throw new Error("coordinates must be an Array");
-  }
-  if (coordinates.length < 2) {
-    throw new Error("coordinates must be at least 2 numbers long");
-  }
-  if (!isNumber2(coordinates[0]) || !isNumber2(coordinates[1])) {
-    throw new Error("coordinates must contain numbers");
-  }
-  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."
-      );
-    }
-    if (ring[ring.length - 1].length !== ring[0].length) {
-      throw new Error("First and last Position are not equivalent.");
-    }
-    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.");
-      }
-    }
-  }
-  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");
-  }
-  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;
-  }
-  if (options.bbox) {
-    fc.bbox = options.bbox;
-  }
-  fc.features = features;
-  return fc;
-}
-function multiPoint(coordinates, properties, options = {}) {
-  const geom = {
-    type: "MultiPoint",
-    coordinates
-  };
-  return feature(geom, properties, options);
-}
-function isNumber2(num) {
-  return !isNaN(num) && num !== null && !Array.isArray(num);
-}
-
-// src/IndoorMap/IndoorMap.ts
-import turfDistance from "@turf/distance";
-import turfCenter3 from "@turf/center";
+import _13 from "lodash";
+import turfDistance2 from "@turf/distance";
+import turfCenter6 from "@turf/center";
 import { PerspectiveCamera } from "three";
 import { ThreeLayer as ThreeLayer5 } from "maptalks.three";
 
@@ -2383,7 +2592,7 @@ var VENUE_EVENTS = {
 };
 
 // src/IndoorMap/utils/createElements.js
-import _4 from "lodash";
+import _12 from "lodash";
 import {
   Polygon,
   MultiPolygon,
@@ -2393,7 +2602,7 @@ import {
   MultiLineString,
   ui
 } from "maptalks";
-import turfCenter from "@turf/center";
+import turfCenter4 from "@turf/center";
 import turfBuffer from "@turf/buffer";
 import {
   TextureLoader as TextureLoader2,
@@ -2413,7 +2622,7 @@ import {
   SpriteMaterial,
   Sprite
 } from "three";
-import _ from "lodash";
+import _9 from "lodash";
 var OPTIONS = {
   altitude: 25,
   scale: 15e-5,
@@ -2439,14 +2648,14 @@ var Billboard = class extends BaseObject {
     this._initOptions(options);
     const {
       altitude = OPTIONS.altitude,
-      scale: scale2 = OPTIONS.scale,
+      scale: scale3 = OPTIONS.scale,
       alphaTest = OPTIONS.alphaTest,
       legColor = OPTIONS.legColor,
       showLeg = OPTIONS.showLeg
     } = options;
     this.properties = { ...properties };
     this._createGroup();
-    const divider = _.clamp(window.innerWidth / 375 / 1.75, 1, 1.7);
+    const divider = _9.clamp(window.innerWidth / 375 / 1.75, 1, 1.7);
     if (showLeg) {
       const lineMaterial = new LineBasicMaterial({
         color: legColor,
@@ -2473,17 +2682,17 @@ var Billboard = class extends BaseObject {
       const sprite = new Sprite(material);
       sprite.material.sizeAttenuation = false;
       sprite.scale.set(
-        scale2 * naturalWidth / divider,
-        scale2 * naturalHeight / divider,
+        scale3 * naturalWidth / divider,
+        scale3 * naturalHeight / divider,
         1
       );
       this.getObject3d().add(sprite);
     });
     const z = layer.altitudeToVector3(altitude, altitude).x;
     const position = layer.coordinateToVector3(coordinate, z);
-    _.set(this.properties, "default.position", position);
-    _.set(this.properties, "default.altitude", altitude);
-    _.set(this.properties, "default.scale", scale2);
+    _9.set(this.properties, "default.position", position);
+    _9.set(this.properties, "default.altitude", altitude);
+    _9.set(this.properties, "default.scale", scale3);
     this.getObject3d().position.copy(position);
   }
   setLineHeight(altitude) {
@@ -2499,7 +2708,7 @@ var Billboard = class extends BaseObject {
 // src/IndoorMap/object3d/SpriteMarker.ts
 import { BaseObject as BaseObject2 } from "maptalks.three";
 import { Sprite as Sprite2, SpriteMaterial as SpriteMaterial2 } from "three";
-import _2 from "lodash";
+import _10 from "lodash";
 var DEFAULT_SCALE = 0.05;
 var DEFAULT_ALTITUDE = 0;
 var DEFAULT_ALPHATEST = 0.3;
@@ -2523,23 +2732,23 @@ var SpriteMarker = class extends BaseObject2 {
     this._createGroup();
     const {
       altitude = DEFAULT_OPTIONS.altitude,
-      scale: scale2 = DEFAULT_OPTIONS.scale,
+      scale: scale3 = DEFAULT_OPTIONS.scale,
       highlight = DEFAULT_OPTIONS.highlight,
       alphaTest = DEFAULT_OPTIONS.alphaTest
     } = options;
     this.properties = { ...properties };
     const modifiedAltitude = altitude + 2;
-    this.#default = { options: { scale: scale2, altitude: modifiedAltitude }, material };
-    this.#highlight = _2.merge({}, DEFAULT_OPTIONS.highlight, highlight);
+    this.#default = { options: { scale: scale3, altitude: modifiedAltitude }, material };
+    this.#highlight = _10.merge({}, DEFAULT_OPTIONS.highlight, highlight);
     if (material && material instanceof SpriteMaterial2)
       material.alphaTest = alphaTest;
     const sprite = new Sprite2(material);
-    sprite.scale.set(scale2, scale2, scale2);
+    sprite.scale.set(scale3, scale3, scale3);
     const obj3d = this.getObject3d();
     obj3d.add(sprite);
     const z = layer.altitudeToVector3(modifiedAltitude, modifiedAltitude).x;
     const position = layer.coordinateToVector3(coordinate, z);
-    _2.set(this.properties, "default.position", position);
+    _10.set(this.properties, "default.position", position);
     this.getObject3d().position.copy(position);
   }
   // Different objects need to implement their own methods
@@ -2680,15 +2889,15 @@ var NavigationPath = class extends BaseObject3 {
 };
 
 // src/IndoorMap/utils/geometry.ts
-import center3 from "@turf/center";
-import _3 from "lodash";
+import center7 from "@turf/center";
+import _11 from "lodash";
 import turfLineOffset from "@turf/line-offset";
 var getCenterFromGeometry = (geometry) => {
   try {
     const { type = null, coordinates = null } = geometry;
     if (!type || !coordinates) return null;
-    const centerPoint = center3(geometry);
-    return _3.get(centerPoint, "geometry.coordinates");
+    const centerPoint = center7(geometry);
+    return _11.get(centerPoint, "geometry.coordinates");
   } catch (error) {
     return null;
   }
@@ -2734,8 +2943,8 @@ var createSVGPathFromMarkerSymbol = (style) => {
     markerFill,
     markerPath
   } = style;
-  const scale2 = markerWidth / 24;
-  return `<path d="${markerPath}" style="transform:translate(${markerDx}px, ${markerDy}px) scale(${scale2})" fill="${markerFill}"/>`;
+  const scale3 = markerWidth / 24;
+  return `<path d="${markerPath}" style="transform:translate(${markerDx}px, ${markerDy}px) scale(${scale3})" fill="${markerFill}"/>`;
 };
 
 // src/IndoorMap/utils/createElements.js
@@ -2839,7 +3048,7 @@ var createWaterFixture = (feature2, style, options = {}) => {
   const { geometry, properties } = feature2;
   const { allowOverride, inheritFillColorToLine, zIndex } = options;
   const symbolStyle = { ...style };
-  if (allowOverride) _4.merge(symbolStyle, properties.style);
+  if (allowOverride) _12.merge(symbolStyle, properties.style);
   if (inheritFillColorToLine) symbolStyle.lineColor = symbolStyle.polygonFill;
   return new GeometryType[geometry.type](geometry.coordinates, {
     properties: {
@@ -2855,7 +3064,7 @@ var createVegetationFixture = (feature2, style, options = {}) => {
   const { geometry, properties } = feature2;
   const { allowOverride, inheritFillColorToLine, zIndex } = options;
   const symbolStyle = { ...style };
-  if (allowOverride) _4.merge(symbolStyle, properties.style);
+  if (allowOverride) _12.merge(symbolStyle, properties.style);
   if (inheritFillColorToLine) symbolStyle.lineColor = symbolStyle.polygonFill;
   return new GeometryType[geometry.type](geometry.coordinates, {
     properties: {
@@ -2872,8 +3081,8 @@ var createObstructionalFixture = (feature2, style = {}, options = {}) => {
   const { model3d } = properties;
   const { allowOverride, inheritFillColorToLine, zIndex } = options;
   const symbolStyle = { ...style };
-  if (!_4.isEmpty(model3d)) return;
-  if (allowOverride) _4.merge(symbolStyle, properties.style);
+  if (!_12.isEmpty(model3d)) return;
+  if (allowOverride) _12.merge(symbolStyle, properties.style);
   if (inheritFillColorToLine) symbolStyle.lineColor = symbolStyle.polygonFill;
   if (geometry.type === "LineString") {
     const polygon2 = createPolygonFromLineString(geometry);
@@ -2943,7 +3152,7 @@ var createPrincipalOpening = (feature2, style, options = {}) => {
   const { geometry, properties } = feature2;
   const { allowOverride, zIndex } = options;
   const symbolStyle = { ...style };
-  if (allowOverride) _4.merge(symbolStyle, properties.style);
+  if (allowOverride) _12.merge(symbolStyle, properties.style);
   try {
     return new LineString(geometry.coordinates, {
       properties: {
@@ -2960,7 +3169,7 @@ var createEmergencyExitOpening = (feature2, style, options = {}) => {
   const { geometry, properties } = feature2;
   const { allowOverride, zIndex } = options;
   const symbolStyle = { ...style };
-  if (allowOverride) _4.merge(symbolStyle, properties.style);
+  if (allowOverride) _12.merge(symbolStyle, properties.style);
   try {
     return new LineString(geometry.coordinates, {
       properties: {
@@ -2977,7 +3186,7 @@ var createPedestrianOpening = (feature2, style, options = {}) => {
   const { geometry, properties, id } = feature2;
   const { allowOverride, zIndex } = options;
   const symbolStyle = { ...style };
-  if (allowOverride) _4.merge(symbolStyle, properties.style);
+  if (allowOverride) _12.merge(symbolStyle, properties.style);
   try {
     return new LineString(geometry.coordinates, {
       properties: {
@@ -3015,9 +3224,9 @@ var create3DMarker = (coordinates, options, material, threeLayer, markerProperti
 };
 var getExtrudeConfigByFeature = (baseExtrudeConfig, feature2 = {}) => {
   const { feature_type: featureType } = feature2;
-  const featureExtrudeConfig = _4.get(feature2, "properties.extrude");
-  const featureCategory = _4.get(feature2, "properties.category");
-  const baseFeatureExtrudeConfig = _4.get(
+  const featureExtrudeConfig = _12.get(feature2, "properties.extrude");
+  const featureCategory = _12.get(feature2, "properties.category");
+  const baseFeatureExtrudeConfig = _12.get(
     baseExtrudeConfig,
     `${featureType}.${featureCategory || featureType}`
   );
@@ -3075,50 +3284,50 @@ var createStyledUIMarkerElement = ({
 var styledFeatureGenerator = (mapTheme) => {
   const getElementSymbol = (key) => {
     const [featureType] = key.split(".");
-    const featureTypeTheme = _4.get(mapTheme, `${featureType}.geometry.symbol`);
+    const featureTypeTheme = _12.get(mapTheme, `${featureType}.geometry.symbol`);
     if (featureType === key) return featureTypeTheme;
-    const categoryTheme = _4.get(mapTheme, `${key}.geometry.symbol`);
-    return _4.merge({}, featureTypeTheme, categoryTheme);
+    const categoryTheme = _12.get(mapTheme, `${key}.geometry.symbol`);
+    return _12.merge({}, featureTypeTheme, categoryTheme);
   };
   const getLabelSymbol = (key) => {
     const [featureType] = key.split(".");
-    const featureTypeTheme = _4.get(mapTheme, `${featureType}.label`);
-    const categoryTheme = _4.get(mapTheme, `${key}.label`);
-    const mergedSymbol = _4.merge({}, featureTypeTheme, categoryTheme);
-    let symbols = _4.values(_4.map(mergedSymbol, "symbol"));
+    const featureTypeTheme = _12.get(mapTheme, `${featureType}.label`);
+    const categoryTheme = _12.get(mapTheme, `${key}.label`);
+    const mergedSymbol = _12.merge({}, featureTypeTheme, categoryTheme);
+    let symbols = _12.values(_12.map(mergedSymbol, "symbol"));
     const markerIndexToMove = symbols.findIndex(
       ({ elementType }) => elementType === "label.marker"
     );
     if (markerIndexToMove >= 0) {
-      const markerSymbolToMove = _4.pullAt(symbols, markerIndexToMove)[0];
+      const markerSymbolToMove = _12.pullAt(symbols, markerIndexToMove)[0];
       symbols.push(markerSymbolToMove);
     }
     return symbols;
   };
   const getUIMarkerSymbol = (key) => {
     const [featureType] = key.split(".");
-    const featureTypeTheme = _4.get(mapTheme, `${featureType}.ui.marker`);
-    const categoryTheme = _4.get(mapTheme, `${key}.ui.marker`);
-    const mergedSymbol = _4.merge({}, featureTypeTheme, categoryTheme);
-    const symbol = _4.get(mergedSymbol, "symbol");
+    const featureTypeTheme = _12.get(mapTheme, `${featureType}.ui.marker`);
+    const categoryTheme = _12.get(mapTheme, `${key}.ui.marker`);
+    const mergedSymbol = _12.merge({}, featureTypeTheme, categoryTheme);
+    const symbol = _12.get(mergedSymbol, "symbol");
     return symbol;
   };
   const getUIMarkerOptions = (key) => {
     const [featureType] = key.split(".");
-    const featureTypeTheme = _4.get(mapTheme, `${featureType}.ui.marker`);
-    const categoryTheme = _4.get(mapTheme, `${key}.ui.marker`);
-    const mergedSymbol = _4.merge({}, featureTypeTheme, categoryTheme);
-    const options = _4.get(mergedSymbol, "options");
+    const featureTypeTheme = _12.get(mapTheme, `${featureType}.ui.marker`);
+    const categoryTheme = _12.get(mapTheme, `${key}.ui.marker`);
+    const mergedSymbol = _12.merge({}, featureTypeTheme, categoryTheme);
+    const options = _12.get(mergedSymbol, "options");
     return options;
   };
   const getLabelOptions = (key) => {
     const [featureType] = key.split(".");
-    const featureTypeSymbol = _4.get(mapTheme, `${featureType}.label`);
-    const categorySymbol = _4.get(mapTheme, `${key}.label`);
-    const mergedSymbol = _4.merge({}, featureTypeSymbol, categorySymbol);
-    return _4.reduce(
+    const featureTypeSymbol = _12.get(mapTheme, `${featureType}.label`);
+    const categorySymbol = _12.get(mapTheme, `${key}.label`);
+    const mergedSymbol = _12.merge({}, featureTypeSymbol, categorySymbol);
+    return _12.reduce(
       mergedSymbol,
-      (acc, symbol) => ({ ...acc, ..._4.get(symbol, "options", {}) }),
+      (acc, symbol) => ({ ...acc, ..._12.get(symbol, "options", {}) }),
       {}
     );
   };
@@ -3133,13 +3342,13 @@ var styledFeatureGenerator = (mapTheme) => {
   };
   const generateSpriteHighlightMarkerOption = () => {
     return SPRITE_HIGHLIGHT_MARKER_FEATURE.reduce((acc, featCate) => {
-      const categoryKey = _4.last(featCate.split("-"));
+      const categoryKey = _12.last(featCate.split("-"));
       const defaultLabelSymbol = getLabelSymbol(categoryKey);
       const highlightLabelSymbol = getLabelSymbol(featCate);
       const [defaultBase, defaultIcon] = defaultLabelSymbol;
       const [highlightBase, highlightIcon] = highlightLabelSymbol;
-      const base = _4.merge({}, defaultBase, highlightBase);
-      const icon = _4.merge({}, defaultIcon, highlightIcon);
+      const base = _12.merge({}, defaultBase, highlightBase);
+      const icon = _12.merge({}, defaultIcon, highlightIcon);
       const material = createSpriteMaterialByLabelSymbol([base, icon]);
       const options = getLabelOptions(featCate);
       return { ...acc, [featCate]: { material, options } };
@@ -3149,32 +3358,32 @@ var styledFeatureGenerator = (mapTheme) => {
   const spriteHighlightMarkerOptionObj = generateSpriteHighlightMarkerOption();
   const getElementOptions = (key) => {
     const [featureType] = key.split(".");
-    const featureTypeOptions = _4.get(
+    const featureTypeOptions = _12.get(
       mapTheme,
       `${featureType}.geometry.options`
     );
-    const categoryOptions = _4.get(mapTheme, `${key}.geometry.options`);
-    return _4.merge({}, featureTypeOptions, categoryOptions);
+    const categoryOptions = _12.get(mapTheme, `${key}.geometry.options`);
+    return _12.merge({}, featureTypeOptions, categoryOptions);
   };
   const createOccupantMarker = (feature2, locatedFeature, mapConfig) => {
     const { textMarkerType, featureExtrudeConfig } = getFeatureMarkerConfig(
       feature2,
       mapConfig
     );
-    const markerHeight = _4.get(featureExtrudeConfig, "height", 0);
+    const markerHeight = _12.get(featureExtrudeConfig, "height", 0);
     const { properties, id, feature_type } = feature2;
     if (!properties.anchor) return;
-    const mainLocationId = _4.get(properties, "unit.id") || _4.get(properties, "kiosk.id");
+    const mainLocationId = _12.get(properties, "unit.id") || _12.get(properties, "kiosk.id");
     const isMainLocationFeature = mainLocationId === locatedFeature?.id;
     const { geometry: mainLocationGeometry } = properties?.anchor;
-    const geometry = isMainLocationFeature ? mainLocationGeometry : turfCenter(locatedFeature)?.geometry;
+    const geometry = isMainLocationFeature ? mainLocationGeometry : turfCenter4(locatedFeature)?.geometry;
     const baseProperties = {
       id,
       feature_type,
       category: properties.category,
       altitude: getAltitude(properties)
     };
-    const occupantName = _4.isEmpty(properties.short_name) ? properties.name : properties.short_name;
+    const occupantName = _12.isEmpty(properties.short_name) ? properties.name : properties.short_name;
     if (locatedFeature) {
       const { feature_type: feature_type2, properties: properties2 } = locatedFeature;
       const { category } = properties2;
@@ -3188,21 +3397,21 @@ var styledFeatureGenerator = (mapTheme) => {
       }
       return requestedType;
     };
-    const logoUrl = _4.get(properties, "logo.url");
-    const requestedRenderType = _4.get(properties, "render_type", "Name");
+    const logoUrl = _12.get(properties, "logo.url");
+    const requestedRenderType = _12.get(properties, "render_type", "Name");
     const renderType = getValidatedRenderType(requestedRenderType, logoUrl);
     if (renderType === "Label") return null;
     const renderPriority = properties.render_priority || 3;
-    const labelSymbol = getLabelSymbol(`occupant-${_4.toLower(renderType)}`);
-    const markerSymbol = _4.last(labelSymbol);
-    const coordinates = _4.get(geometry, "coordinates");
+    const labelSymbol = getLabelSymbol(`occupant-${_12.toLower(renderType)}`);
+    const markerSymbol = _12.last(labelSymbol);
+    const coordinates = _12.get(geometry, "coordinates");
     const priorityLabelSymbol = getLabelSymbol(
-      `occupant-${_4.toLower(renderType)}-${renderPriority}`
+      `occupant-${_12.toLower(renderType)}-${renderPriority}`
     );
-    const priorityMarkerSymbol = _4.last(priorityLabelSymbol) || {};
+    const priorityMarkerSymbol = _12.last(priorityLabelSymbol) || {};
     switch (renderType) {
       case "Logo":
-        _4.set(priorityMarkerSymbol, "markerFile", logoUrl);
+        _12.set(priorityMarkerSymbol, "markerFile", logoUrl);
         return new Marker(coordinates, {
           properties: {
             altitude: getAltitude(properties) + markerHeight,
@@ -3263,13 +3472,13 @@ var styledFeatureGenerator = (mapTheme) => {
           });
         }
         const uiMarkerSymbol = getUIMarkerSymbol(
-          `occupant-${_4.toLower(renderType)}`
+          `occupant-${_12.toLower(renderType)}`
         );
         const uiMarkerPrioritySymbol = getUIMarkerSymbol(
-          `occupant-${_4.toLower(renderType)}-${renderPriority}`
+          `occupant-${_12.toLower(renderType)}-${renderPriority}`
         );
         const uiMarkerPriorityOptions = getUIMarkerOptions(
-          `occupant-${_4.toLower(renderType)}-${renderPriority}`
+          `occupant-${_12.toLower(renderType)}-${renderPriority}`
         );
         const style = { ...uiMarkerSymbol, ...uiMarkerPrioritySymbol };
         return new ui.UIMarker(coordinates, {
@@ -3291,7 +3500,7 @@ var styledFeatureGenerator = (mapTheme) => {
     const { category, ordinal, style = {} } = properties;
     const elementStyle = getElementSymbol(`${feature_type}.${category}`);
     const { allowOverride } = getElementOptions(`${feature_type}.${category}`);
-    if (allowOverride) _4.merge(elementStyle, style);
+    if (allowOverride) _12.merge(elementStyle, style);
     const { polygonFill: color } = elementStyle;
     const featureProperty = {
       id,
@@ -3380,9 +3589,9 @@ var styledFeatureGenerator = (mapTheme) => {
         feature2,
         mapConfig
       );
-      const markerHeight = _4.get(featureExtrudeConfig, "height");
+      const markerHeight = _12.get(featureExtrudeConfig, "height");
       const { id, properties } = feature2;
-      const geometry = _4.get(feature2, "geometry") || _4.get(feature2, "properties.anchor.geometry");
+      const geometry = _12.get(feature2, "geometry") || _12.get(feature2, "properties.anchor.geometry");
       const coordinates = getCenterFromGeometry(geometry);
       const symbol = getElementSymbol("pin-marker");
       try {
@@ -3402,10 +3611,10 @@ var styledFeatureGenerator = (mapTheme) => {
         feature2,
         mapConfig
       );
-      const markerHeight = _4.get(featureExtrudeConfig, "height", 0);
+      const markerHeight = _12.get(featureExtrudeConfig, "height", 0);
       const { properties, id } = feature2;
       const { geometry } = properties.anchor;
-      const logoUrl = _4.get(properties, "logo.url");
+      const logoUrl = _12.get(properties, "logo.url");
       const coordinates = getCenterFromGeometry(geometry);
       const [markerBase, markerLabel] = getLabelSymbol(
         "highlighted-logo-marker"
@@ -3475,7 +3684,7 @@ var styledFeatureGenerator = (mapTheme) => {
         feature2,
         mapConfig
       );
-      const markerHeight = _4.get(featureExtrudeConfig, "height");
+      const markerHeight = _12.get(featureExtrudeConfig, "height");
       const { id, feature_type, properties } = feature2;
       if (!properties.anchor) return;
       const markerProperties = {
@@ -3485,8 +3694,8 @@ var styledFeatureGenerator = (mapTheme) => {
         altitude: getAltitude(properties) + markerHeight
       };
       const { geometry } = properties?.anchor;
-      const coordinates = _4.get(geometry, "coordinates");
-      const logoUrl = _4.get(properties, "logo.url");
+      const coordinates = _12.get(geometry, "coordinates");
+      const logoUrl = _12.get(properties, "logo.url");
       if (markerSymbol) {
         return new Marker(coordinates, {
           properties: markerProperties,
@@ -3501,8 +3710,8 @@ var styledFeatureGenerator = (mapTheme) => {
         });
       }
       const labelSymbol = getLabelSymbol("highlight-occupant-logo");
-      const priorityMarkerSymbol = _4.last(labelSymbol) || {};
-      _4.set(priorityMarkerSymbol, "markerFile", logoUrl);
+      const priorityMarkerSymbol = _12.last(labelSymbol) || {};
+      _12.set(priorityMarkerSymbol, "markerFile", logoUrl);
       return new Marker(coordinates, {
         properties: markerProperties,
         symbol: labelSymbol
@@ -3510,14 +3719,14 @@ var styledFeatureGenerator = (mapTheme) => {
     },
     createHighlight2DAmenityMarkerFrom3DMarker: (feature2, mapConfig) => {
       const { coordinates, units, kiosk } = feature2;
-      const amenityLocatedUnit = _4.first(units);
+      const amenityLocatedUnit = _12.first(units);
       const unitConfig = getExtrudeConfigByFeature(
         mapConfig,
         amenityLocatedUnit
       );
-      const unitHeight = _4.get(unitConfig, "height", 0);
+      const unitHeight = _12.get(unitConfig, "height", 0);
       const kioskConfig = getExtrudeConfigByFeature(mapConfig, kiosk);
-      const kioskHeight = _4.get(kioskConfig, "height", 0);
+      const kioskHeight = _12.get(kioskConfig, "height", 0);
       const markerHeight = unitHeight + kioskHeight;
       const symbol = getElementSymbol("highlight-amenity-marker");
       return new Marker(coordinates, {
@@ -3593,7 +3802,7 @@ var styledFeatureGenerator = (mapTheme) => {
       }
     },
     createLineStringFromGeometries: (geometries) => {
-      const mergedCoordinates = _4(geometries).map((geometry) => {
+      const mergedCoordinates = _12(geometries).map((geometry) => {
         switch (geometry.type) {
           case "Point":
             return [
@@ -3671,7 +3880,7 @@ var styledFeatureGenerator = (mapTheme) => {
       const {
         logo,
         altitude,
-        scale: scale2,
+        scale: scale3,
         alphaTest,
         legColor,
         showLeg,
@@ -3685,7 +3894,7 @@ var styledFeatureGenerator = (mapTheme) => {
       };
       const options = {
         altitude,
-        scale: scale2,
+        scale: scale3,
         alphaTest,
         legColor,
         showLeg,
@@ -3702,29 +3911,29 @@ var styledFeatureGenerator = (mapTheme) => {
     create3DAmenityMarker: (feature2, threeLayer, config) => {
       const { geometry, properties, feature_type, id } = feature2;
       const { category, units, kiosk, is_clickable } = properties;
-      const amenityLocatedUnit = _4.first(units);
-      const isLocatedUnitModel3dAvailable = !_4.isEmpty(
+      const amenityLocatedUnit = _12.first(units);
+      const isLocatedUnitModel3dAvailable = !_12.isEmpty(
         amenityLocatedUnit?.properties?.model3d
       );
-      const isLocatedKioskModel3dAvailable = !_4.isEmpty(
+      const isLocatedKioskModel3dAvailable = !_12.isEmpty(
         kiosk?.properties?.model3d
       );
       const unitConfig = getExtrudeConfigByFeature(config, amenityLocatedUnit);
-      const unitHeight = isLocatedUnitModel3dAvailable ? 0 : _4.get(unitConfig, "height", 0);
+      const unitHeight = isLocatedUnitModel3dAvailable ? 0 : _12.get(unitConfig, "height", 0);
       const kioskConfig = getExtrudeConfigByFeature(config, kiosk);
-      const kioskHeight = isLocatedKioskModel3dAvailable ? 0 : _4.get(kioskConfig, "height", 0);
-      const coordinates = _4.get(geometry, "coordinates");
+      const kioskHeight = isLocatedKioskModel3dAvailable ? 0 : _12.get(kioskConfig, "height", 0);
+      const coordinates = _12.get(geometry, "coordinates");
       const markerProperties = {
         ...properties,
         coordinates,
         id,
         feature_type
       };
-      const material = _4.get(
+      const material = _12.get(
         spriteMarkerMaterialObj,
         `${feature_type}.${category}`
       );
-      const highlightOptions = _4.get(
+      const highlightOptions = _12.get(
         spriteHighlightMarkerOptionObj,
         `${PREFIX_HIGHLIGHTED_SYMBOL_KEY}-${feature_type}.${category}`
       );
@@ -3747,24 +3956,24 @@ var styledFeatureGenerator = (mapTheme) => {
       const { category, unit, kiosk } = properties;
       const amenityLocation = kiosk || unit;
       const locationConfig = getExtrudeConfigByFeature(config, amenityLocation);
-      const coordinates = _4.get(geometry, "coordinates");
+      const coordinates = _12.get(geometry, "coordinates");
       const markerProperties = {
         ...properties,
         coordinates,
         id,
         feature_type
       };
-      const material = _4.get(
+      const material = _12.get(
         spriteMarkerMaterialObj,
         `${feature_type}.${category}`
       );
-      const highlightOptions = _4.get(
+      const highlightOptions = _12.get(
         spriteHighlightMarkerOptionObj,
         `${PREFIX_HIGHLIGHTED_SYMBOL_KEY}-${feature_type}.${category}`
       );
       const options = {
         scale: 0.05,
-        altitude: _4.get(locationConfig, "height", 0),
+        altitude: _12.get(locationConfig, "height", 0),
         highlight: highlightOptions
       };
       return create3DMarker(
@@ -3780,24 +3989,24 @@ var styledFeatureGenerator = (mapTheme) => {
       const { category, unit, kiosk } = properties;
       const amenityLocation = kiosk || unit;
       const locationConfig = getExtrudeConfigByFeature(config, amenityLocation);
-      const coordinates = _4.get(geometry, "coordinates");
+      const coordinates = _12.get(geometry, "coordinates");
       const markerProperties = {
         ...properties,
         coordinates,
         id,
         feature_type
       };
-      const material = _4.get(
+      const material = _12.get(
         spriteMarkerMaterialObj,
         `${feature_type}.${category}`
       );
-      const highlightOptions = _4.get(
+      const highlightOptions = _12.get(
         spriteHighlightMarkerOptionObj,
         `${PREFIX_HIGHLIGHTED_SYMBOL_KEY}-${feature_type}.${category}`
       );
       const options = {
         scale: 0.05,
-        altitude: _4.get(locationConfig, "height", 0),
+        altitude: _12.get(locationConfig, "height", 0),
         highlight: highlightOptions
       };
       return create3DMarker(
@@ -3809,13 +4018,13 @@ var styledFeatureGenerator = (mapTheme) => {
       );
     },
     createExtrudedUnit: (unit, threeLayer, options) => {
-      const extrudeHeight = _4.get(options, "height");
+      const extrudeHeight = _12.get(options, "height");
       if (!extrudeHeight) return;
       const unitProperty = getFeatureProperties(unit);
       const options3d = {
         // TODO: Move to extrude config later
         offset: -0.1,
-        altitude: _4.get(options, "altitude", 0)
+        altitude: _12.get(options, "altitude", 0)
       };
       const color = unitProperty.defaultColor;
       if (color === "transparent") return;
@@ -3858,14 +4067,14 @@ var EXCEPT_AMENITY_LOCATION_CATEGORIES = [
   "unspecified"
 ];
 var getLocationByAmenity = (feature2) => {
-  const unit = _4.get(feature2, "properties.units[0]", null);
-  const unitCategory = _4.get(unit, "properties.category");
+  const unit = _12.get(feature2, "properties.units[0]", null);
+  const unitCategory = _12.get(unit, "properties.category");
   if (!unit) return feature2.id;
   return EXCEPT_AMENITY_LOCATION_CATEGORIES.includes(unitCategory) ? feature2 : unit;
 };
 var getLocationByOccupant = (feature2) => {
-  const kiosk = _4.get(feature2, "properties.kiosk", null);
-  const unit = _4.get(feature2, "properties.anchor.properties.unit", null);
+  const kiosk = _12.get(feature2, "properties.kiosk", null);
+  const unit = _12.get(feature2, "properties.anchor.properties.unit", null);
   return kiosk || unit;
 };
 var getLocationIdByFeature = (feature2) => {
@@ -3893,10 +4102,10 @@ var getFeatureByLocationId = (id, features = []) => {
   });
 };
 var isClickableFeature = (feature2) => {
-  const isClickable = _4.get(feature2, "properties.is_clickable");
+  const isClickable = _12.get(feature2, "properties.is_clickable");
   switch (feature2?.feature_type) {
     case "amenity":
-      return _4.isNull(isClickable) ? true : isClickable;
+      return _12.isNull(isClickable) ? true : isClickable;
     case "occupant":
       return true;
     default:
@@ -3914,15 +4123,15 @@ var getLocationByFeature = (feature2) => {
   }
 };
 var getRelatedLocationsByOccupant = (feature2) => {
-  const kiosks = _4.get(feature2, "properties.kiosks", []);
-  const units = _4.get(feature2, "properties.units", []);
+  const kiosks = _12.get(feature2, "properties.kiosks", []);
+  const units = _12.get(feature2, "properties.units", []);
   return [...kiosks, ...units];
 };
 var getRelatedLocationsByAmenity = (feature2) => {
-  const units = _4.get(feature2, "properties.units", []);
+  const units = _12.get(feature2, "properties.units", []);
   if (units.length === 0) return [feature2];
   return units.filter((unit) => {
-    const unitCategory = _4.get(unit, "properties.category");
+    const unitCategory = _12.get(unit, "properties.category");
     return !EXCEPT_AMENITY_LOCATION_CATEGORIES.includes(unitCategory);
   });
 };
@@ -3948,8 +4157,8 @@ var getRelatedLocationsByFeature = (feature2) => {
 };
 var getOrdinalByLocationId = (locationId, feature2) => {
   if (!feature2) return null;
-  const mainUnit = _4.get(feature2, "properties.unit");
-  const mainKiosk = _4.get(feature2, "properties.kiosk");
+  const mainUnit = _12.get(feature2, "properties.unit");
+  const mainKiosk = _12.get(feature2, "properties.kiosk");
   const relatedLocations = getRelatedLocationsByFeature(feature2);
   const allLocations = [mainUnit, mainKiosk, ...relatedLocations].filter(
     Boolean
@@ -3957,7 +4166,7 @@ var getOrdinalByLocationId = (locationId, feature2) => {
   const targetLocation = allLocations.find(
     (location) => location.id === locationId
   );
-  return targetLocation ? _4.get(targetLocation, "properties.level.properties.ordinal") || _4.get(targetLocation, "properties.ordinal") : null;
+  return targetLocation ? _12.get(targetLocation, "properties.level.properties.ordinal") || _12.get(targetLocation, "properties.ordinal") : null;
 };
 
 // src/IndoorMap/utils/math.ts
@@ -3970,140 +4179,16 @@ var getBearingBetweenPoints = (origin, destination) => {
   return Math.floor(radToDegree(theta));
 };
 var getSuitablyValueBetweenBearings = (newBearing, currentBearing) => {
-  const difference = Math.abs(newBearing - currentBearing);
-  if (difference > 180)
+  const difference2 = Math.abs(newBearing - currentBearing);
+  if (difference2 > 180)
     return newBearing > 0 ? newBearing - 360 : newBearing + 360;
   return newBearing;
 };
 
 // src/IndoorMap/camera/CameraManager.ts
 import { Extent } from "maptalks";
-
-// ../../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");
-      }
-    }
-  }
-}
-
-// ../../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];
-    }
-    if (result[1] > coord[1]) {
-      result[1] = coord[1];
-    }
-    if (result[2] < coord[0]) {
-      result[2] = coord[0];
-    }
-    if (result[3] < coord[1]) {
-      result[3] = coord[1];
-    }
-  });
-  return result;
-}
-var index_default = bbox;
-
-// src/IndoorMap/camera/CameraManager.ts
-import scale from "@turf/transform-scale";
-import bboxPolygon from "@turf/bbox-polygon";
+import scale2 from "@turf/transform-scale";
+import bboxPolygon2 from "@turf/bbox-polygon";
 var CameraManager = class {
   map;
   constructor(map, options) {
@@ -4129,7 +4214,7 @@ var CameraManager = class {
   }
   getFeatureExtent = (feature2, scaleFactor = 1) => {
     const [minX, minY, maxX, maxY] = index_default(
-      scale(bboxPolygon(index_default(feature2)), scaleFactor)
+      scale2(bboxPolygon2(index_default(feature2)), scaleFactor)
     );
     return new Extent(minX, minY, maxX, maxY);
   };
@@ -4167,7 +4252,7 @@ var CameraManager = class {
 
 // src/IndoorMap/renderer/RendererManager.ts
 import { min, compact as compact2, isFunction } from "lodash";
-import { center as turfCenter2 } from "@turf/center";
+import { center as turfCenter5 } from "@turf/center";
 import * as THREE4 from "three";
 
 // src/IndoorMap/renderer/3d/Element3DRenderer.ts
@@ -4175,7 +4260,7 @@ import * as maptalks4 from "maptalks-gl";
 import * as THREE from "three";
 import { BaseObject as BaseObject5 } from "maptalks.three";
 import turfBuffer2 from "@turf/buffer";
-import { cleanCoords } from "@turf/clean-coords";
+import { cleanCoords as cleanCoords2 } from "@turf/clean-coords";
 import { polygonToLine } from "@turf/polygon-to-line";
 import { nearestPointOnLine } from "@turf/nearest-point-on-line";
 import { length } from "@turf/length";
@@ -4191,7 +4276,7 @@ import {
   PlaneGeometry
 } from "three";
 import { largestRect } from "d3plus-shape";
-import { max, merge, isNumber as isNumber3, isArray as isArray2, range } from "lodash";
+import { max, merge, isNumber as isNumber2, isArray, range } from "lodash";
 var OPTIONS3 = {
   // Allowing click through and prevent interaction
   interactive: false,
@@ -4265,22 +4350,22 @@ var getMaterial = (text, flatLabelOptions) => {
     texts = wrapText(ctx, text, maxWidth);
   }
   let textWidth = max(texts.map((text2) => ctx.measureText(text2).width));
-  let scale2 = 1;
-  while (scale2 > 0 && textWidth + 2 * margin > SIZE) {
-    scale2 -= scaleStep;
-    ctx.font = `${fontWeight} ${scale2 * fontSize}px "${fontFamily}", Arial`;
+  let scale3 = 1;
+  while (scale3 > 0 && textWidth + 2 * margin > SIZE) {
+    scale3 -= scaleStep;
+    ctx.font = `${fontWeight} ${scale3 * fontSize}px "${fontFamily}", Arial`;
     textWidth = max(texts.map((text2) => ctx.measureText(text2).width));
   }
-  const center4 = { x: 0.5 * SIZE, y: 0.5 * SIZE };
-  if (scale2 > scaleMin) {
-    const totalHeight = texts.length * (fontSize * scale2 * lineHeight);
-    const startY = center4.y - totalHeight / 2 + fontSize * scale2 * lineHeight * 0.5;
+  const center8 = { x: 0.5 * SIZE, y: 0.5 * SIZE };
+  if (scale3 > scaleMin) {
+    const totalHeight = texts.length * (fontSize * scale3 * lineHeight);
+    const startY = center8.y - totalHeight / 2 + fontSize * scale3 * lineHeight * 0.5;
     texts.forEach((text2, index) => {
-      const yOffset = startY + index * (fontSize * scale2 * lineHeight);
+      const yOffset = startY + index * (fontSize * scale3 * lineHeight);
       if (strokeStyle && lineWidth) {
-        ctx.strokeText(text2, center4.x, yOffset);
+        ctx.strokeText(text2, center8.x, yOffset);
       }
-      ctx.fillText(text2, center4.x, yOffset);
+      ctx.fillText(text2, center8.x, yOffset);
     });
   }
   const texture = new Texture(canvas);
@@ -4337,7 +4422,7 @@ var GroundLabel = class extends BaseObject4 {
       strokeStyle,
       lineWidth
     });
-    const rectAngles = isArray2(angle) ? angle : [angle];
+    const rectAngles = isArray(angle) ? angle : [angle];
     material.needsUpdate = true;
     const rect = largestRect(bound, {
       cache: true,
@@ -4357,8 +4442,8 @@ var GroundLabel = class extends BaseObject4 {
     const basePosition = layer.coordinateToVector3([cx, cy], z);
     this.#originalPosition = basePosition.clone();
     const finalPosition = this.#calculateFinalPosition(basePosition);
-    const scale2 = width / 6456122659e-13;
-    const finalScale = maxFontScale && scale2 > maxFontScale ? maxFontScale : scale2;
+    const scale3 = width / 6456122659e-13;
+    const finalScale = maxFontScale && scale3 > maxFontScale ? maxFontScale : scale3;
     this.getObject3d().scale.set(finalScale, finalScale, finalScale);
     this.getObject3d().position.copy(finalPosition);
     this.getObject3d().rotation.z = Math.PI / 180 * this.#angle;
@@ -4410,32 +4495,32 @@ var GroundLabel = class extends BaseObject4 {
     return { x: this.#offsetX, y: this.#offsetY };
   }
   set offsetX(value) {
-    if (isNumber3(value)) {
+    if (isNumber2(value)) {
       this.#offsetX = value;
       this.#updatePosition();
     }
   }
   set offsetY(value) {
-    if (isNumber3(value)) {
+    if (isNumber2(value)) {
       this.#offsetY = value;
       this.#updatePosition();
     }
   }
   set angle(newAngle) {
-    if (isNumber3(newAngle)) {
+    if (isNumber2(newAngle)) {
       this.#angle = newAngle;
       this.getObject3d().rotation.z = Math.PI / 180 * this.#angle;
     }
   }
   setOffset(offsetX, offsetY) {
-    if (isNumber3(offsetX) && isNumber3(offsetY)) {
+    if (isNumber2(offsetX) && isNumber2(offsetY)) {
       this.#offsetX = offsetX;
       this.#offsetY = offsetY;
       this.#updatePosition();
     }
   }
   addOffset(deltaX, deltaY) {
-    if (isNumber3(deltaX) && isNumber3(deltaY)) {
+    if (isNumber2(deltaX) && isNumber2(deltaY)) {
       this.#offsetX += deltaX;
       this.#offsetY += deltaY;
       this.#updatePosition();
@@ -4537,6 +4622,7 @@ var Element3DRenderer = class extends EventTarget {
   threeLayer;
   scene;
   lineMaterial;
+  navigationLineMaterial;
   materialByColorMap;
   // Renderer is Ready
   isReady = false;
@@ -4548,6 +4634,7 @@ var Element3DRenderer = class extends EventTarget {
     this.threeLayer = groupLayer.getLayer("three");
     this.gltfLayer = groupLayer.getLayer("gltf");
     this.lineMaterial = new THREE.LineBasicMaterial({ color: "#000" });
+    this.navigationLineMaterial = new THREE.LineBasicMaterial({ color: "#f00" });
     this.render();
   }
   animation() {
@@ -4663,7 +4750,7 @@ var Element3DRenderer = class extends EventTarget {
     const polygons = unit.geometry.type === "Polygon" ? [unit.geometry.coordinates] : unit.geometry.coordinates;
     return polygons.map((plg) => {
       return plg.map((ring) => {
-        const roomWall = cleanCoords(polygonToLine(polygon([ring])));
+        const roomWall = cleanCoords2(polygonToLine(polygon([ring])));
         if (openings.length === 0) {
           const color = "#ababab";
           const material = this.getOrCreateMaterialByColor(color);
@@ -4750,10 +4837,10 @@ var Element3DRenderer = class extends EventTarget {
     this.threeLayer.addMesh(groundLabel);
     return groundLabel;
   }
-  async createModel3d(f) {
-    const marker = new maptalks4.GLTFMarker(f.properties.center, {
+  async createModel3d(center8, url) {
+    const marker = new maptalks4.GLTFMarker(center8, {
       symbol: {
-        url: f.properties.model
+        url
       }
     });
     marker.addTo(this.gltfLayer);
@@ -4812,11 +4899,23 @@ var Element3DRenderer = class extends EventTarget {
       }
     }
   }
+  drawNavigation = (route) => {
+    const lines = [];
+    route.steps.map((step) => {
+      const lineString2 = new maptalks4.LineString(step.path);
+      const line = this.threeLayer.toPath(lineString2, { altitude: 0.2, cornerRadius: 1, width: 1, asynchronous: true }, this.navigationLineMaterial);
+      lines.push(line);
+    });
+    this.threeLayer.addMesh(lines);
+  };
   render() {
     this.threeLayer._needsUpdate = !this.threeLayer._needsUpdate;
     if (this.threeLayer._needsUpdate) {
       this.threeLayer.redraw();
     }
+    if (this.navigationLineMaterial?.map?.offset) {
+      this.navigationLineMaterial.map.offset.x -= 2e-3;
+    }
     requestAnimationFrame(this.render.bind(this));
   }
 };
@@ -4956,6 +5055,8 @@ var Element2DRenderer = class extends EventTarget {
       }
     };
   }
+  drawNavigation(route) {
+  }
 };
 
 // src/IndoorMap/renderer/2d/Marker2DRenderer.ts
@@ -5001,7 +5102,7 @@ import * as THREE3 from "three";
 import { Coordinate as Coordinate2, Util as Util4 } from "maptalks";
 import * as THREE2 from "three";
 import { BaseObject as BaseObject6 } from "maptalks.three";
-import { isNil, set } from "lodash";
+import { isNil, set as set4 } from "lodash";
 
 // src/IndoorMap/renderer/utils/interpolateStops.ts
 var interpolateStops = ({ stops }, zoom) => {
@@ -5011,8 +5112,8 @@ var interpolateStops = ({ stops }, zoom) => {
     const [z1, v1] = stops[i];
     const [z2, v2] = stops[i + 1];
     if (zoom >= z1 && zoom <= z2) {
-      const t = (zoom - z1) / (z2 - z1);
-      return v1 + t * (v2 - v1);
+      const t2 = (zoom - z1) / (z2 - z1);
+      return v1 + t2 * (v2 - v1);
     }
   }
 };
@@ -5157,7 +5258,7 @@ var TextSpriteMarker = class extends BaseObject6 {
     const altitude = (options.altitude || 0) + this.#altitudeOffset;
     const z = layer.altitudeToVector3(altitude, altitude).x;
     const position = layer.coordinateToVector3(this._coordinate, z);
-    set(this.properties, "default.position", position);
+    set4(this.properties, "default.position", position);
     this.getObject3d().position.copy(position);
   }
   _animation() {
@@ -5332,10 +5433,10 @@ var angleBetweenLineStrings = (line1, line2) => {
 };
 
 // src/IndoorMap/renderer/utils/findUnitOnPoint.ts
-import { booleanPointInPolygon as booleanPointInPolygon3 } from "@turf/boolean-point-in-polygon";
+import { booleanPointInPolygon as booleanPointInPolygon5 } from "@turf/boolean-point-in-polygon";
 var findUnitOnPoint = (units, point2) => {
   try {
-    return units.find((unit) => booleanPointInPolygon3(point2, polygon(unit.geometry.coordinates)));
+    return units.find((unit) => booleanPointInPolygon5(point2, polygon(unit.geometry.coordinates)));
   } catch (err) {
     return null;
   }
@@ -5422,6 +5523,7 @@ var RendererManager = class extends EventTarget {
           options.onRendererReady();
         }
         _this.#createElements();
+        _this.elementRenderer.createModel3d([100.54724407, 13.72699081], "https://s3.venue.in.th/all_park_f95ac5be3c.gltf");
         setTimeout(() => {
           findBadMeshes(scene);
         }, 3e3);
@@ -5538,7 +5640,7 @@ var RendererManager = class extends EventTarget {
         const thatLevelOpening = bothOpenings.find((opening) => opening.properties.ordinal !== thisOrdinal);
         const angle = 180 * (1 / Math.PI) * angleBetweenLineStrings(thisLevelOpening.geometry.coordinates, thatLevelOpening.geometry.coordinates);
         const direction = thisOrdinal < thatLevelOpening.properties.ordinal ? "up" : "down";
-        const escalatorEntryPoint = turfCenter2(thisLevelOpening).geometry.coordinates;
+        const escalatorEntryPoint = turfCenter5(thisLevelOpening).geometry.coordinates;
         const element = await this.elementRenderer.createEscalator(escalator, escalatorEntryPoint, { direction, angle });
         if (element) {
           const _elements = Array.isArray(element) ? element : [element];
@@ -5550,8 +5652,8 @@ var RendererManager = class extends EventTarget {
     }
     const groundLabels = await this.#dataClient.filterByType("label");
     for (const label of groundLabels) {
-      const center4 = turfCenter2(polygon(label.geometry.coordinates)).geometry.coordinates;
-      const unit = findUnitOnPoint(units, center4);
+      const center8 = turfCenter5(polygon(label.geometry.coordinates)).geometry.coordinates;
+      const unit = findUnitOnPoint(units, center8);
       if (unit) {
         const element = this.elementRenderer.createGroundLabel(label, unit);
         if (element) {
@@ -5560,12 +5662,6 @@ var RendererManager = class extends EventTarget {
         }
       }
     }
-    if (this.options.type === "3D") {
-      const model3ds = await this.#dataClient.filterByType("model3d");
-      for (const model3d of model3ds) {
-        this.elementRenderer.createModel3d(model3d);
-      }
-    }
     this.changeLevelByOrdinal(this.currentOrdinals);
     this.dispatchEvent(new CustomEvent("renderermanager:elements_created"));
   }
@@ -5650,6 +5746,9 @@ var RendererManager = class extends EventTarget {
       this.markerRenderer.removeMarker(marker);
     }
   }
+  drawNavigation(route) {
+    this.elementRenderer.drawNavigation(route);
+  }
 };
 
 // src/IndoorMap/IndoorMap.ts
@@ -5727,7 +5826,7 @@ var IndoorMap = class extends EventTarget {
   };
   constructor(elementId, options) {
     super();
-    const combinedOptions = _5.merge({}, defaultOptions, options);
+    const combinedOptions = _13.merge({}, defaultOptions, options);
     this.options = combinedOptions;
     const {
       onMapReady,
@@ -5774,7 +5873,7 @@ var IndoorMap = class extends EventTarget {
     this.dataClient = options.dataClient;
   }
   setOptions(options) {
-    const combinedOptions = _5.merge({}, defaultOptions, options);
+    const combinedOptions = _13.merge({}, defaultOptions, options);
     this.options = combinedOptions;
     const maptalksOptions = parseMaptalksOptions(combinedOptions);
     this.map.setOptions(maptalksOptions);
@@ -5784,10 +5883,10 @@ var IndoorMap = class extends EventTarget {
     if (!this.options.camera?.defaultView?.center) {
       this.#dataClient.filterByType("venue").then((venues) => {
         this.#venues = venues;
-        const venueCenters = turfCenter3(featureCollection(venues));
+        const venueCenters = turfCenter6(featureCollection(venues));
         const [x, y] = venueCenters.geometry.coordinates;
-        const center4 = new Coordinate4(x, y);
-        this.camera.setView({ center: center4, pitch: 60, zoom: 19 });
+        const center8 = new Coordinate4(x, y);
+        this.camera.setView({ center: center8, pitch: 60, zoom: 19 });
       });
     }
   }
@@ -5800,7 +5899,7 @@ var IndoorMap = class extends EventTarget {
   handleMapClick = ({ coordinate }) => {
     const { x, y } = coordinate;
     console.log(
-      `[Coordinates]: x: ${_5.round(x, 8)} y: ${_5.round(
+      `[Coordinates]: x: ${_13.round(x, 8)} y: ${_13.round(
         y,
         8
       )}, [Bearing]: ${this.map.getBearing()}, [Pitch]: ${this.map.getPitch()}`
@@ -5886,7 +5985,7 @@ var IndoorMap = class extends EventTarget {
     if (this.#isClicked) return;
     this.#isClicked = true;
     const onClickElement = this.#onClickElement;
-    if (!_5.isFunction(onClickElement)) return;
+    if (!_13.isFunction(onClickElement)) return;
     this.#onClickElement(e);
     this.#isClicked = false;
   };
@@ -5906,16 +6005,16 @@ var IndoorMap = class extends EventTarget {
     for (const feature2 of this.#features) {
       try {
         const { feature_type: featureType, properties, id } = feature2;
-        const layerName = _5.get(
+        const layerName = _13.get(
           LAYER_FEATURE_TYPE_OBJ,
           featureType,
           featureType
         );
         const layer = this.map.getLayer(layerName);
         let geometry;
-        const category = _5.get(feature2, "properties.category");
-        const extrudeConfig = _5.get(this.#mapConfig, "extrude");
-        const textMarkerType = _5.get(
+        const category = _13.get(feature2, "properties.category");
+        const extrudeConfig = _13.get(this.#mapConfig, "extrude");
+        const textMarkerType = _13.get(
           this.#mapConfig,
           "text_marker_type",
           "ui-marker"
@@ -5947,7 +6046,7 @@ var IndoorMap = class extends EventTarget {
           case "opening": {
             switch (category) {
               case "emergencyexit":
-                const { geometry: geometry2 } = turfCenter3(feature2);
+                const { geometry: geometry2 } = turfCenter6(feature2);
                 const markerFeature = {
                   ...feature2,
                   geometry: geometry2
@@ -6030,9 +6129,9 @@ var IndoorMap = class extends EventTarget {
     const mapCenter = this.map.getCenter();
     const result = this.#venues.reduce((closest, venue) => {
       const { display_point: displayPoint } = venue.properties;
-      const distance = turfDistance(displayPoint, [mapCenter.x, mapCenter.y]);
-      if (!closest || distance < closest.distance) {
-        return { venueId: venue.id, distance };
+      const distance5 = turfDistance2(displayPoint, [mapCenter.x, mapCenter.y]);
+      if (!closest || distance5 < closest.distance) {
+        return { venueId: venue.id, distance: distance5 };
       }
       return closest;
     }, null);
@@ -6082,15 +6181,15 @@ var IndoorMap = class extends EventTarget {
     }
   }
   updateUserLocationSymbolByLocale(locale) {
-    const userLocationGeometry = _5.get(
+    const userLocationGeometry = _13.get(
       this.#elements,
       `${USER_LOCATION_ELEMENT_ID}.geometry`
     );
     if (!userLocationGeometry) return;
     const currentSymbol = userLocationGeometry.getSymbol();
     const localeSymbolToUpdate = currentSymbol.map((symbol) => {
-      const localeSymbol = _5.get(symbol, `${LOCALE_SYMBOL_KEY}.${locale}`) || _5.get(symbol, `${LOCALE_SYMBOL_KEY}.default`);
-      if (!_5.isPlainObject(localeSymbol)) return symbol;
+      const localeSymbol = _13.get(symbol, `${LOCALE_SYMBOL_KEY}.${locale}`) || _13.get(symbol, `${LOCALE_SYMBOL_KEY}.default`);
+      if (!_13.isPlainObject(localeSymbol)) return symbol;
       return {
         ...symbol,
         ...localeSymbol
@@ -6164,14 +6263,14 @@ var IndoorMap = class extends EventTarget {
    * END of User Location
    ****************************/
   showGeometryByElementId = (elementId) => {
-    const geometry = _5.get(
+    const geometry = _13.get(
       this.#elements,
       `${elementId}.geometry`
     );
     if (geometry) geometry.show();
   };
   hideGeometryByElementId = (elementId) => {
-    const geometry = _5.get(this.#elements, `${elementId}.geometry`);
+    const geometry = _13.get(this.#elements, `${elementId}.geometry`);
     if (geometry) geometry.hide();
   };
   setSpriteMarkersOpacity = (opacity = 1) => {
@@ -6210,7 +6309,7 @@ var IndoorMap = class extends EventTarget {
    * Navigation
    ****************************/
   combineNearbyLineStrings(lineStrings, options = { properties: {}, distance: 3e-4 }) {
-    const { properties = {}, distance = 3e-4 } = options || {};
+    const { properties = {}, distance: distance5 = 3e-4 } = options || {};
     const combinedLineStrings = [];
     const accLine = [];
     if (lineStrings.length === 1) return lineStrings;
@@ -6218,14 +6317,14 @@ var IndoorMap = class extends EventTarget {
       const line = lineStrings[i];
       const coords = line.geometry.coordinates;
       const prevLine = lineStrings[i - 1];
-      const firstCoord = _5.first(coords);
+      const firstCoord = _13.first(coords);
       const isFirstLine = i === 0;
       if (isFirstLine) {
         accLine.push(...coords);
         continue;
       }
-      const prevLastCoord = _5.last(prevLine.geometry.coordinates);
-      const isNearby = turfDistance(point(firstCoord), point(prevLastCoord)) < distance;
+      const prevLastCoord = _13.last(prevLine.geometry.coordinates);
+      const isNearby = turfDistance2(point(firstCoord), point(prevLastCoord)) < distance5;
       if (!isNearby) {
         const remainingLines = lineStrings.slice(i);
         const res = this.combineNearbyLineStrings(remainingLines, properties);
@@ -6245,8 +6344,8 @@ var IndoorMap = class extends EventTarget {
       create3DStepPath
     } = this.#styler;
     const routeMarkerLayer = this.map.getLayer(HIGHLIGHT_LAYER_NAME);
-    const linesByOrdinal = _5(stepGeometries).filter(({ geometry }) => geometry.type === "LineString").groupBy("properties.ordinal").value();
-    const joinedLines = _5(linesByOrdinal).reduce((acc, lines, key) => {
+    const linesByOrdinal = _13(stepGeometries).filter(({ geometry }) => geometry.type === "LineString").groupBy("properties.ordinal").value();
+    const joinedLines = _13(linesByOrdinal).reduce((acc, lines, key) => {
       const joined = this.combineNearbyLineStrings(lines, {
         properties: { ordinal: +key }
       });
@@ -6274,14 +6373,14 @@ var IndoorMap = class extends EventTarget {
                 stepElement = createOriginMarker(stepGeometry).addTo(routeMarkerLayer);
                 break;
               case "destination-marker":
-                const extrudeConfig = _5.get(this.#mapConfig, "extrude");
+                const extrudeConfig = _13.get(this.#mapConfig, "extrude");
                 if (destinationFeature.feature_type === "occupant") {
-                  const stepId = _5.get(stepGeometry, "id");
+                  const stepId = _13.get(stepGeometry, "id");
                   const normalizedDestinationFeature = {
                     ...destinationFeature,
                     id: stepId
                   };
-                  const logoUrl = _5.get(
+                  const logoUrl = _13.get(
                     normalizedDestinationFeature,
                     "properties.logo.url"
                   );
@@ -6326,15 +6425,15 @@ var IndoorMap = class extends EventTarget {
     const routeMarkerLayer = this.map.getLayer(
       HIGHLIGHT_LAYER_NAME
     );
-    const originMarkerGeometry = _5.get(
+    const originMarkerGeometry = _13.get(
       this.#elements,
       `${ORIGIN_MARKER_ID}.geometry`
     );
-    const destinationMarkerGeometry = _5.get(
+    const destinationMarkerGeometry = _13.get(
       this.#elements,
       `${DESTINATION_MARKER_ID}.geometry`
     );
-    const geometriesToRemove = _5.compact([
+    const geometriesToRemove = _13.compact([
       originMarkerGeometry,
       destinationMarkerGeometry
     ]);
@@ -6345,7 +6444,7 @@ var IndoorMap = class extends EventTarget {
       (obj) => !(obj instanceof NavigationPath)
     );
     const objects = this.#navigationGeometries || {};
-    _5.forEach(objects, (obj) => {
+    _13.forEach(objects, (obj) => {
       if (!obj) return;
       this.#navigationGeometries[obj.properties.id] = null;
       obj.remove();
@@ -6382,7 +6481,7 @@ var IndoorMap = class extends EventTarget {
     }
     if (this.threeLayer) {
       const currentView = this.camera.getView();
-      const objectOpacity = _5.clamp(38 - 2 * currentView.zoom, 0, 1);
+      const objectOpacity = _13.clamp(38 - 2 * currentView.zoom, 0, 1);
       this.#objects.forEach((object) => {
         object.getObject3d().traverse((child) => {
           if (child.isMesh) child.material.opacity = objectOpacity;
@@ -6392,7 +6491,7 @@ var IndoorMap = class extends EventTarget {
       });
       if (this.#billboardObjects) {
         this.#billboardObjects.forEach((object) => {
-          const objectScale = _5.clamp(
+          const objectScale = _13.clamp(
             20 - 1 * currentView.zoom,
             1,
             1.05
@@ -6401,7 +6500,7 @@ var IndoorMap = class extends EventTarget {
         });
       }
       if (this.#isLayersFadingOnZoom) {
-        const layerOpacity = _5.clamp(1 - objectOpacity, 0, 1);
+        const layerOpacity = _13.clamp(1 - objectOpacity, 0, 1);
         LAYERS.forEach((layerKey) => {
           const layer = this.map.getLayer(layerKey);
           if (layer) layer.setOpacity(layerOpacity);