venue-js 1.4.0-next.2 → 1.4.0-next.20

package/dist/index.js

@@ -37,6 +37,7 @@ __export(index_exports, {
   GEOJSON_FEATURE_TYPES: () => GEOJSON_FEATURE_TYPES,
   HIGHLIGHT_LAYER_NAME: () => HIGHLIGHT_LAYER_NAME,
   IMDF_FEATURE_TYPES: () => IMDF_FEATURE_TYPES,
+  IMDF_UNIT_CATEGORIES: () => IMDF_UNIT_CATEGORIES,
   IndoorMap: () => IndoorMap,
   LAST_USER_LOCATION_ELEMENT_ID_PREFIX: () => LAST_USER_LOCATION_ELEMENT_ID_PREFIX,
   LAYERS: () => LAYERS,
@@ -68,11 +69,13 @@ __export(index_exports, {
   getLocationByFeature: () => getLocationByFeature,
   getLocationByOccupant: () => getLocationByOccupant,
   getLocationIdByFeature: () => getLocationIdByFeature,
+  getNavigateClient: () => getNavigateClient,
   getOrdinalByLocationId: () => getOrdinalByLocationId,
   getRelatedLocationIdsByFeature: () => getRelatedLocationIdsByFeature,
   getRelatedLocationsByAmenity: () => getRelatedLocationsByAmenity,
   getRelatedLocationsByFeature: () => getRelatedLocationsByFeature,
   getRelatedLocationsByOccupant: () => getRelatedLocationsByOccupant,
+  getSearchClient: () => getSearchClient,
   getSuitablyValueBetweenBearings: () => getSuitablyValueBetweenBearings,
   isClickableFeature: () => isClickableFeature,
   isValidCoordinate: () => isValidCoordinate,
@@ -113,6 +116,71 @@ var IMDF_FEATURE_TYPES = [
   "unit",
   "venue"
 ];
+var IMDF_UNIT_CATEGORIES = [
+  "auditorium",
+  "brick",
+  "classroom",
+  "column",
+  "concrete",
+  "conferenceroom",
+  "drywall",
+  "elevator",
+  "escalator",
+  "fieldofplay",
+  "firstaid",
+  "fitnessroom",
+  "foodservice",
+  "footbridge",
+  "glass",
+  "huddleroom",
+  "kitchen",
+  "laboratory",
+  "library",
+  "lobby",
+  "lounge",
+  "mailroom",
+  "mothersroom",
+  "movietheater",
+  "movingwalkway",
+  "nonpublic",
+  "office",
+  "opentobelow",
+  "parking",
+  "phoneroom",
+  "platform",
+  "privatelounge",
+  "ramp",
+  "recreation",
+  "restroom",
+  "restroom.family",
+  "restroom.female",
+  "restroom.female.wheelchair",
+  "restroom.male",
+  "restroom.male.wheelchair",
+  "restroom.transgender",
+  "restroom.transgender.wheelchair",
+  "restroom.unisex",
+  "restroom.unisex.wheelchair",
+  "restroom.wheelchair",
+  "road",
+  "room",
+  "serverroom",
+  "shower",
+  "smokingarea",
+  "stairs",
+  "steps",
+  "storage",
+  "structure",
+  "terrace",
+  "theater",
+  "unenclosedarea",
+  "unspecified",
+  "vegetation",
+  "waitingroom",
+  "walkway",
+  "walkway.island",
+  "wood"
+];
 var NONIMDF_FEATURE_TYPES = [
   "taxonomy",
   "event",
@@ -171,6 +239,119 @@ var defaultFeatureQueryOptionsMap = {
   model3d: {}
 };
 
+// src/data/utils/geometry-validator.ts
+var isValidCoordinate = (point2) => {
+  return point2.length === 2 && point2.every((coord) => typeof coord === "number");
+};
+function isValidLinearRingCoordinates(ring) {
+  if (ring.length < 4) {
+    return false;
+  }
+  return ring.every(isValidCoordinate) && ring[0][0] === ring[ring.length - 1][0] && ring[0][1] === ring[ring.length - 1][1];
+}
+var isValidPolygonCoordinates = (polygon2) => {
+  if (Array.isArray(polygon2[0]) && (polygon2[0].length === 0 || typeof polygon2[0][0] === "number")) {
+    return isValidLinearRingCoordinates(polygon2);
+  }
+  if (Array.isArray(polygon2) && polygon2.length > 0 && Array.isArray(polygon2[0])) {
+    if (!isValidLinearRingCoordinates(polygon2[0])) {
+      return false;
+    }
+    for (let i = 1; i < polygon2.length; i++) {
+      if (!isValidLinearRingCoordinates(polygon2[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+};
+var isValidMultiPolygonCoordinates = (multipolygon) => {
+  return multipolygon.every(isValidPolygonCoordinates);
+};
+var isValidLineStringCoordinates = (lineString2) => {
+  if (!Array.isArray(lineString2) || lineString2.length < 2) {
+    return false;
+  }
+  const firstPoint = lineString2[0];
+  const lastPoint = lineString2[lineString2.length - 1];
+  if (firstPoint[0] === lastPoint[0] && firstPoint[1] === lastPoint[1]) {
+    return false;
+  }
+  return lineString2.every(isValidCoordinate);
+};
+var isValidMultiPolygon = (geometry) => {
+  const { type, coordinates } = geometry;
+  return type === "MultiPolygon" && isValidMultiPolygonCoordinates(coordinates);
+};
+var isValidPolygon = (geometry) => {
+  const { type, coordinates } = geometry;
+  return type === "Polygon" && isValidPolygonCoordinates(coordinates);
+};
+var isValidLineString = (geometry) => {
+  const { type, coordinates } = geometry;
+  return type === "LineString" && isValidLineStringCoordinates(coordinates);
+};
+var isValidPoint = (geometry) => {
+  const { type, coordinates } = geometry;
+  return type === "Point" && isValidCoordinate(coordinates);
+};
+
+// src/data/utils/match-filters.ts
+function isInFilter(filter) {
+  return typeof filter === "object" && filter !== null && "$in" in filter && Array.isArray(filter.$in);
+}
+var someIntersect = (a, b) => a.some((v) => b.includes(v));
+function matchFilter(value, filter) {
+  if (Array.isArray(value)) {
+    if (isInFilter(filter)) return someIntersect(value, filter.$in);
+    return value.includes(filter);
+  } else {
+    if (isInFilter(filter)) return filter.$in.includes(value);
+    return value === filter;
+  }
+}
+function matchFilters(item, filters) {
+  return Object.entries(filters).every(([key, filter]) => {
+    return matchFilter(item.properties[key], filter);
+  });
+}
+
+// src/data/utils/occupant-helper.ts
+var occupant_helper_exports = {};
+__export(occupant_helper_exports, {
+  getOccupantCorrelatedLocations: () => getOccupantCorrelatedLocations,
+  getOccupantMainLocation: () => getOccupantMainLocation,
+  getOccupantMarkerLocations: () => getOccupantMarkerLocations
+});
+
+// src/data/utils/lodash/compact.ts
+var compact = (arr) => arr.filter((item) => Boolean(item));
+
+// src/data/utils/occupant-helper.ts
+var getOccupantMainLocation = (occupant) => {
+  return occupant.properties.kiosk || occupant.properties.unit;
+};
+var getOccupantCorrelatedLocations = (occupant) => {
+  const allCorrelatedLocations = [
+    ...occupant.properties.units,
+    ...occupant.properties.kiosks
+  ];
+  return compact(allCorrelatedLocations);
+};
+var getOccupantMarkerLocations = (occupant, options) => {
+  const placementType = options?.type ? options.type : occupant.properties.show_name_on_all_units ? "ALL_LOCATIONS" : "ONCE_PER_LEVEL";
+  const mainLocation = getOccupantMainLocation(occupant);
+  const mainLocationLevel = mainLocation?.properties?.level_id;
+  const allCorrelatedLocations = getOccupantCorrelatedLocations(occupant);
+  if (placementType === "ALL_LOCATIONS") {
+    return compact([mainLocation, ...allCorrelatedLocations]);
+  }
+  const otherLevelLocations = allCorrelatedLocations.filter((f) => f.properties.level_id !== mainLocationLevel);
+  const onePerLevelLocations = [...new Map(otherLevelLocations.map((loc) => [loc.properties.level_id, loc])).values()];
+  return compact([mainLocation, ...onePerLevelLocations]);
+};
+
 // src/data/api/delivery-project.ts
 async function fetchDeliveryApi(projectId, apiKey, featureType, baseUrl = DEFAULT_BASE_URL) {
   switch (featureType) {
@@ -292,121 +473,44 @@ var safeFetchFeature = async (featureType, params) => {
   }
 };
 
-// src/data/utils/geometry-validator.ts
-var isValidCoordinate = (point2) => {
-  return point2.length === 2 && point2.every((coord) => typeof coord === "number");
-};
-function isValidLinearRingCoordinates(ring) {
-  if (ring.length < 4) {
-    return false;
-  }
-  return ring.every(isValidCoordinate) && ring[0][0] === ring[ring.length - 1][0] && ring[0][1] === ring[ring.length - 1][1];
-}
-var isValidPolygonCoordinates = (polygon2) => {
-  if (Array.isArray(polygon2[0]) && (polygon2[0].length === 0 || typeof polygon2[0][0] === "number")) {
-    return isValidLinearRingCoordinates(polygon2);
-  }
-  if (Array.isArray(polygon2) && polygon2.length > 0 && Array.isArray(polygon2[0])) {
-    if (!isValidLinearRingCoordinates(polygon2[0])) {
-      return false;
-    }
-    for (let i = 1; i < polygon2.length; i++) {
-      if (!isValidLinearRingCoordinates(polygon2[i])) {
+// src/data/getDataClient.ts
+var import_query_core = require("@tanstack/query-core");
+
+// src/data/populator/index.ts
+var import_center2 = require("@turf/center");
+var import_boolean_point_in_polygon2 = require("@turf/boolean-point-in-polygon");
+
+// src/data/utils/findContaining.ts
+var import_center = require("@turf/center");
+var import_boolean_point_in_polygon = require("@turf/boolean-point-in-polygon");
+var findContainingUnit = (poi, units) => {
+  const unit = units.find(
+    (unit2) => {
+      try {
+        return unit2.properties.level_id === poi.properties.level_id && (0, import_boolean_point_in_polygon.booleanPointInPolygon)((0, import_center.center)(poi), unit2);
+      } catch (e) {
+        console.log(`Cannot find containing unit of (${poi.id}):`, e.message);
         return false;
       }
     }
-    return true;
-  }
-  return false;
-};
-var isValidMultiPolygonCoordinates = (multipolygon) => {
-  return multipolygon.every(isValidPolygonCoordinates);
-};
-var isValidLineStringCoordinates = (lineString2) => {
-  if (!Array.isArray(lineString2) || lineString2.length < 2) {
-    return false;
-  }
-  const firstPoint = lineString2[0];
-  const lastPoint = lineString2[lineString2.length - 1];
-  if (firstPoint[0] === lastPoint[0] && firstPoint[1] === lastPoint[1]) {
-    return false;
-  }
-  return lineString2.every(isValidCoordinate);
-};
-var isValidMultiPolygon = (geometry) => {
-  const { type, coordinates } = geometry;
-  return type === "MultiPolygon" && isValidMultiPolygonCoordinates(coordinates);
-};
-var isValidPolygon = (geometry) => {
-  const { type, coordinates } = geometry;
-  return type === "Polygon" && isValidPolygonCoordinates(coordinates);
-};
-var isValidLineString = (geometry) => {
-  const { type, coordinates } = geometry;
-  return type === "LineString" && isValidLineStringCoordinates(coordinates);
-};
-var isValidPoint = (geometry) => {
-  const { type, coordinates } = geometry;
-  return type === "Point" && isValidCoordinate(coordinates);
-};
-
-// src/data/utils/match-filters.ts
-function isInFilter(filter) {
-  return typeof filter === "object" && filter !== null && "$in" in filter && Array.isArray(filter.$in);
-}
-var someIntersect = (a, b) => a.some((v2) => b.includes(v2));
-function matchFilter(value, filter) {
-  if (Array.isArray(value)) {
-    if (isInFilter(filter)) return someIntersect(value, filter.$in);
-    return value.includes(filter);
-  } else {
-    if (isInFilter(filter)) return filter.$in.includes(value);
-    return value === filter;
-  }
-}
-function matchFilters(item, filters) {
-  return Object.entries(filters).every(([key, filter]) => {
-    return matchFilter(item.properties[key], filter);
-  });
-}
-
-// src/data/utils/occupant-helper.ts
-var occupant_helper_exports = {};
-__export(occupant_helper_exports, {
-  getOccupantCorrelatedLocations: () => getOccupantCorrelatedLocations,
-  getOccupantMainLocation: () => getOccupantMainLocation,
-  getOccupantMarkerLocations: () => getOccupantMarkerLocations
-});
-var import_lodash_es = require("lodash-es");
-var getOccupantMainLocation = (occupant) => {
-  return occupant.properties.kiosk || occupant.properties.unit;
-};
-var getOccupantCorrelatedLocations = (occupant) => {
-  const allCorrelatedLocations = [
-    ...occupant.properties.units,
-    ...occupant.properties.kiosks
-  ];
-  return (0, import_lodash_es.compact)(allCorrelatedLocations);
+  );
+  return unit;
 };
-var getOccupantMarkerLocations = (occupant, options) => {
-  const placementType = options?.type ? options.type : occupant.properties.show_name_on_all_units ? "ALL_LOCATIONS" : "ONCE_PER_LEVEL";
-  const mainLocation = getOccupantMainLocation(occupant);
-  const mainLocationLevel = mainLocation?.properties?.level_id;
-  const allCorrelatedLocations = getOccupantCorrelatedLocations(occupant);
-  if (placementType === "ALL_LOCATIONS") {
-    return (0, import_lodash_es.compact)([mainLocation, ...allCorrelatedLocations]);
-  }
-  const otherLevelLocations = allCorrelatedLocations.filter((f) => f.properties.level_id !== mainLocationLevel);
-  const onePerLevelLocations = [...new Map(otherLevelLocations.map((loc) => [loc.properties.level_id, loc])).values()];
-  return (0, import_lodash_es.compact)([mainLocation, ...onePerLevelLocations]);
+var findContainingUnitAtPoint = (point2, levelId, units) => {
+  const unit = units.find(
+    (unit2) => {
+      try {
+        return unit2.properties.level_id === levelId && (0, import_boolean_point_in_polygon.booleanPointInPolygon)(point2, unit2);
+      } catch (e) {
+        console.log(`Cannot find containing unit of (point: ${point2}, levelId: ${levelId}):`, e.message);
+        return false;
+      }
+    }
+  );
+  return unit;
 };
 
-// src/data/getDataClient.ts
-var import_query_core = require("@tanstack/query-core");
-
 // src/data/populator/index.ts
-var import_lodash_es2 = require("lodash-es");
-var import_boolean_within = require("@turf/boolean-within");
 var createPopulator = ({
   internalFindById,
   internalFilterByType
@@ -416,7 +520,6 @@ var createPopulator = ({
   const populateDetail = (detail) => Promise.resolve(detail);
   const populateFootprint = (footprint) => Promise.resolve(footprint);
   const populateGeofence = (geofence) => Promise.resolve(geofence);
-  const populateRelationship = (relationship) => Promise.resolve(relationship);
   const populatePrivilege = (privilege) => Promise.resolve(privilege);
   const populateEvent = (event) => Promise.resolve(event);
   const populatePromotion = async (promotion) => {
@@ -440,13 +543,14 @@ var createPopulator = ({
     const ordinalKiosks = kiosks.filter(
       (kiosk2) => kiosk2.properties.level_id === defaultLevel.id
     );
-    const kiosk = ordinalKiosks.find((kiosk2) => (0, import_boolean_within.booleanWithin)(amenity, kiosk2));
+    const kiosk = ordinalKiosks.find((kiosk2) => (0, import_boolean_point_in_polygon2.booleanPointInPolygon)(amenity, kiosk2));
     return {
       ...amenity,
       properties: {
         ...amenity.properties,
         ordinal: defaultLevel.properties.ordinal,
         level_name: defaultLevel.properties.name.en,
+        level: defaultLevel,
         units: populatedUnits,
         venue,
         _experimental_kiosk: kiosk ? await populateKiosk(kiosk) : null
@@ -458,7 +562,7 @@ var createPopulator = ({
     const venue = await internalFindById(unit.properties.venue_id);
     const level = await internalFindById(unit.properties.level_id);
     const sections = await internalFilterByType("section");
-    const section = sections.find((section2) => (0, import_boolean_within.booleanWithin)(anchor, section2));
+    const section = sections.find((section2) => (0, import_boolean_point_in_polygon2.booleanPointInPolygon)(anchor, section2));
     return {
       ...anchor,
       properties: {
@@ -491,20 +595,11 @@ var createPopulator = ({
     const venue = await internalFindById(kiosk.properties.venue_id);
     const anchor = await internalFindById(kiosk.properties.anchor_id);
     const units = await internalFilterByType("unit");
-    const unit = units.find(
-      (unit2) => {
-        try {
-          return unit2.properties.category === "walkway" && unit2.properties.level_id === kiosk.properties.level_id && (0, import_boolean_within.booleanWithin)(kiosk, unit2);
-        } catch (e) {
-          console.log(`Cannot find kiosk(${kiosk.id})'s units:`, e.message);
-          return false;
-        }
-      }
-    );
+    const unit = findContainingUnit(kiosk, units.filter((unit2) => unit2.properties.category === "walkway"));
     let section = null;
     if (anchor) {
       const sections = await internalFilterByType("section");
-      section = sections.find((section2) => (0, import_boolean_within.booleanWithin)(anchor, section2));
+      section = sections.find((section2) => (0, import_boolean_point_in_polygon2.booleanPointInPolygon)(anchor, section2));
     }
     return {
       ...kiosk,
@@ -534,8 +629,8 @@ var createPopulator = ({
       anchor_id,
       venue_id,
       local_category_ids,
-      promotion_ids,
-      privilege_ids,
+      promotion_ids = [],
+      privilege_ids = [],
       kiosk_id,
       unit_id,
       kiosk_ids = [],
@@ -562,7 +657,7 @@ var createPopulator = ({
         ...occupant.properties,
         anchor: anchor ? await populateAnchor(anchor) : null,
         local_categories: await Promise.all(
-          (0, import_lodash_es2.compact)(localCategories).map(populateTaxonomy)
+          compact(localCategories).map(populateTaxonomy)
         ),
         venue,
         promotions,
@@ -599,12 +694,29 @@ var createPopulator = ({
       }
     };
   };
+  const populateRelationship = async (relationship) => {
+    const originId = relationship.properties.origin?.id;
+    const destinationId = relationship.properties.destination?.id;
+    const origin = originId ? await internalFindById(originId) : null;
+    const destination = destinationId ? await internalFindById(destinationId) : null;
+    const intermediary_ids = (relationship.properties.intermediary || []).map(({ id }) => id);
+    const intermediary = await Promise.all(intermediary_ids.map(internalFindById));
+    return {
+      ...relationship,
+      properties: {
+        ...relationship.properties,
+        origin,
+        destination,
+        intermediary
+      }
+    };
+  };
   const populateUnit = async (unit) => {
     const venue = await internalFindById(unit.properties.venue_id);
     const level = await internalFindById(unit.properties.level_id);
     const sections = await internalFilterByType("section");
     try {
-      const section = unit.geometry.type !== "MultiPolygon" ? sections.find((section2) => (0, import_boolean_within.booleanWithin)(unit, section2)) : null;
+      const section = unit.geometry.type !== "MultiPolygon" ? sections.find((section2) => (0, import_boolean_point_in_polygon2.booleanPointInPolygon)((0, import_center2.center)(unit), section2)) : null;
       return {
         ...unit,
         properties: {
@@ -632,6 +744,20 @@ var createPopulator = ({
       }
     };
   };
+  const populateModel3D = async (model3d) => {
+    const level = await internalFindById(model3d.properties.level_id);
+    try {
+      return {
+        ...model3d,
+        properties: {
+          ...model3d.properties,
+          level: await populateLevel(level)
+        }
+      };
+    } catch (err) {
+      console.log(`error finding level`, { model3d, level });
+    }
+  };
   const populateFeature = (feature2) => Promise.resolve(feature2);
   return {
     address: populateAddress,
@@ -656,23 +782,1667 @@ var createPopulator = ({
     section: populateSection,
     unit: populateUnit,
     venue: populateVenue,
-    taxonomy: populateTaxonomy
+    taxonomy: populateTaxonomy,
+    model3d: populateModel3D
   };
 };
 
-// src/data/getDataClient.ts
-var getDataClient = (options) => {
-  const observers = /* @__PURE__ */ new Map();
-  const queryClient = options.queryClient ?? new import_query_core.QueryClient();
-  const { mode = "delivery", projectId, apiKey, baseUrl, previewToken } = options;
-  if (!projectId)
-    throw new Error(
-      "Cannot create VenueDataClient. Reason: `projectId` is missing"
-    );
-  if (mode === "delivery" && !apiKey)
-    throw new Error(
-      "Cannot create VenueDataClient. Reason: `apiKey` is missing"
-    );
+// src/data/search/getSearchClient.ts
+var import_fuse = __toESM(require("fuse.js"));
+
+// src/data/search/utils/sanitizeInput.ts
+var sanitizeInput = (str) => str.replace(/[\u200E\u200F\u202A-\u202E\u2066-\u2069]/g, "").replace(/[\-–—_./()]+/g, "").normalize("NFC").trim();
+
+// src/data/search/getSearchClient.ts
+var getSearchClient = ({ occupants, amenities }) => {
+  const fuseAmenities = new import_fuse.default(amenities, {
+    threshold: 0.2,
+    keys: [
+      { name: "properties.name", "weight": 1, getFn: (obj) => Object.values(obj.properties.name || {}) },
+      { name: "properties.category", "weight": 1 }
+    ]
+  });
+  const fuseOccupants = new import_fuse.default(occupants, {
+    threshold: 0.25,
+    // 0.2 is too strict (can't find Mo-Mo Paradise with "momo" search string)
+    includeScore: true,
+    shouldSort: true,
+    keys: [
+      { name: "properties.name", "weight": 4, getFn: (obj) => Object.values(obj.properties.name || {}) },
+      { name: "properties.keywords", "weight": 0.5 },
+      { name: "properties.category", "weight": 0.25 },
+      { name: "properties.local_category_names", "weight": 0.25 },
+      { name: "properties.description", "weight": 0.25, getFn: (occ) => Object.values(occ.properties.description || {}) },
+      { name: "properties.unit_name", "weight": 0.25 },
+      { name: "properties.kiosk_name", "weight": 0.25 }
+    ]
+  });
+  const search = (value) => {
+    const sanitizedValue = sanitizeInput(value);
+    const matchedAmenities = fuseAmenities.search(sanitizedValue);
+    const matchedOccupants = fuseOccupants.search(sanitizedValue);
+    return [...matchedAmenities, ...matchedOccupants];
+  };
+  return {
+    search
+  };
+};
+
+// src/data/navigate/getNavigateClient.ts
+var import_boolean_point_in_polygon4 = require("@turf/boolean-point-in-polygon");
+
+// src/data/navigate/graph/prepare.ts
+var import_lodash10 = __toESM(require("lodash"));
+var import_node_dijkstra = __toESM(require("node-dijkstra"));
+var import_distance3 = require("@turf/distance");
+var import_center5 = require("@turf/center");
+
+// src/data/navigate/graph/nodemap/createTraversalNodeMap.ts
+var import_distance = require("@turf/distance");
+var import_center3 = require("@turf/center");
+var import_lodash3 = __toESM(require("lodash"));
+
+// src/data/navigate/graph/constants.ts
+var ROOM_BASEDISTANCE = 1e3;
+var TERRACE_BASEDISTANCE = 1e3;
+var ESCALATOR_BASEDISTANCE = 200;
+var RAMP_BASEDISTANCE = 200;
+var ELEVATOR_BASEDISTANCE = 500;
+var STAIR_BASEDISTANCE = 1e5;
+var BASE_POI_BASEDISTANCE = 9999999;
+var DEFAULT_UNIT_BASEDISTANCE_OPTIONS = {
+  default: { baseDistance: 0 },
+  byCategory: {
+    room: { baseDistance: ROOM_BASEDISTANCE },
+    terrace: { baseDistance: TERRACE_BASEDISTANCE },
+    escalator: { baseDistance: ESCALATOR_BASEDISTANCE, scaleDistanceByLevel: false },
+    ramp: { baseDistance: RAMP_BASEDISTANCE, scaleDistanceByLevel: false },
+    elevator: { baseDistance: ELEVATOR_BASEDISTANCE, scaleDistanceByLevel: false },
+    stairs: {
+      baseDistance: STAIR_BASEDISTANCE,
+      scaleDistanceByLevel: true
+    },
+    "stairs.emergencyexit": {
+      baseDistance: STAIR_BASEDISTANCE,
+      scaleDistanceByLevel: true
+    }
+  }
+};
+
+// src/data/navigate/graph/utils/getDistanceOption.ts
+var getDistanceOptions = (options, category) => {
+  if (!options) return DEFAULT_UNIT_BASEDISTANCE_OPTIONS.byCategory[category];
+  return (category && options.byCategory?.[category]) ?? DEFAULT_UNIT_BASEDISTANCE_OPTIONS.byCategory[category] ?? options?.default ?? DEFAULT_UNIT_BASEDISTANCE_OPTIONS.default;
+};
+
+// src/data/utils/trace.ts
+var trace = (namespace, text, ms, color) => {
+  if (process.env.NODE_ENV !== "test") console.log(`[${namespace}] %c${text.padEnd(90)}   ${ms !== void 0 ? `${ms.toFixed(1).padStart(6)} ms` : ``}`, color ? `color: ${color}` : void 0);
+};
+
+// src/data/navigate/graph/nodemap/createTraversalNodeMap.ts
+var createTraversalNodeMap = (unitOpenings, options) => {
+  const { units } = options.data;
+  let counter = 0;
+  const calculateFeatureDistanceWithinUnit = (features, distanceOptions) => {
+    let relationshipGraph = {};
+    for (let currentIndex = 0; currentIndex < features.length; currentIndex++) {
+      const isLastItem = currentIndex + 1 === features.length;
+      if (isLastItem) break;
+      for (let j = currentIndex + 1; j < features.length; j++) {
+        const opening = features[currentIndex];
+        const feature2 = features[j];
+        try {
+          const distance5 = (0, import_distance.distance)(
+            (0, import_center3.center)(opening.geometry),
+            (0, import_center3.center)(feature2.geometry),
+            { units: "meters" }
+          ) + (distanceOptions?.baseDistance ?? 0);
+          if (opening.id === feature2.id) continue;
+          import_lodash3.default.set(relationshipGraph, `${opening.id}.${feature2.id}`, distance5);
+          import_lodash3.default.set(relationshipGraph, `${feature2.id}.${opening.id}`, distance5);
+          counter++;
+        } catch (error) {
+          continue;
+        }
+      }
+    }
+    return relationshipGraph;
+  };
+  const t0 = performance.now();
+  const nodeMap = import_lodash3.default.reduce(
+    unitOpenings,
+    (acc, openings, unitId) => {
+      const unit = units.find((unit2) => unit2.id === unitId);
+      const unitDistanceOption = getDistanceOptions(options.unitDistanceOptions, unit.properties.category);
+      return import_lodash3.default.merge(
+        acc,
+        calculateFeatureDistanceWithinUnit(openings, unitDistanceOption)
+      );
+    },
+    {}
+  );
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} traversal relationships`, t1 - t0);
+  return nodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createElevatorNodeMap.ts
+var import_lodash4 = __toESM(require("lodash"));
+var createElevatorNodeMap = (elevatorLikeRelationships, unitOpenings, options) => {
+  const t0 = performance.now();
+  const { levels, units } = options.data;
+  const distanceOptions = getDistanceOptions(options.unitDistanceOptions, "elevator");
+  const {
+    baseDistance = ELEVATOR_BASEDISTANCE,
+    scaleDistanceByLevel = false
+  } = distanceOptions;
+  let elevatorNodeMap = {};
+  let counter = 0;
+  for (const relationship of elevatorLikeRelationships) {
+    try {
+      const {
+        origin: originTypeAndId,
+        intermediary,
+        destination: destinationTypeAndId
+      } = relationship.properties;
+      const origin = units.find((unit) => unit.id === originTypeAndId.id);
+      if (!origin) return;
+      const originOpenings = compact(unitOpenings[origin.id]);
+      const originLevel = levels.find((level) => level.id === origin.properties.level_id);
+      const destination = units.find((unit) => unit.id === destinationTypeAndId.id);
+      const destinationOpenings = unitOpenings[destination.id];
+      const destinationOpeningAndLevels = destinationOpenings.map((opening) => {
+        const level = levels.find((level2) => level2.id === destination.properties.level_id);
+        return { opening, level };
+      });
+      const intermediaryOpeningAndLevels = intermediary.map((unitTypeAndId) => {
+        const openings = unitOpenings[unitTypeAndId.id];
+        const unit = units.find((unit2) => unit2.id === unitTypeAndId.id);
+        const level = levels.find((level2) => level2.id === unit.properties.level_id);
+        return openings.map((opening) => ({ opening, level }));
+      }).flat();
+      const connections = compact([...intermediaryOpeningAndLevels, ...destinationOpeningAndLevels]);
+      if (!originOpenings || originOpenings.length === 0) return;
+      for (const originOpening of originOpenings) {
+        for (const connection of connections) {
+          const { opening, level } = connection;
+          let distance5 = baseDistance;
+          if (scaleDistanceByLevel) {
+            const originOrdinal = originLevel.properties.ordinal;
+            const connectionOrdinal = level.properties.ordinal;
+            const levelDifference = Math.abs(originOrdinal - connectionOrdinal);
+            if (levelDifference > 0) distance5 *= levelDifference;
+          }
+          import_lodash4.default.set(elevatorNodeMap, `${originOpening.id}.${opening.id}`, distance5);
+          import_lodash4.default.set(elevatorNodeMap, `${opening.id}.${originOpening.id}`, distance5);
+          counter++;
+        }
+      }
+    } catch (err) {
+      console.log(err);
+      console.log("cannot create elevatorNodeMap for ", { relationship });
+    }
+  }
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} escalator relationships`, t1 - t0);
+  return elevatorNodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createEscalatorNodeMap.ts
+var import_set = __toESM(require("lodash/set"));
+var createEscalatorNodeMap = (relationships, options) => {
+  const t0 = performance.now();
+  const distanceOptions = getDistanceOptions(options.unitDistanceOptions, "escalator");
+  let counter = 0;
+  let nodeMap = {};
+  for (const relationship of relationships) {
+    const {
+      properties: { direction, origin, destination }
+    } = relationship;
+    (0, import_set.default)(nodeMap, `${origin.id}.${destination.id}`, distanceOptions.baseDistance);
+    if (direction === "undirected") {
+      (0, import_set.default)(nodeMap, `${destination.id}.${origin.id}`, distanceOptions.baseDistance);
+    }
+    counter++;
+  }
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} escalator relationships`, t1 - t0);
+  return nodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createRampNodeMap.ts
+var import_set2 = __toESM(require("lodash/set"));
+var createRampNodeMap = (relationships, options) => {
+  const t0 = performance.now();
+  const distanceOptions = getDistanceOptions(options.unitDistanceOptions, "ramp");
+  let counter = 0;
+  let nodeMap = {};
+  relationships.forEach((relationship) => {
+    const {
+      properties: { origin, destination }
+    } = relationship;
+    (0, import_set2.default)(nodeMap, `${origin.id}.${destination.id}`, distanceOptions.baseDistance);
+    (0, import_set2.default)(nodeMap, `${destination.id}.${origin.id}`, distanceOptions.baseDistance);
+    counter++;
+  });
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} ramp relationships`, t1 - t0);
+  return nodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createStairNodeMap.ts
+var import_lodash6 = __toESM(require("lodash"));
+var createStairNodeMap = (elevatorLikeRelationships, unitOpenings, options) => {
+  const t0 = performance.now();
+  const { levels = [], openings = [], units = [] } = options.data;
+  const { baseDistance, scaleDistanceByLevel } = getDistanceOptions(options.unitDistanceOptions, "stairs");
+  let elevatorNodeMap = {};
+  let counter = 0;
+  for (const relationship of elevatorLikeRelationships) {
+    try {
+      const {
+        origin: { id: originId },
+        intermediary,
+        destination: { id: destinationId }
+      } = relationship.properties;
+      const origin = openings.find((opening) => opening.id === originId);
+      if (!origin) return;
+      const originLevel = levels.find((level) => level.id === origin.properties.level_id);
+      const destination = openings.find((opening) => opening.id === destinationId);
+      const destinationOpeningAndLevel = {
+        opening: destination,
+        level: levels.find((level) => level.id === destination.properties.level_id)
+      };
+      const intermediaryOpeningAndLevels = intermediary.map((unitTypeAndId) => {
+        const openings2 = unitOpenings[unitTypeAndId.id];
+        const unit = units.find((unit2) => unit2.id === unitTypeAndId.id);
+        const level = levels.find((level2) => level2.id === unit.properties.level_id);
+        return openings2.map((opening) => ({ opening, level }));
+      }).flat();
+      const connections = [...intermediaryOpeningAndLevels, destinationOpeningAndLevel];
+      if (!origin) return;
+      for (const connection of connections) {
+        const { opening, level } = connection;
+        let distance5 = baseDistance;
+        if (scaleDistanceByLevel) {
+          const originOrdinal = originLevel.properties.ordinal;
+          const connectionOrdinal = level.properties.ordinal;
+          const levelDifference = Math.abs(originOrdinal - connectionOrdinal);
+          if (levelDifference > 0) distance5 *= levelDifference;
+        }
+        import_lodash6.default.set(elevatorNodeMap, `${origin.id}.${opening.id}`, distance5);
+        import_lodash6.default.set(elevatorNodeMap, `${opening.id}.${origin.id}`, distance5);
+        counter++;
+      }
+    } catch (err) {
+      console.warn(
+        "Failed to create stairNodeMap",
+        {
+          relationshipId: relationship.id,
+          featureType: relationship.feature_type,
+          error: err instanceof Error ? err.message : err,
+          stack: err instanceof Error ? err.stack : void 0
+        }
+      );
+    }
+  }
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} stairs relationships`, t1 - t0);
+  return elevatorNodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createOccupantNodeMap.ts
+var import_lodash7 = __toESM(require("lodash"));
+var createOccupantNodeMap = (occupants) => {
+  const t0 = performance.now();
+  let nodeMap = {};
+  let counter = 0;
+  occupants.forEach((occupant) => {
+    const { unit_id, unit_ids = [], kiosk_id, kiosk_ids = [] } = occupant.properties;
+    const occupantRoomIds = compact([unit_id, ...unit_ids]);
+    const occupantKioskIds = compact([kiosk_id, ...kiosk_ids]);
+    for (const roomId of occupantRoomIds) {
+      import_lodash7.default.set(nodeMap, `${roomId}.${occupant.id}`, 1e-3);
+      import_lodash7.default.set(nodeMap, `${occupant.id}.${roomId}`, 1e-3);
+      counter++;
+    }
+    for (const kioskId of occupantKioskIds) {
+      import_lodash7.default.set(nodeMap, `${kioskId}.${occupant.id}`, 1e-3);
+      import_lodash7.default.set(nodeMap, `${occupant.id}.${kioskId}`, 1e-3);
+      counter++;
+    }
+  });
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} occupants relationships`, t1 - t0);
+  return nodeMap;
+};
+
+// src/data/navigate/graph/nodemap/createPOINodeMaps.ts
+var import_center4 = require("@turf/center");
+var import_distance2 = require("@turf/distance");
+var import_lodash9 = __toESM(require("lodash"));
+var createPOINodeMap = (features, getFeatureUnit, unitOpenings) => {
+  const t0 = performance.now();
+  let nodeMap = {};
+  let counter = 0;
+  features.forEach((feat) => {
+    try {
+      const locatedOnUnitId = getFeatureUnit(feat);
+      const openings = unitOpenings[locatedOnUnitId];
+      const center8 = (0, import_center4.center)(feat);
+      for (const opening of openings) {
+        try {
+          const openingCenter = (0, import_center4.center)(opening);
+          const dis = (0, import_distance2.distance)(center8, openingCenter, { units: "meters" }) + BASE_POI_BASEDISTANCE;
+          import_lodash9.default.set(nodeMap, `${opening.id}.${feat.id}`, dis);
+          import_lodash9.default.set(nodeMap, `${feat.id}.${opening.id}`, dis);
+          counter++;
+        } catch (err) {
+          console.log(err, opening);
+        }
+      }
+    } catch (err) {
+      console.log(err);
+      console.log(`cannot connect poi to openings`, err.message, { feat });
+    }
+  });
+  const type = features.length > 0 ? features[0].feature_type : "-";
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} ${type} relationships`, t1 - t0);
+  return nodeMap;
+};
+
+// src/data/navigate/graph/utils/mergeNodeMap.ts
+var mergeNodeMap = (nodeMaps) => {
+  const out = {};
+  for (const nodeMap of nodeMaps) {
+    for (const from in nodeMap) {
+      out[from] = {
+        ...out[from] ?? {},
+        ...nodeMap[from]
+      };
+    }
+  }
+  return out;
+};
+
+// src/data/navigate/graph/utils/createUnitOpenings.ts
+var import_uniqBy = __toESM(require("lodash/uniqBy"));
+var createUnitOpenings = (relationships, units, openings) => {
+  const openingConnections = {};
+  const relationshipMap = /* @__PURE__ */ new Map();
+  relationships.forEach((relationship) => {
+    const originId = relationship.properties.origin?.id || null;
+    const destinationId = relationship.properties.destination?.id || null;
+    if (!relationshipMap.has(originId)) {
+      relationshipMap.set(originId, []);
+    }
+    if (!relationshipMap.has(destinationId)) {
+      relationshipMap.set(destinationId, []);
+    }
+    relationshipMap.get(originId).push(relationship);
+    relationshipMap.get(destinationId).push(relationship);
+  });
+  units.forEach((unit) => {
+    const unitId = unit.id;
+    const connectedRelationshop = relationshipMap.get(unitId) || [];
+    const relationshipIntermediaryTypeAndId = connectedRelationshop.map(
+      (relationship) => relationship.properties.intermediary[0]
+      // Assuming intermediary is always an array
+    );
+    const relationshipIntermediary = relationshipIntermediaryTypeAndId.map(({ id }) => {
+      return openings.find((opening) => opening.id === id);
+    });
+    openingConnections[unitId] = (0, import_uniqBy.default)(
+      [...openingConnections[unitId] || [], ...relationshipIntermediary],
+      "id"
+    );
+  });
+  return openingConnections;
+};
+
+// 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 = []
+    }
+  } = options;
+  const {
+    traversal: traversalRelationships = [],
+    escalator: escalatorRelationships = [],
+    ramp: rampRelationships = [],
+    elevator: elevatorRelationships = [],
+    stairs: stairsRelationships = []
+  } = import_lodash10.default.groupBy(relationships, "properties.category");
+  const unitOpenings = createUnitOpenings(traversalRelationships, units, openings);
+  const traversalNodeMap = createTraversalNodeMap(unitOpenings, options);
+  const escalatorNodeMap = createEscalatorNodeMap(escalatorRelationships, options);
+  const rampNodeMap = createRampNodeMap(rampRelationships, options);
+  const elevatorNodeMap = createElevatorNodeMap(
+    elevatorRelationships,
+    unitOpenings,
+    options
+  );
+  const stairNodeMap = createStairNodeMap(
+    stairsRelationships,
+    unitOpenings,
+    options
+  );
+  const amenityNodeMap = createPOINodeMap(amenities, (amenity) => amenity.properties.unit_ids[0], unitOpenings);
+  const anchorsNodeMap = createPOINodeMap(anchors, (anchor) => anchor.properties.unit_id, unitOpenings);
+  const walkwayUnits = units.filter((unit) => unit.properties.category === "walkway");
+  const kioskNodeMap = createPOINodeMap(kiosks, (kiosk) => findContainingUnit(kiosk, walkwayUnits)?.id, unitOpenings);
+  const unitNodeMap = createPOINodeMap(units, (unit) => unit.id, unitOpenings);
+  const occupantNodeMap = createOccupantNodeMap(occupants);
+  const defaultGraph = new import_node_dijkstra.default(mergeNodeMap([
+    traversalNodeMap,
+    escalatorNodeMap,
+    rampNodeMap,
+    elevatorNodeMap,
+    stairNodeMap,
+    amenityNodeMap,
+    anchorsNodeMap,
+    kioskNodeMap,
+    unitNodeMap,
+    occupantNodeMap
+  ]));
+  const accessibleGraph = new import_node_dijkstra.default(mergeNodeMap([
+    traversalNodeMap,
+    rampNodeMap,
+    elevatorNodeMap,
+    amenityNodeMap,
+    anchorsNodeMap,
+    kioskNodeMap,
+    unitNodeMap,
+    occupantNodeMap
+  ]));
+  const addCoordinateOrdinalNode = (params, locatedOnUnit) => {
+    const [lat, lng, ordinal] = parseOrdinalCoordinate(params);
+    if (locatedOnUnit) {
+      const openings2 = unitOpenings[locatedOnUnit.id];
+      for (const opening of openings2) {
+        const openingCenter = (0, import_center5.center)(opening);
+        const dis = (0, import_distance3.distance)([lat, lng], openingCenter, { units: "meters" });
+        defaultGraph.addNode(params, { [opening.id]: dis }).addNode(opening.id, { [params]: dis });
+        accessibleGraph.addNode(params, { [opening.id]: dis }).addNode(opening.id, { [params]: dis });
+      }
+    }
+  };
+  return { defaultGraph, accessibleGraph, unitOpenings, addCoordinateOrdinalNode };
+};
+
+// src/data/navigate/steps/createStepUtils.ts
+var import_lodash12 = require("lodash");
+var import_intersectionBy = __toESM(require("lodash/intersectionBy"));
+
+// src/data/navigate/description/describe.ts
+var t = (template, locale, options) => {
+  return template.replace(`{{intermediary}}`, options.intermediary ?? "").replace(`{{toward}}`, options.toward?.[locale] ?? "").replace(`{{landmark}}`, options.landmark?.[locale] ?? "");
+};
+var describeVerticalStep = (fromLevel, toLevel, intermediary) => {
+  const dir = fromLevel.properties.ordinal < toLevel.properties.ordinal ? "up" : "down";
+  const template = `Take the {{intermediary}} ${dir} to {{toward}}`;
+  return {
+    template,
+    text: t(template, "en", { intermediary, toward: toLevel.properties.name })
+  };
+};
+var describeHorizontalStep = (intermediary, toward, landmark) => {
+  const template = `Follow the path ${intermediary === "walkway" ? `along the walkway` : `through {{intermediary}}`} ${toward ? `toward {{toward}}` : ``} ${landmark ? `near {{landmark}}` : ``}`.trim();
+  return {
+    text: t(template, "en", { intermediary, toward, landmark }),
+    template
+  };
+};
+
+// src/data/navigate/steps/path/index.ts
+var import_lodash11 = __toESM(require("lodash"));
+
+// src/data/navigate/constants.ts
+var OBSTACLE_FEATURE_TYPES = [
+  "kiosk"
+  /* , "fixture" */
+];
+var OBSTACLE_CATEGORIES = [
+  "fixture.water",
+  "fixture.stage",
+  "nonpublic",
+  "opentobelow",
+  "elevator",
+  "escalator",
+  "stairs",
+  "stairs.emergencyexit",
+  "room",
+  "unspecified",
+  "structure",
+  "brick",
+  "concrete",
+  "drywall",
+  "glass",
+  "wood",
+  "column"
+];
+var WALKABLE_CATEGORY = [
+  "walkway",
+  "parking",
+  "room",
+  "terrace",
+  "unenclosedarea",
+  "vegetation",
+  "unspecified"
+];
+
+// node_modules/@turf/helpers/dist/esm/index.js
+var earthRadius = 63710088e-1;
+var factors = {
+  centimeters: earthRadius * 100,
+  centimetres: earthRadius * 100,
+  degrees: 360 / (2 * Math.PI),
+  feet: earthRadius * 3.28084,
+  inches: earthRadius * 39.37,
+  kilometers: earthRadius / 1e3,
+  kilometres: earthRadius / 1e3,
+  meters: earthRadius,
+  metres: earthRadius,
+  miles: earthRadius / 1609.344,
+  millimeters: earthRadius * 1e3,
+  millimetres: earthRadius * 1e3,
+  nauticalmiles: earthRadius / 1852,
+  radians: 1,
+  yards: earthRadius * 1.0936
+};
+function feature(geom, properties, options = {}) {
+  const feat = { type: "Feature" };
+  if (options.id === 0 || options.id) {
+    feat.id = options.id;
+  }
+  if (options.bbox) {
+    feat.bbox = options.bbox;
+  }
+  feat.properties = properties || {};
+  feat.geometry = geom;
+  return feat;
+}
+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 (!isNumber(coordinates[0]) || !isNumber(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 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];
+    }
+  }
+  if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
+    return [...coord];
+  }
+  throw new Error("coord must be GeoJSON Point or an Array of numbers");
+}
+function getGeom(geojson) {
+  if (geojson.type === "Feature") {
+    return geojson.geometry;
+  }
+  return geojson;
+}
+function getType(geojson, _name) {
+  if (geojson.type === "FeatureCollection") {
+    return "FeatureCollection";
+  }
+  if (geojson.type === "GeometryCollection") {
+    return "GeometryCollection";
+  }
+  if (geojson.type === "Feature" && geojson.geometry !== null) {
+    return geojson.geometry.type;
+  }
+  return geojson.type;
+}
+
+// src/data/navigate/steps/path/index.ts
+var import_difference = __toESM(require("@turf/difference"));
+var import_envelope = __toESM(require("@turf/envelope"));
+var import_boolean_overlap = __toESM(require("@turf/boolean-overlap"));
+var import_boolean_intersects = __toESM(require("@turf/boolean-intersects"));
+
+// ../../node_modules/@turf/meta/dist/esm/index.js
+function coordEach(geojson, callback, excludeWrapCoord) {
+  if (geojson === null) return;
+  var j, k, l, geometry, stopG, coords, geometryMaybeCollection, wrapShrink = 0, coordIndex = 0, isGeometryCollection, type = geojson.type, isFeatureCollection = type === "FeatureCollection", isFeature = type === "Feature", stop = isFeatureCollection ? geojson.features.length : 1;
+  for (var featureIndex = 0; featureIndex < stop; featureIndex++) {
+    geometryMaybeCollection = isFeatureCollection ? geojson.features[featureIndex].geometry : isFeature ? geojson.geometry : geojson;
+    isGeometryCollection = geometryMaybeCollection ? geometryMaybeCollection.type === "GeometryCollection" : false;
+    stopG = isGeometryCollection ? geometryMaybeCollection.geometries.length : 1;
+    for (var geomIndex = 0; geomIndex < stopG; geomIndex++) {
+      var multiFeatureIndex = 0;
+      var geometryIndex = 0;
+      geometry = isGeometryCollection ? geometryMaybeCollection.geometries[geomIndex] : geometryMaybeCollection;
+      if (geometry === null) continue;
+      coords = geometry.coordinates;
+      var geomType = geometry.type;
+      wrapShrink = excludeWrapCoord && (geomType === "Polygon" || geomType === "MultiPolygon") ? 1 : 0;
+      switch (geomType) {
+        case null:
+          break;
+        case "Point":
+          if (callback(
+            coords,
+            coordIndex,
+            featureIndex,
+            multiFeatureIndex,
+            geometryIndex
+          ) === false)
+            return false;
+          coordIndex++;
+          multiFeatureIndex++;
+          break;
+        case "LineString":
+        case "MultiPoint":
+          for (j = 0; j < coords.length; j++) {
+            if (callback(
+              coords[j],
+              coordIndex,
+              featureIndex,
+              multiFeatureIndex,
+              geometryIndex
+            ) === false)
+              return false;
+            coordIndex++;
+            if (geomType === "MultiPoint") multiFeatureIndex++;
+          }
+          if (geomType === "LineString") multiFeatureIndex++;
+          break;
+        case "Polygon":
+        case "MultiLineString":
+          for (j = 0; j < coords.length; j++) {
+            for (k = 0; k < coords[j].length - wrapShrink; k++) {
+              if (callback(
+                coords[j][k],
+                coordIndex,
+                featureIndex,
+                multiFeatureIndex,
+                geometryIndex
+              ) === false)
+                return false;
+              coordIndex++;
+            }
+            if (geomType === "MultiLineString") multiFeatureIndex++;
+            if (geomType === "Polygon") geometryIndex++;
+          }
+          if (geomType === "Polygon") multiFeatureIndex++;
+          break;
+        case "MultiPolygon":
+          for (j = 0; j < coords.length; j++) {
+            geometryIndex = 0;
+            for (k = 0; k < coords[j].length; k++) {
+              for (l = 0; l < coords[j][k].length - wrapShrink; l++) {
+                if (callback(
+                  coords[j][k][l],
+                  coordIndex,
+                  featureIndex,
+                  multiFeatureIndex,
+                  geometryIndex
+                ) === false)
+                  return false;
+                coordIndex++;
+              }
+              geometryIndex++;
+            }
+            multiFeatureIndex++;
+          }
+          break;
+        case "GeometryCollection":
+          for (j = 0; j < geometry.geometries.length; j++)
+            if (coordEach(geometry.geometries[j], callback, excludeWrapCoord) === false)
+              return false;
+          break;
+        default:
+          throw new Error("Unknown Geometry Type");
+      }
+    }
+  }
+}
+
+// ../../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/data/navigate/steps/path/turf/shortestPath.ts
+var import_boolean_point_in_polygon3 = __toESM(require("@turf/boolean-point-in-polygon"));
+var import_distance4 = __toESM(require("@turf/distance"));
+var import_transform_scale = __toESM(require("@turf/transform-scale"));
+var import_union = __toESM(require("@turf/union"));
+var import_bbox_polygon = __toESM(require("@turf/bbox-polygon"));
+var import_clean_coords = require("@turf/clean-coords");
+var import_pathfinding = __toESM(require("pathfinding"));
+var import_set3 = __toESM(require("lodash/set"));
+
+// src/data/navigate/steps/path/turf/stringPull.ts
+function stringPull(grid, path) {
+  const isWalkable = (x, y) => grid.isInside(x, y) && grid.isWalkableAt(x, y);
+  function hasLOS(a, b) {
+    let x0 = a[0], y0 = a[1];
+    const x1 = b[0], y1 = b[1];
+    if (!isWalkable(x0, y0) || !isWalkable(x1, y1)) return false;
+    const dx = Math.abs(x1 - x0);
+    const dy = Math.abs(y1 - y0);
+    const sx = x0 < x1 ? 1 : -1;
+    const sy = y0 < y1 ? 1 : -1;
+    let err = dx - dy;
+    while (true) {
+      if (!isWalkable(x0, y0)) return false;
+      if (x0 === x1 && y0 === y1) break;
+      const e2 = err * 2;
+      let nx = x0;
+      let ny = y0;
+      let movedX = false;
+      let movedY = false;
+      if (e2 > -dy) {
+        err -= dy;
+        nx += sx;
+        movedX = true;
+      }
+      if (e2 < dx) {
+        err += dx;
+        ny += sy;
+        movedY = true;
+      }
+      if (movedX && movedY) {
+        if (!isWalkable(nx, y0) || !isWalkable(x0, ny)) return false;
+      }
+      x0 = nx;
+      y0 = ny;
+    }
+    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;
+    }
+    out.push(path[best]);
+    i = best;
+  }
+  return out;
+}
+
+// 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.at(-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.at(-1));
+  return out;
+}
+
+// src/data/navigate/steps/path/turf/pruneShortSegments.ts
+function pruneShortSegments(path, minLen = 5) {
+  const out = [path[0]];
+  for (let i = 1; i < path.length; i++) {
+    const [x0, y0] = out.at(-1);
+    const [x1, y1] = path[i];
+    if (Math.hypot(x1 - x0, y1 - y0) >= minLen) {
+      out.push(path[i]);
+    }
+  }
+  return out;
+}
+
+// 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]);
+      }
+    }
+  }
+  const dirs = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1],
+    [1, 1],
+    [1, -1],
+    [-1, 1],
+    [-1, -1]
+  ];
+  let qi = 0;
+  while (qi < q.length) {
+    const [x, y] = q[qi++];
+    const d0 = dist[y][x];
+    for (const [dx, dy] of dirs) {
+      const nx = x + dx, ny = y + dy;
+      if (nx < 0 || ny < 0 || nx >= w || ny >= h) continue;
+      const nd = d0 + 1;
+      if (nd < dist[ny][nx]) {
+        dist[ny][nx] = nd;
+        q.push([nx, ny]);
+      }
+    }
+  }
+  return 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 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((0, import_transform_scale.default)((0, import_bbox_polygon.default)(index_default(collection)), 1.15));
+  if (!resolution) {
+    const width = (0, import_distance4.default)([box[0], box[1]], [box[2], box[1]], options);
+    resolution = width / 100;
+  }
+  collection.features.pop();
+  collection.features.pop();
+  const [west, south, east, north] = box;
+  const xFraction = resolution / (0, import_distance4.default)([west, south], [east, south], options);
+  const cellWidth = xFraction * (east - west);
+  const yFraction = resolution / (0, import_distance4.default)([west, south], [west, north], options);
+  const cellHeight = yFraction * (north - south);
+  const bboxHorizontalSide = east - west;
+  const bboxVerticalSide = north - south;
+  const columns = Math.floor(bboxHorizontalSide / cellWidth);
+  const rows = Math.floor(bboxVerticalSide / cellHeight);
+  const deltaX = (bboxHorizontalSide - columns * cellWidth) / 2;
+  const deltaY = (bboxVerticalSide - rows * cellHeight) / 2;
+  let closestToStart = null, closestToEnd = null, minDistStart = Infinity, minDistEnd = Infinity, currentY = north - deltaY, currentX = west + deltaX, row = 0, column = 0, distStart, distEnd, pt, isInsideObstacle;
+  const roundLoopY = Math.ceil((currentY - south) / cellHeight);
+  const roundLoopX = Math.ceil((east - currentX) / cellWidth);
+  let totalRounds = roundLoopX * roundLoopY;
+  const pointMatrix = [];
+  const matrix = [];
+  const obstacleTotal = collection.features.length;
+  const obstacleFeatures = collection.features;
+  let combinedObstacle = obstacleFeatures[0];
+  let obstacleIndex = 0;
+  for (obstacleIndex = 0; obstacleIndex < obstacleTotal; obstacleIndex++) {
+    const nextObstacleFeature = obstacleFeatures[obstacleIndex + 1];
+    if (!nextObstacleFeature) continue;
+    try {
+      combinedObstacle = (0, import_union.default)(
+        featureCollection([combinedObstacle, nextObstacleFeature])
+      );
+    } catch (e) {
+      console.log(e);
+    }
+  }
+  while (totalRounds--) {
+    pt = point([currentX, currentY]);
+    isInsideObstacle = (0, import_boolean_point_in_polygon3.default)(pt, combinedObstacle);
+    (0, import_set3.default)(matrix, `[${row}][${column}]`, isInsideObstacle ? 1 : 0);
+    (0, import_set3.default)(pointMatrix, `[${row}][${column}]`, `${currentX}|${currentY}`);
+    distStart = (0, import_distance4.default)(pt, start);
+    if (!isInsideObstacle && distStart < minDistStart) {
+      minDistStart = distStart;
+      closestToStart = { x: column, y: row };
+    }
+    distEnd = (0, import_distance4.default)(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++;
+    }
+  }
+  const finder = new import_pathfinding.default.AStarFinder({
+    allowDiagonal: true,
+    dontCrossCorners: true,
+    heuristic: import_pathfinding.default.Heuristic.euclidean
+  });
+  const grid = new import_pathfinding.default.Grid(matrix);
+  const startOnMatrix = [closestToStart.x, closestToStart.y];
+  const endOnMatrix = [closestToEnd.x, closestToEnd.y];
+  let result = finder.findPath(...startOnMatrix, ...endOnMatrix, grid);
+  if (result.length > 0) {
+    result = stringPull(grid, result);
+    const clearanceGrid = buildClearanceGrid(matrix);
+    const isWalkable = (x, y) => grid.isInside(x, y) && grid.isWalkableAt(x, y);
+    result = centerlineSnapPath(result, clearanceGrid, isWalkable);
+    result = stringPull(grid, result);
+    result = pruneSmallAngles(result);
+    result = pruneShortSegments(result);
+  }
+  result.pop();
+  result.shift();
+  const path = [startCoord];
+  result.forEach((coord) => {
+    const coords = pointMatrix[coord[1]][coord[0]].split("|");
+    path.push([+coords[0], +coords[1]]);
+  });
+  path.push(endCoord);
+  return (0, import_clean_coords.cleanCoords)(lineString(path));
+}
+var 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));
+    });
+  };
+  const findObstaclesFromWalkway = (intermediaryUnit, exceptionIds = []) => {
+    const result = featureCollection([]);
+    if (!intermediaryUnit) return result;
+    const walkwayLevelId = intermediaryUnit.properties.level_id;
+    const obstacleOnLevel = filterObstaclesByOrdinal(walkwayLevelId).filter(
+      (obstacle) => !exceptionIds.includes(obstacle.id)
+    );
+    const relatedObstacleWithIntermediary = obstacleOnLevel.reduce(
+      (obstacles, feature2) => {
+        if (
+          // Prevent detecting itself as an obstacle
+          // Ex. Unable to draw a line to amenity located with in a room as room is also consider as obstacle
+          feature2.id !== intermediaryUnit.id && ((0, import_boolean_overlap.default)(intermediaryUnit, feature2) || (0, import_boolean_intersects.default)(intermediaryUnit, feature2))
+        ) {
+          const polygons = getType(feature2) === "Polygon" ? [polygon(feature2.geometry.coordinates, { id: feature2.id })] : feature2.geometry.coordinates.map((ring) => polygon(ring, { id: feature2.id }));
+          obstacles.push(...polygons);
+        }
+        return obstacles;
+      },
+      []
+    );
+    const intermediaryExtends = (0, import_envelope.default)(intermediaryUnit);
+    const walkwayPerimeter = (0, import_difference.default)(
+      featureCollection([intermediaryExtends, intermediaryUnit])
+    );
+    result.features.push(...relatedObstacleWithIntermediary, walkwayPerimeter);
+    return result;
+  };
+  const findPathOnArea = (originPoint, destinationPoint, options2) => {
+    const { obstacles = featureCollection([]), resolution: resolution2, properties } = options2 || {};
+    const stepPath = shortestPath_default(originPoint, destinationPoint, {
+      obstacles,
+      smoothenPath: false,
+      resolution: resolution2
+    });
+    stepPath.properties = properties;
+    return stepPath;
+  };
+  const findStepPath = (from, to, intermediaries) => {
+    const t0 = performance.now();
+    const relatedWalkablePlatform = intermediaries.find(
+      (feature2) => WALKABLE_CATEGORY.includes(feature2.properties.category)
+    );
+    const exceptionFeatureIds = [];
+    const obstacles = findObstaclesFromWalkway(
+      relatedWalkablePlatform,
+      import_lodash11.default.compact(exceptionFeatureIds)
+    );
+    const line = findPathOnArea(from, to, {
+      resolution,
+      obstacles
+    });
+    return line.geometry.coordinates;
+  };
+  return {
+    findStepPath
+  };
+};
+
+// src/data/navigate/steps/utils/combineWalkwaySteps.ts
+var import_uniq = __toESM(require("lodash/uniq"));
+var combineWalkwaySteps = (steps) => {
+  let result = [];
+  for (let i = 0; i < steps.length; i++) {
+    const thisStep = steps[i];
+    if (i === steps.length - 1) {
+      result.push(thisStep);
+      continue;
+    }
+    const nextStep = steps[i + 1];
+    if (thisStep.intermediaryCategory === "walkway" && nextStep.intermediaryCategory === "walkway" && thisStep.from.source.type === "opening" && nextStep.from.source.type === "opening") {
+      result.push({
+        from: thisStep.from,
+        to: nextStep.to,
+        levelIds: (0, import_uniq.default)([...thisStep.levelIds, ...nextStep.levelIds]),
+        ordinals: (0, import_uniq.default)([...thisStep.ordinals, ...nextStep.ordinals]),
+        intermediaryCategory: "walkway",
+        description: nextStep.description,
+        path: [
+          ...thisStep.path,
+          ...nextStep.path
+        ]
+      });
+      i++;
+    } else {
+      result.push(thisStep);
+    }
+  }
+  return result;
+};
+
+// src/data/navigate/steps/createStepUtils.ts
+var createStepUtils = (options) => {
+  const { data: { units, relationships }, findByIdSync } = 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 ? [matchedOne.properties.origin, matchedOne.properties.destination] : [];
+    const matchedTwo = relationships.find((rel) => rel.properties.intermediary.map((int) => int.id).includes(destination.id));
+    const matchTwoUnits = matchedTwo ? [matchedTwo.properties.origin, matchedTwo.properties.destination] : [];
+    const unitIds = (0, import_intersectionBy.default)(matchOneUnits, matchTwoUnits, "id");
+    return unitIds.map(({ id }) => findByIdSync(id));
+  };
+  const findHorizontalIntermediary = (from, to) => {
+    if (from.source.type !== "opening") {
+      const unit = findContainingUnitAtPoint(from.point, from.levelId, units);
+      return unit ? [unit] : [];
+    }
+    if (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 (0, import_lodash12.capitalize)(category);
+  };
+  const getNextStepIntermediary = (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 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 = getNextStepIntermediary(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 {
+    toSteps
+  };
+};
+
+// src/data/navigate/utils/timeDistance.ts
+var import_length = __toESM(require("@turf/length"));
+var WALKING_SPEED = 1.4;
+var calculatePathLength = (feature2) => (0, import_length.default)(feature2, { units: "kilometers" }) * 1e3;
+var calculateTravelingDuration = (distance5) => {
+  const duration = distance5 / WALKING_SPEED;
+  const minutes = Math.round(duration / 60);
+  return minutes > 0 ? minutes : 1;
+};
+var calculateTotalDistance = (steps = []) => {
+  return steps.reduce((acc, { path }) => acc + calculatePathLength(lineString(path)), 0);
+};
+var calculateRoundedDistance = (distance5) => {
+  return Math.round(distance5 - distance5 % 25);
+};
+
+// src/data/navigate/type-guard.ts
+function isCoordinateOrdinalString(id) {
+  return /^-?\d+(\.\d+)?,-?\d+(\.\d+)?,-?\d+(\.\d+)?o$/.test(id);
+}
+
+// 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/waypoint/createWaypointUtils.ts
+var import_center9 = require("@turf/center");
+
+// src/data/navigate/waypoint/extractEndWaypoint.ts
+var import_center6 = require("@turf/center");
+
+// src/data/navigate/waypoint/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/waypoint/extractEndWaypoint.ts
+var extractEndPoint = (path, options) => {
+  const { findByIdSync } = options;
+  const [c, b, a] = path.slice(-3);
+  if (isOccupant(a) && isUnit(b) && isOpening(c)) {
+    const occ = findByIdSync(a);
+    const opening = findByIdSync(c);
+    const level = findByIdSync(opening.properties.level_id);
+    return [
+      {
+        id: occ.id,
+        type: "end",
+        name: occ.properties.name,
+        point: (0, import_center6.center)(opening).geometry.coordinates,
+        levelId: opening.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "opening", id: opening.id }
+      },
+      path.slice(0, -3)
+    ];
+  }
+  if (isOccupant(a) && isKiosk(b)) {
+    const occ = findByIdSync(a);
+    const kiosk = findByIdSync(b);
+    const level = findByIdSync(kiosk.properties.level_id);
+    return [
+      {
+        id: occ.id,
+        type: "end",
+        name: occ.properties.name,
+        point: (0, import_center6.center)(kiosk).geometry.coordinates,
+        levelId: kiosk.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "kiosk", id: kiosk.id }
+      },
+      path.slice(0, -2)
+    ];
+  }
+  if (isCoordinateOrdinalString(a) && isOpening(b)) {
+    const [lat, lng, ordinal] = parseOrdinalCoordinate(a);
+    const opening = findByIdSync(b);
+    return [
+      {
+        id: a,
+        type: "end",
+        name: { en: a },
+        point: [lng, lat],
+        levelId: opening.properties.level_id,
+        ordinal,
+        source: { type: "coordinate", raw: a }
+      },
+      path.slice(0, -1)
+    ];
+  }
+  return [null, path];
+};
+
+// src/data/navigate/waypoint/extractStartWaypoint.ts
+var import_center7 = require("@turf/center");
+var extractStartPoint = (path, options) => {
+  const { findByIdSync } = options;
+  const [a, b, c] = path;
+  if (isOccupant(a) && isUnit(b) && isOpening(c)) {
+    const occ = findByIdSync(a);
+    const opening = findByIdSync(c);
+    const level = findByIdSync(opening.properties.level_id);
+    return [
+      {
+        id: occ.id,
+        type: "start",
+        name: occ.properties.name,
+        point: (0, import_center7.center)(opening).geometry.coordinates,
+        levelId: opening.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "opening", id: opening.id }
+      },
+      path.slice(3)
+    ];
+  }
+  if (isOccupant(a) && isKiosk(b)) {
+    const occ = findByIdSync(a);
+    const kiosk = findByIdSync(b);
+    const level = findByIdSync(kiosk.properties.level_id);
+    return [
+      {
+        id: occ.id,
+        type: "start",
+        name: occ.properties.name,
+        point: (0, import_center7.center)(kiosk).geometry.coordinates,
+        levelId: kiosk.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "kiosk", id: kiosk.id }
+      },
+      path.slice(2)
+    ];
+  }
+  if (isCoordinateOrdinalString(a) && isOpening(b)) {
+    const [lat, lng, ordinal] = parseOrdinalCoordinate(a);
+    const opening = findByIdSync(b);
+    return [
+      {
+        id: a,
+        type: "start",
+        name: { en: a },
+        point: [lng, lat],
+        levelId: opening.properties.level_id,
+        ordinal,
+        source: { type: "coordinate", raw: a }
+      },
+      path.slice(1)
+    ];
+  }
+  return [null, path];
+};
+
+// src/data/navigate/landmark/createLandmarkUtils.ts
+var import_center8 = require("@turf/center");
+var import_distance5 = __toESM(require("@turf/distance"));
+var NEARBY_DISTANCE = 30;
+var createLandmarkUtils = (options) => {
+  const { data, findByIdSync } = options;
+  const { occupants = [] } = data;
+  const occupantToLandmark = (occupant) => {
+    const locationType = occupant.properties.unit_id ? "unit" : "kiosk";
+    const locationId = locationType === "unit" ? occupant.properties.unit_id : occupant.properties.kiosk_id;
+    const location = locationType === "unit" ? findByIdSync(locationId) : findByIdSync(locationId);
+    const level = findByIdSync(location.properties.level_id);
+    return {
+      name: occupant.properties.name,
+      point: (0, import_center8.center)(location.geometry).geometry.coordinates,
+      level_id: location.properties.level_id,
+      is_priority: occupant.properties.is_landmark,
+      ordinal: level.properties.ordinal
+    };
+  };
+  const landmarks = [
+    ...occupants.map(occupantToLandmark)
+  ];
+  const findNearbyLandmarks = (point2, levelId) => {
+    if (point2 === null || levelId === null) return [];
+    return landmarks.map((landmark) => {
+      const landmarkAndDistance = {
+        landmark,
+        d: (0, import_distance5.default)(point2, landmark.point, { units: "meters" })
+      };
+      return landmarkAndDistance;
+    }).filter(({ landmark, d }) => d <= NEARBY_DISTANCE && landmark.level_id === levelId).sort((a, b) => {
+      const aPriority = a.landmark.is_priority ? 0 : 1;
+      const bPriority = b.landmark.is_priority ? 0 : 1;
+      if (aPriority !== bPriority) return aPriority - bPriority;
+      return a.d - b.d;
+    }).map(({ landmark }) => landmark);
+  };
+  const findNearestLandmark = (point2, levelId) => {
+    const nearbyLandmarks = findNearbyLandmarks(point2, levelId);
+    const nearestLandmark = nearbyLandmarks.length > 0 ? nearbyLandmarks[0] : null;
+    return nearestLandmark;
+  };
+  return { findNearbyLandmarks, findNearestLandmark };
+};
+
+// src/data/navigate/waypoint/createWaypointUtils.ts
+var createWaypointUtils = (options) => {
+  const { findByIdSync } = options;
+  const landmarkUtils = createLandmarkUtils(options);
+  const toWaypoints = (path) => {
+    const [startPoint, middleAndEndPoints] = extractStartPoint(path, options);
+    const [endPoint, middlePoints] = extractEndPoint(middleAndEndPoints, options);
+    const waypoints = middlePoints.map((openingId) => {
+      const opening = findByIdSync(openingId);
+      const level = findByIdSync(opening.properties.level_id);
+      const coordinates = (0, import_center9.center)(opening).geometry.coordinates;
+      const landmark = landmarkUtils.findNearestLandmark(coordinates, opening.properties.level_id);
+      return {
+        id: `${opening.properties.level_id}:${openingId}`,
+        type: "between",
+        point: coordinates,
+        name: null,
+        levelId: opening.properties.level_id,
+        ordinal: level.properties.ordinal,
+        hint: landmark ? { kind: "landmark", name: landmark.name } : void 0,
+        source: { type: "opening", id: opening.id }
+      };
+    });
+    return [startPoint, ...waypoints, endPoint];
+  };
+  return { toWaypoints };
+};
+
+// src/data/navigate/getNavigateClient.ts
+var getNavigateClient = (options) => {
+  const { data } = options;
+  const { levels, units } = data;
+  trace("nav", "\u2713 prepare");
+  const t0 = performance.now();
+  trace("nav", "  \u251C\u2500 createGraph (dijkstra)");
+  const { defaultGraph, accessibleGraph, addCoordinateOrdinalNode } = prepareGraph({ data });
+  const t1 = performance.now();
+  trace("nav", "  \u2502    \u2514\u2500 Total ", t1 - t0);
+  const t2 = performance.now();
+  const { findByIdSync } = createFindByIdSync(data);
+  const t3 = performance.now();
+  trace("nav", "  \u2514\u2500 findByIdSync", t3 - t2);
+  const findCoordinateOrdinalUnit = (params) => {
+    const [lat, lng, ordinal] = parseOrdinalCoordinate(params);
+    const levelIdsWithOrdinal = levels.filter((level) => level.properties.ordinal === ordinal).map((level) => level.id);
+    const unit = units.find((unit2) => levelIdsWithOrdinal.includes(unit2.properties.level_id) && (0, import_boolean_point_in_polygon4.booleanPointInPolygon)([lat, lng], unit2));
+    return unit;
+  };
+  const stepUtils = createStepUtils({ ...options, findByIdSync });
+  const waypointUtils = createWaypointUtils({ ...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 = waypointUtils.toWaypoints(path);
+      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 {
+        distance: roundedDistance,
+        duration,
+        steps
+      };
+    } catch (error) {
+      console.log(error);
+      throw error;
+    }
+  };
+  return {
+    findRoute,
+    findByIdSync
+  };
+};
+
+// src/data/getDataClient.ts
+var getDataClient = (options) => {
+  let searchClient;
+  let navigateClient;
+  const observers = /* @__PURE__ */ new Map();
+  const queryClient = options.queryClient ?? new import_query_core.QueryClient();
+  const { mode = "delivery", projectId, apiKey, baseUrl, previewToken } = options;
+  if (!projectId)
+    throw new Error(
+      "Cannot create VenueDataClient. Reason: `projectId` is missing"
+    );
+  if (mode === "delivery" && !apiKey)
+    throw new Error(
+      "Cannot create VenueDataClient. Reason: `apiKey` is missing"
+    );
   if (mode === "preview" && !previewToken)
     throw new Error(
       "Cannot create VenueDataClient. Reason: `previewToken` is missing"
@@ -690,7 +2460,7 @@ var getDataClient = (options) => {
     }
   };
   const internalFindById = async (id) => {
-    if (id === null) return null;
+    if (id === null || id === void 0) return null;
     const featureType = id.slice(0, id.lastIndexOf("-"));
     const feature2 = await queryClient.ensureQueryData({
       queryKey: ["_deliveryapi", featureType, id],
@@ -770,135 +2540,61 @@ var getDataClient = (options) => {
       id,
       params
     );
-    const feature2 = await queryClient.ensureQueryData(findQueryOptions);
-    return feature2;
-  }
-  return {
-    projectId,
-    queryClient,
-    registerObserver,
-    destroyObserver,
-    destroyObservers,
-    createFilterByTypeQueryOptions,
-    createFindByIdQueryOptions,
-    filterByType,
-    findById
-  };
-};
-
-// src/IndoorMap/IndoorMap.ts
-var import_maptalks_gl = require("maptalks-gl");
-var import_transcoders = require("@maptalks/transcoders.draco");
-var import_tween = __toESM(require("@tweenjs/tween.js"));
-var import_lodash6 = __toESM(require("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 (!isNumber(coordinates[0]) || !isNumber(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 feature2 = await queryClient.ensureQueryData(findQueryOptions);
+    return feature2;
   }
-  const geom = {
-    type: "Polygon",
-    coordinates
+  const searchFn = async (txt) => {
+    if (!searchClient) {
+      const [occupants, amenities] = await Promise.all([
+        filterByType("occupant"),
+        filterByType("amenity")
+      ]);
+      const haystack = { occupants, amenities };
+      searchClient = getSearchClient(haystack);
+    }
+    return searchClient.search(txt);
   };
-  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
+  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 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 {
+    projectId,
+    queryClient,
+    registerObserver,
+    destroyObserver,
+    destroyObservers,
+    createFilterByTypeQueryOptions,
+    createFindByIdQueryOptions,
+    _internalFindById: internalFindById,
+    filterByType,
+    findById,
+    search: searchFn,
+    navigate: navigateFn
   };
-  return feature(geom, properties, options);
-}
-function isNumber(num) {
-  return !isNaN(num) && num !== null && !Array.isArray(num);
-}
+};
 
 // src/IndoorMap/IndoorMap.ts
-var import_distance = __toESM(require("@turf/distance"));
-var import_center4 = __toESM(require("@turf/center"));
+var import_maptalks_gl = require("maptalks-gl");
+var import_transcoders = require("@maptalks/transcoders.draco");
+var import_tween = __toESM(require("@tweenjs/tween.js"));
+var import_lodash20 = __toESM(require("lodash"));
+var import_distance6 = __toESM(require("@turf/distance"));
+var import_center13 = __toESM(require("@turf/center"));
 var import_three6 = require("three");
 var import_maptalks10 = require("maptalks.three");
 
@@ -977,9 +2673,9 @@ var VENUE_EVENTS = {
 };
 
 // src/IndoorMap/utils/createElements.js
-var import_lodash4 = __toESM(require("lodash"));
+var import_lodash16 = __toESM(require("lodash"));
 var import_maptalks4 = require("maptalks");
-var import_center2 = __toESM(require("@turf/center"));
+var import_center11 = __toESM(require("@turf/center"));
 var import_buffer = __toESM(require("@turf/buffer"));
 var import_three4 = require("three");
 
@@ -987,7 +2683,7 @@ var import_three4 = require("three");
 var maptalks = __toESM(require("maptalks"));
 var import_maptalks = require("maptalks.three");
 var import_three = require("three");
-var import_lodash = __toESM(require("lodash"));
+var import_lodash13 = __toESM(require("lodash"));
 var OPTIONS = {
   altitude: 25,
   scale: 15e-5,
@@ -1020,7 +2716,7 @@ var Billboard = class extends import_maptalks.BaseObject {
     } = options;
     this.properties = { ...properties };
     this._createGroup();
-    const divider = import_lodash.default.clamp(window.innerWidth / 375 / 1.75, 1, 1.7);
+    const divider = import_lodash13.default.clamp(window.innerWidth / 375 / 1.75, 1, 1.7);
     if (showLeg) {
       const lineMaterial = new import_three.LineBasicMaterial({
         color: legColor,
@@ -1055,9 +2751,9 @@ var Billboard = class extends import_maptalks.BaseObject {
     });
     const z = layer.altitudeToVector3(altitude, altitude).x;
     const position = layer.coordinateToVector3(coordinate, z);
-    import_lodash.default.set(this.properties, "default.position", position);
-    import_lodash.default.set(this.properties, "default.altitude", altitude);
-    import_lodash.default.set(this.properties, "default.scale", scale3);
+    import_lodash13.default.set(this.properties, "default.position", position);
+    import_lodash13.default.set(this.properties, "default.altitude", altitude);
+    import_lodash13.default.set(this.properties, "default.scale", scale3);
     this.getObject3d().position.copy(position);
   }
   setLineHeight(altitude) {
@@ -1073,7 +2769,7 @@ var Billboard = class extends import_maptalks.BaseObject {
 // src/IndoorMap/object3d/SpriteMarker.ts
 var import_maptalks2 = require("maptalks.three");
 var import_three2 = require("three");
-var import_lodash2 = __toESM(require("lodash"));
+var import_lodash14 = __toESM(require("lodash"));
 var DEFAULT_SCALE = 0.05;
 var DEFAULT_ALTITUDE = 0;
 var DEFAULT_ALPHATEST = 0.3;
@@ -1104,7 +2800,7 @@ var SpriteMarker = class extends import_maptalks2.BaseObject {
     this.properties = { ...properties };
     const modifiedAltitude = altitude + 2;
     this.#default = { options: { scale: scale3, altitude: modifiedAltitude }, material };
-    this.#highlight = import_lodash2.default.merge({}, DEFAULT_OPTIONS.highlight, highlight);
+    this.#highlight = import_lodash14.default.merge({}, DEFAULT_OPTIONS.highlight, highlight);
     if (material && material instanceof import_three2.SpriteMaterial)
       material.alphaTest = alphaTest;
     const sprite = new import_three2.Sprite(material);
@@ -1113,7 +2809,7 @@ var SpriteMarker = class extends import_maptalks2.BaseObject {
     obj3d.add(sprite);
     const z = layer.altitudeToVector3(modifiedAltitude, modifiedAltitude).x;
     const position = layer.coordinateToVector3(coordinate, z);
-    import_lodash2.default.set(this.properties, "default.position", position);
+    import_lodash14.default.set(this.properties, "default.position", position);
     this.getObject3d().position.copy(position);
   }
   // Different objects need to implement their own methods
@@ -1254,15 +2950,15 @@ var NavigationPath = class extends import_maptalks3.BaseObject {
 };
 
 // src/IndoorMap/utils/geometry.ts
-var import_center = __toESM(require("@turf/center"));
-var import_lodash3 = __toESM(require("lodash"));
+var import_center10 = __toESM(require("@turf/center"));
+var import_lodash15 = __toESM(require("lodash"));
 var import_line_offset = __toESM(require("@turf/line-offset"));
 var getCenterFromGeometry = (geometry) => {
   try {
     const { type = null, coordinates = null } = geometry;
     if (!type || !coordinates) return null;
-    const centerPoint = (0, import_center.default)(geometry);
-    return import_lodash3.default.get(centerPoint, "geometry.coordinates");
+    const centerPoint = (0, import_center10.default)(geometry);
+    return import_lodash15.default.get(centerPoint, "geometry.coordinates");
   } catch (error) {
     return null;
   }
@@ -1413,7 +3109,7 @@ var createWaterFixture = (feature2, style, options = {}) => {
   const { geometry, properties } = feature2;
   const { allowOverride, inheritFillColorToLine, zIndex } = options;
   const symbolStyle = { ...style };
-  if (allowOverride) import_lodash4.default.merge(symbolStyle, properties.style);
+  if (allowOverride) import_lodash16.default.merge(symbolStyle, properties.style);
   if (inheritFillColorToLine) symbolStyle.lineColor = symbolStyle.polygonFill;
   return new GeometryType[geometry.type](geometry.coordinates, {
     properties: {
@@ -1429,7 +3125,7 @@ var createVegetationFixture = (feature2, style, options = {}) => {
   const { geometry, properties } = feature2;
   const { allowOverride, inheritFillColorToLine, zIndex } = options;
   const symbolStyle = { ...style };
-  if (allowOverride) import_lodash4.default.merge(symbolStyle, properties.style);
+  if (allowOverride) import_lodash16.default.merge(symbolStyle, properties.style);
   if (inheritFillColorToLine) symbolStyle.lineColor = symbolStyle.polygonFill;
   return new GeometryType[geometry.type](geometry.coordinates, {
     properties: {
@@ -1446,8 +3142,8 @@ var createObstructionalFixture = (feature2, style = {}, options = {}) => {
   const { model3d } = properties;
   const { allowOverride, inheritFillColorToLine, zIndex } = options;
   const symbolStyle = { ...style };
-  if (!import_lodash4.default.isEmpty(model3d)) return;
-  if (allowOverride) import_lodash4.default.merge(symbolStyle, properties.style);
+  if (!import_lodash16.default.isEmpty(model3d)) return;
+  if (allowOverride) import_lodash16.default.merge(symbolStyle, properties.style);
   if (inheritFillColorToLine) symbolStyle.lineColor = symbolStyle.polygonFill;
   if (geometry.type === "LineString") {
     const polygon2 = createPolygonFromLineString(geometry);
@@ -1517,7 +3213,7 @@ var createPrincipalOpening = (feature2, style, options = {}) => {
   const { geometry, properties } = feature2;
   const { allowOverride, zIndex } = options;
   const symbolStyle = { ...style };
-  if (allowOverride) import_lodash4.default.merge(symbolStyle, properties.style);
+  if (allowOverride) import_lodash16.default.merge(symbolStyle, properties.style);
   try {
     return new import_maptalks4.LineString(geometry.coordinates, {
       properties: {
@@ -1534,7 +3230,7 @@ var createEmergencyExitOpening = (feature2, style, options = {}) => {
   const { geometry, properties } = feature2;
   const { allowOverride, zIndex } = options;
   const symbolStyle = { ...style };
-  if (allowOverride) import_lodash4.default.merge(symbolStyle, properties.style);
+  if (allowOverride) import_lodash16.default.merge(symbolStyle, properties.style);
   try {
     return new import_maptalks4.LineString(geometry.coordinates, {
       properties: {
@@ -1551,7 +3247,7 @@ var createPedestrianOpening = (feature2, style, options = {}) => {
   const { geometry, properties, id } = feature2;
   const { allowOverride, zIndex } = options;
   const symbolStyle = { ...style };
-  if (allowOverride) import_lodash4.default.merge(symbolStyle, properties.style);
+  if (allowOverride) import_lodash16.default.merge(symbolStyle, properties.style);
   try {
     return new import_maptalks4.LineString(geometry.coordinates, {
       properties: {
@@ -1589,9 +3285,9 @@ var create3DMarker = (coordinates, options, material, threeLayer, markerProperti
 };
 var getExtrudeConfigByFeature = (baseExtrudeConfig, feature2 = {}) => {
   const { feature_type: featureType } = feature2;
-  const featureExtrudeConfig = import_lodash4.default.get(feature2, "properties.extrude");
-  const featureCategory = import_lodash4.default.get(feature2, "properties.category");
-  const baseFeatureExtrudeConfig = import_lodash4.default.get(
+  const featureExtrudeConfig = import_lodash16.default.get(feature2, "properties.extrude");
+  const featureCategory = import_lodash16.default.get(feature2, "properties.category");
+  const baseFeatureExtrudeConfig = import_lodash16.default.get(
     baseExtrudeConfig,
     `${featureType}.${featureCategory || featureType}`
   );
@@ -1649,50 +3345,50 @@ var createStyledUIMarkerElement = ({
 var styledFeatureGenerator = (mapTheme) => {
   const getElementSymbol = (key) => {
     const [featureType] = key.split(".");
-    const featureTypeTheme = import_lodash4.default.get(mapTheme, `${featureType}.geometry.symbol`);
+    const featureTypeTheme = import_lodash16.default.get(mapTheme, `${featureType}.geometry.symbol`);
     if (featureType === key) return featureTypeTheme;
-    const categoryTheme = import_lodash4.default.get(mapTheme, `${key}.geometry.symbol`);
-    return import_lodash4.default.merge({}, featureTypeTheme, categoryTheme);
+    const categoryTheme = import_lodash16.default.get(mapTheme, `${key}.geometry.symbol`);
+    return import_lodash16.default.merge({}, featureTypeTheme, categoryTheme);
   };
   const getLabelSymbol = (key) => {
     const [featureType] = key.split(".");
-    const featureTypeTheme = import_lodash4.default.get(mapTheme, `${featureType}.label`);
-    const categoryTheme = import_lodash4.default.get(mapTheme, `${key}.label`);
-    const mergedSymbol = import_lodash4.default.merge({}, featureTypeTheme, categoryTheme);
-    let symbols = import_lodash4.default.values(import_lodash4.default.map(mergedSymbol, "symbol"));
+    const featureTypeTheme = import_lodash16.default.get(mapTheme, `${featureType}.label`);
+    const categoryTheme = import_lodash16.default.get(mapTheme, `${key}.label`);
+    const mergedSymbol = import_lodash16.default.merge({}, featureTypeTheme, categoryTheme);
+    let symbols = import_lodash16.default.values(import_lodash16.default.map(mergedSymbol, "symbol"));
     const markerIndexToMove = symbols.findIndex(
       ({ elementType }) => elementType === "label.marker"
     );
     if (markerIndexToMove >= 0) {
-      const markerSymbolToMove = import_lodash4.default.pullAt(symbols, markerIndexToMove)[0];
+      const markerSymbolToMove = import_lodash16.default.pullAt(symbols, markerIndexToMove)[0];
       symbols.push(markerSymbolToMove);
     }
     return symbols;
   };
   const getUIMarkerSymbol = (key) => {
     const [featureType] = key.split(".");
-    const featureTypeTheme = import_lodash4.default.get(mapTheme, `${featureType}.ui.marker`);
-    const categoryTheme = import_lodash4.default.get(mapTheme, `${key}.ui.marker`);
-    const mergedSymbol = import_lodash4.default.merge({}, featureTypeTheme, categoryTheme);
-    const symbol = import_lodash4.default.get(mergedSymbol, "symbol");
+    const featureTypeTheme = import_lodash16.default.get(mapTheme, `${featureType}.ui.marker`);
+    const categoryTheme = import_lodash16.default.get(mapTheme, `${key}.ui.marker`);
+    const mergedSymbol = import_lodash16.default.merge({}, featureTypeTheme, categoryTheme);
+    const symbol = import_lodash16.default.get(mergedSymbol, "symbol");
     return symbol;
   };
   const getUIMarkerOptions = (key) => {
     const [featureType] = key.split(".");
-    const featureTypeTheme = import_lodash4.default.get(mapTheme, `${featureType}.ui.marker`);
-    const categoryTheme = import_lodash4.default.get(mapTheme, `${key}.ui.marker`);
-    const mergedSymbol = import_lodash4.default.merge({}, featureTypeTheme, categoryTheme);
-    const options = import_lodash4.default.get(mergedSymbol, "options");
+    const featureTypeTheme = import_lodash16.default.get(mapTheme, `${featureType}.ui.marker`);
+    const categoryTheme = import_lodash16.default.get(mapTheme, `${key}.ui.marker`);
+    const mergedSymbol = import_lodash16.default.merge({}, featureTypeTheme, categoryTheme);
+    const options = import_lodash16.default.get(mergedSymbol, "options");
     return options;
   };
   const getLabelOptions = (key) => {
     const [featureType] = key.split(".");
-    const featureTypeSymbol = import_lodash4.default.get(mapTheme, `${featureType}.label`);
-    const categorySymbol = import_lodash4.default.get(mapTheme, `${key}.label`);
-    const mergedSymbol = import_lodash4.default.merge({}, featureTypeSymbol, categorySymbol);
-    return import_lodash4.default.reduce(
+    const featureTypeSymbol = import_lodash16.default.get(mapTheme, `${featureType}.label`);
+    const categorySymbol = import_lodash16.default.get(mapTheme, `${key}.label`);
+    const mergedSymbol = import_lodash16.default.merge({}, featureTypeSymbol, categorySymbol);
+    return import_lodash16.default.reduce(
       mergedSymbol,
-      (acc, symbol) => ({ ...acc, ...import_lodash4.default.get(symbol, "options", {}) }),
+      (acc, symbol) => ({ ...acc, ...import_lodash16.default.get(symbol, "options", {}) }),
       {}
     );
   };
@@ -1707,13 +3403,13 @@ var styledFeatureGenerator = (mapTheme) => {
   };
   const generateSpriteHighlightMarkerOption = () => {
     return SPRITE_HIGHLIGHT_MARKER_FEATURE.reduce((acc, featCate) => {
-      const categoryKey = import_lodash4.default.last(featCate.split("-"));
+      const categoryKey = import_lodash16.default.last(featCate.split("-"));
       const defaultLabelSymbol = getLabelSymbol(categoryKey);
       const highlightLabelSymbol = getLabelSymbol(featCate);
       const [defaultBase, defaultIcon] = defaultLabelSymbol;
       const [highlightBase, highlightIcon] = highlightLabelSymbol;
-      const base = import_lodash4.default.merge({}, defaultBase, highlightBase);
-      const icon = import_lodash4.default.merge({}, defaultIcon, highlightIcon);
+      const base = import_lodash16.default.merge({}, defaultBase, highlightBase);
+      const icon = import_lodash16.default.merge({}, defaultIcon, highlightIcon);
       const material = createSpriteMaterialByLabelSymbol([base, icon]);
       const options = getLabelOptions(featCate);
       return { ...acc, [featCate]: { material, options } };
@@ -1723,32 +3419,32 @@ var styledFeatureGenerator = (mapTheme) => {
   const spriteHighlightMarkerOptionObj = generateSpriteHighlightMarkerOption();
   const getElementOptions = (key) => {
     const [featureType] = key.split(".");
-    const featureTypeOptions = import_lodash4.default.get(
+    const featureTypeOptions = import_lodash16.default.get(
       mapTheme,
       `${featureType}.geometry.options`
     );
-    const categoryOptions = import_lodash4.default.get(mapTheme, `${key}.geometry.options`);
-    return import_lodash4.default.merge({}, featureTypeOptions, categoryOptions);
+    const categoryOptions = import_lodash16.default.get(mapTheme, `${key}.geometry.options`);
+    return import_lodash16.default.merge({}, featureTypeOptions, categoryOptions);
   };
   const createOccupantMarker = (feature2, locatedFeature, mapConfig) => {
     const { textMarkerType, featureExtrudeConfig } = getFeatureMarkerConfig(
       feature2,
       mapConfig
     );
-    const markerHeight = import_lodash4.default.get(featureExtrudeConfig, "height", 0);
+    const markerHeight = import_lodash16.default.get(featureExtrudeConfig, "height", 0);
     const { properties, id, feature_type } = feature2;
     if (!properties.anchor) return;
-    const mainLocationId = import_lodash4.default.get(properties, "unit.id") || import_lodash4.default.get(properties, "kiosk.id");
+    const mainLocationId = import_lodash16.default.get(properties, "unit.id") || import_lodash16.default.get(properties, "kiosk.id");
     const isMainLocationFeature = mainLocationId === locatedFeature?.id;
     const { geometry: mainLocationGeometry } = properties?.anchor;
-    const geometry = isMainLocationFeature ? mainLocationGeometry : (0, import_center2.default)(locatedFeature)?.geometry;
+    const geometry = isMainLocationFeature ? mainLocationGeometry : (0, import_center11.default)(locatedFeature)?.geometry;
     const baseProperties = {
       id,
       feature_type,
       category: properties.category,
       altitude: getAltitude(properties)
     };
-    const occupantName = import_lodash4.default.isEmpty(properties.short_name) ? properties.name : properties.short_name;
+    const occupantName = import_lodash16.default.isEmpty(properties.short_name) ? properties.name : properties.short_name;
     if (locatedFeature) {
       const { feature_type: feature_type2, properties: properties2 } = locatedFeature;
       const { category } = properties2;
@@ -1762,21 +3458,21 @@ var styledFeatureGenerator = (mapTheme) => {
       }
       return requestedType;
     };
-    const logoUrl = import_lodash4.default.get(properties, "logo.url");
-    const requestedRenderType = import_lodash4.default.get(properties, "render_type", "Name");
+    const logoUrl = import_lodash16.default.get(properties, "logo.url");
+    const requestedRenderType = import_lodash16.default.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-${import_lodash4.default.toLower(renderType)}`);
-    const markerSymbol = import_lodash4.default.last(labelSymbol);
-    const coordinates = import_lodash4.default.get(geometry, "coordinates");
+    const labelSymbol = getLabelSymbol(`occupant-${import_lodash16.default.toLower(renderType)}`);
+    const markerSymbol = import_lodash16.default.last(labelSymbol);
+    const coordinates = import_lodash16.default.get(geometry, "coordinates");
     const priorityLabelSymbol = getLabelSymbol(
-      `occupant-${import_lodash4.default.toLower(renderType)}-${renderPriority}`
+      `occupant-${import_lodash16.default.toLower(renderType)}-${renderPriority}`
     );
-    const priorityMarkerSymbol = import_lodash4.default.last(priorityLabelSymbol) || {};
+    const priorityMarkerSymbol = import_lodash16.default.last(priorityLabelSymbol) || {};
     switch (renderType) {
       case "Logo":
-        import_lodash4.default.set(priorityMarkerSymbol, "markerFile", logoUrl);
+        import_lodash16.default.set(priorityMarkerSymbol, "markerFile", logoUrl);
         return new import_maptalks4.Marker(coordinates, {
           properties: {
             altitude: getAltitude(properties) + markerHeight,
@@ -1837,13 +3533,13 @@ var styledFeatureGenerator = (mapTheme) => {
           });
         }
         const uiMarkerSymbol = getUIMarkerSymbol(
-          `occupant-${import_lodash4.default.toLower(renderType)}`
+          `occupant-${import_lodash16.default.toLower(renderType)}`
         );
         const uiMarkerPrioritySymbol = getUIMarkerSymbol(
-          `occupant-${import_lodash4.default.toLower(renderType)}-${renderPriority}`
+          `occupant-${import_lodash16.default.toLower(renderType)}-${renderPriority}`
         );
         const uiMarkerPriorityOptions = getUIMarkerOptions(
-          `occupant-${import_lodash4.default.toLower(renderType)}-${renderPriority}`
+          `occupant-${import_lodash16.default.toLower(renderType)}-${renderPriority}`
         );
         const style = { ...uiMarkerSymbol, ...uiMarkerPrioritySymbol };
         return new import_maptalks4.ui.UIMarker(coordinates, {
@@ -1865,7 +3561,7 @@ var styledFeatureGenerator = (mapTheme) => {
     const { category, ordinal, style = {} } = properties;
     const elementStyle = getElementSymbol(`${feature_type}.${category}`);
     const { allowOverride } = getElementOptions(`${feature_type}.${category}`);
-    if (allowOverride) import_lodash4.default.merge(elementStyle, style);
+    if (allowOverride) import_lodash16.default.merge(elementStyle, style);
     const { polygonFill: color } = elementStyle;
     const featureProperty = {
       id,
@@ -1954,9 +3650,9 @@ var styledFeatureGenerator = (mapTheme) => {
         feature2,
         mapConfig
       );
-      const markerHeight = import_lodash4.default.get(featureExtrudeConfig, "height");
+      const markerHeight = import_lodash16.default.get(featureExtrudeConfig, "height");
       const { id, properties } = feature2;
-      const geometry = import_lodash4.default.get(feature2, "geometry") || import_lodash4.default.get(feature2, "properties.anchor.geometry");
+      const geometry = import_lodash16.default.get(feature2, "geometry") || import_lodash16.default.get(feature2, "properties.anchor.geometry");
       const coordinates = getCenterFromGeometry(geometry);
       const symbol = getElementSymbol("pin-marker");
       try {
@@ -1976,10 +3672,10 @@ var styledFeatureGenerator = (mapTheme) => {
         feature2,
         mapConfig
       );
-      const markerHeight = import_lodash4.default.get(featureExtrudeConfig, "height", 0);
+      const markerHeight = import_lodash16.default.get(featureExtrudeConfig, "height", 0);
       const { properties, id } = feature2;
       const { geometry } = properties.anchor;
-      const logoUrl = import_lodash4.default.get(properties, "logo.url");
+      const logoUrl = import_lodash16.default.get(properties, "logo.url");
       const coordinates = getCenterFromGeometry(geometry);
       const [markerBase, markerLabel] = getLabelSymbol(
         "highlighted-logo-marker"
@@ -2049,7 +3745,7 @@ var styledFeatureGenerator = (mapTheme) => {
         feature2,
         mapConfig
       );
-      const markerHeight = import_lodash4.default.get(featureExtrudeConfig, "height");
+      const markerHeight = import_lodash16.default.get(featureExtrudeConfig, "height");
       const { id, feature_type, properties } = feature2;
       if (!properties.anchor) return;
       const markerProperties = {
@@ -2059,8 +3755,8 @@ var styledFeatureGenerator = (mapTheme) => {
         altitude: getAltitude(properties) + markerHeight
       };
       const { geometry } = properties?.anchor;
-      const coordinates = import_lodash4.default.get(geometry, "coordinates");
-      const logoUrl = import_lodash4.default.get(properties, "logo.url");
+      const coordinates = import_lodash16.default.get(geometry, "coordinates");
+      const logoUrl = import_lodash16.default.get(properties, "logo.url");
       if (markerSymbol) {
         return new import_maptalks4.Marker(coordinates, {
           properties: markerProperties,
@@ -2075,8 +3771,8 @@ var styledFeatureGenerator = (mapTheme) => {
         });
       }
       const labelSymbol = getLabelSymbol("highlight-occupant-logo");
-      const priorityMarkerSymbol = import_lodash4.default.last(labelSymbol) || {};
-      import_lodash4.default.set(priorityMarkerSymbol, "markerFile", logoUrl);
+      const priorityMarkerSymbol = import_lodash16.default.last(labelSymbol) || {};
+      import_lodash16.default.set(priorityMarkerSymbol, "markerFile", logoUrl);
       return new import_maptalks4.Marker(coordinates, {
         properties: markerProperties,
         symbol: labelSymbol
@@ -2084,14 +3780,14 @@ var styledFeatureGenerator = (mapTheme) => {
     },
     createHighlight2DAmenityMarkerFrom3DMarker: (feature2, mapConfig) => {
       const { coordinates, units, kiosk } = feature2;
-      const amenityLocatedUnit = import_lodash4.default.first(units);
+      const amenityLocatedUnit = import_lodash16.default.first(units);
       const unitConfig = getExtrudeConfigByFeature(
         mapConfig,
         amenityLocatedUnit
       );
-      const unitHeight = import_lodash4.default.get(unitConfig, "height", 0);
+      const unitHeight = import_lodash16.default.get(unitConfig, "height", 0);
       const kioskConfig = getExtrudeConfigByFeature(mapConfig, kiosk);
-      const kioskHeight = import_lodash4.default.get(kioskConfig, "height", 0);
+      const kioskHeight = import_lodash16.default.get(kioskConfig, "height", 0);
       const markerHeight = unitHeight + kioskHeight;
       const symbol = getElementSymbol("highlight-amenity-marker");
       return new import_maptalks4.Marker(coordinates, {
@@ -2167,7 +3863,7 @@ var styledFeatureGenerator = (mapTheme) => {
       }
     },
     createLineStringFromGeometries: (geometries) => {
-      const mergedCoordinates = (0, import_lodash4.default)(geometries).map((geometry) => {
+      const mergedCoordinates = (0, import_lodash16.default)(geometries).map((geometry) => {
         switch (geometry.type) {
           case "Point":
             return [
@@ -2276,29 +3972,29 @@ var styledFeatureGenerator = (mapTheme) => {
     create3DAmenityMarker: (feature2, threeLayer, config) => {
       const { geometry, properties, feature_type, id } = feature2;
       const { category, units, kiosk, is_clickable } = properties;
-      const amenityLocatedUnit = import_lodash4.default.first(units);
-      const isLocatedUnitModel3dAvailable = !import_lodash4.default.isEmpty(
+      const amenityLocatedUnit = import_lodash16.default.first(units);
+      const isLocatedUnitModel3dAvailable = !import_lodash16.default.isEmpty(
         amenityLocatedUnit?.properties?.model3d
       );
-      const isLocatedKioskModel3dAvailable = !import_lodash4.default.isEmpty(
+      const isLocatedKioskModel3dAvailable = !import_lodash16.default.isEmpty(
         kiosk?.properties?.model3d
       );
       const unitConfig = getExtrudeConfigByFeature(config, amenityLocatedUnit);
-      const unitHeight = isLocatedUnitModel3dAvailable ? 0 : import_lodash4.default.get(unitConfig, "height", 0);
+      const unitHeight = isLocatedUnitModel3dAvailable ? 0 : import_lodash16.default.get(unitConfig, "height", 0);
       const kioskConfig = getExtrudeConfigByFeature(config, kiosk);
-      const kioskHeight = isLocatedKioskModel3dAvailable ? 0 : import_lodash4.default.get(kioskConfig, "height", 0);
-      const coordinates = import_lodash4.default.get(geometry, "coordinates");
+      const kioskHeight = isLocatedKioskModel3dAvailable ? 0 : import_lodash16.default.get(kioskConfig, "height", 0);
+      const coordinates = import_lodash16.default.get(geometry, "coordinates");
       const markerProperties = {
         ...properties,
         coordinates,
         id,
         feature_type
       };
-      const material = import_lodash4.default.get(
+      const material = import_lodash16.default.get(
         spriteMarkerMaterialObj,
         `${feature_type}.${category}`
       );
-      const highlightOptions = import_lodash4.default.get(
+      const highlightOptions = import_lodash16.default.get(
         spriteHighlightMarkerOptionObj,
         `${PREFIX_HIGHLIGHTED_SYMBOL_KEY}-${feature_type}.${category}`
       );
@@ -2321,24 +4017,24 @@ var styledFeatureGenerator = (mapTheme) => {
       const { category, unit, kiosk } = properties;
       const amenityLocation = kiosk || unit;
       const locationConfig = getExtrudeConfigByFeature(config, amenityLocation);
-      const coordinates = import_lodash4.default.get(geometry, "coordinates");
+      const coordinates = import_lodash16.default.get(geometry, "coordinates");
       const markerProperties = {
         ...properties,
         coordinates,
         id,
         feature_type
       };
-      const material = import_lodash4.default.get(
+      const material = import_lodash16.default.get(
         spriteMarkerMaterialObj,
         `${feature_type}.${category}`
       );
-      const highlightOptions = import_lodash4.default.get(
+      const highlightOptions = import_lodash16.default.get(
         spriteHighlightMarkerOptionObj,
         `${PREFIX_HIGHLIGHTED_SYMBOL_KEY}-${feature_type}.${category}`
       );
       const options = {
         scale: 0.05,
-        altitude: import_lodash4.default.get(locationConfig, "height", 0),
+        altitude: import_lodash16.default.get(locationConfig, "height", 0),
         highlight: highlightOptions
       };
       return create3DMarker(
@@ -2354,24 +4050,24 @@ var styledFeatureGenerator = (mapTheme) => {
       const { category, unit, kiosk } = properties;
       const amenityLocation = kiosk || unit;
       const locationConfig = getExtrudeConfigByFeature(config, amenityLocation);
-      const coordinates = import_lodash4.default.get(geometry, "coordinates");
+      const coordinates = import_lodash16.default.get(geometry, "coordinates");
       const markerProperties = {
         ...properties,
         coordinates,
         id,
         feature_type
       };
-      const material = import_lodash4.default.get(
+      const material = import_lodash16.default.get(
         spriteMarkerMaterialObj,
         `${feature_type}.${category}`
       );
-      const highlightOptions = import_lodash4.default.get(
+      const highlightOptions = import_lodash16.default.get(
         spriteHighlightMarkerOptionObj,
         `${PREFIX_HIGHLIGHTED_SYMBOL_KEY}-${feature_type}.${category}`
       );
       const options = {
         scale: 0.05,
-        altitude: import_lodash4.default.get(locationConfig, "height", 0),
+        altitude: import_lodash16.default.get(locationConfig, "height", 0),
         highlight: highlightOptions
       };
       return create3DMarker(
@@ -2383,13 +4079,13 @@ var styledFeatureGenerator = (mapTheme) => {
       );
     },
     createExtrudedUnit: (unit, threeLayer, options) => {
-      const extrudeHeight = import_lodash4.default.get(options, "height");
+      const extrudeHeight = import_lodash16.default.get(options, "height");
       if (!extrudeHeight) return;
       const unitProperty = getFeatureProperties(unit);
       const options3d = {
         // TODO: Move to extrude config later
         offset: -0.1,
-        altitude: import_lodash4.default.get(options, "altitude", 0)
+        altitude: import_lodash16.default.get(options, "altitude", 0)
       };
       const color = unitProperty.defaultColor;
       if (color === "transparent") return;
@@ -2432,14 +4128,14 @@ var EXCEPT_AMENITY_LOCATION_CATEGORIES = [
   "unspecified"
 ];
 var getLocationByAmenity = (feature2) => {
-  const unit = import_lodash4.default.get(feature2, "properties.units[0]", null);
-  const unitCategory = import_lodash4.default.get(unit, "properties.category");
+  const unit = import_lodash16.default.get(feature2, "properties.units[0]", null);
+  const unitCategory = import_lodash16.default.get(unit, "properties.category");
   if (!unit) return feature2.id;
   return EXCEPT_AMENITY_LOCATION_CATEGORIES.includes(unitCategory) ? feature2 : unit;
 };
 var getLocationByOccupant = (feature2) => {
-  const kiosk = import_lodash4.default.get(feature2, "properties.kiosk", null);
-  const unit = import_lodash4.default.get(feature2, "properties.anchor.properties.unit", null);
+  const kiosk = import_lodash16.default.get(feature2, "properties.kiosk", null);
+  const unit = import_lodash16.default.get(feature2, "properties.anchor.properties.unit", null);
   return kiosk || unit;
 };
 var getLocationIdByFeature = (feature2) => {
@@ -2467,10 +4163,10 @@ var getFeatureByLocationId = (id, features = []) => {
   });
 };
 var isClickableFeature = (feature2) => {
-  const isClickable = import_lodash4.default.get(feature2, "properties.is_clickable");
+  const isClickable = import_lodash16.default.get(feature2, "properties.is_clickable");
   switch (feature2?.feature_type) {
     case "amenity":
-      return import_lodash4.default.isNull(isClickable) ? true : isClickable;
+      return import_lodash16.default.isNull(isClickable) ? true : isClickable;
     case "occupant":
       return true;
     default:
@@ -2488,24 +4184,24 @@ var getLocationByFeature = (feature2) => {
   }
 };
 var getRelatedLocationsByOccupant = (feature2) => {
-  const kiosks = import_lodash4.default.get(feature2, "properties.kiosks", []);
-  const units = import_lodash4.default.get(feature2, "properties.units", []);
+  const kiosks = import_lodash16.default.get(feature2, "properties.kiosks", []);
+  const units = import_lodash16.default.get(feature2, "properties.units", []);
   return [...kiosks, ...units];
 };
 var getRelatedLocationsByAmenity = (feature2) => {
-  const units = import_lodash4.default.get(feature2, "properties.units", []);
+  const units = import_lodash16.default.get(feature2, "properties.units", []);
   if (units.length === 0) return [feature2];
   return units.filter((unit) => {
-    const unitCategory = import_lodash4.default.get(unit, "properties.category");
+    const unitCategory = import_lodash16.default.get(unit, "properties.category");
     return !EXCEPT_AMENITY_LOCATION_CATEGORIES.includes(unitCategory);
   });
 };
 var getRelatedLocationIdsByFeature = (feature2) => {
   switch (feature2?.feature_type) {
     case "amenity":
-      return getRelatedLocationsByAmenity(feature2).map((v2) => v2?.id);
+      return getRelatedLocationsByAmenity(feature2).map((v) => v?.id);
     case "occupant":
-      return getRelatedLocationsByOccupant(feature2).map((v2) => v2?.id);
+      return getRelatedLocationsByOccupant(feature2).map((v) => v?.id);
     default:
       return [];
   }
@@ -2522,8 +4218,8 @@ var getRelatedLocationsByFeature = (feature2) => {
 };
 var getOrdinalByLocationId = (locationId, feature2) => {
   if (!feature2) return null;
-  const mainUnit = import_lodash4.default.get(feature2, "properties.unit");
-  const mainKiosk = import_lodash4.default.get(feature2, "properties.kiosk");
+  const mainUnit = import_lodash16.default.get(feature2, "properties.unit");
+  const mainKiosk = import_lodash16.default.get(feature2, "properties.kiosk");
   const relatedLocations = getRelatedLocationsByFeature(feature2);
   const allLocations = [mainUnit, mainKiosk, ...relatedLocations].filter(
     Boolean
@@ -2531,7 +4227,7 @@ var getOrdinalByLocationId = (locationId, feature2) => {
   const targetLocation = allLocations.find(
     (location) => location.id === locationId
   );
-  return targetLocation ? import_lodash4.default.get(targetLocation, "properties.level.properties.ordinal") || import_lodash4.default.get(targetLocation, "properties.ordinal") : null;
+  return targetLocation ? import_lodash16.default.get(targetLocation, "properties.level.properties.ordinal") || import_lodash16.default.get(targetLocation, "properties.ordinal") : null;
 };
 
 // src/IndoorMap/utils/math.ts
@@ -2544,140 +4240,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
 var import_maptalks5 = require("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
-var import_transform_scale = __toESM(require("@turf/transform-scale"));
-var import_bbox_polygon = __toESM(require("@turf/bbox-polygon"));
+var import_transform_scale2 = __toESM(require("@turf/transform-scale"));
+var import_bbox_polygon2 = __toESM(require("@turf/bbox-polygon"));
 var CameraManager = class {
   map;
   constructor(map, options) {
@@ -2703,7 +4275,7 @@ var CameraManager = class {
   }
   getFeatureExtent = (feature2, scaleFactor = 1) => {
     const [minX, minY, maxX, maxY] = index_default(
-      (0, import_transform_scale.default)((0, import_bbox_polygon.default)(index_default(feature2)), scaleFactor)
+      (0, import_transform_scale2.default)((0, import_bbox_polygon2.default)(index_default(feature2)), scaleFactor)
     );
     return new import_maptalks5.Extent(minX, minY, maxX, maxY);
   };
@@ -2740,8 +4312,8 @@ var CameraManager = class {
 };
 
 // src/IndoorMap/renderer/RendererManager.ts
-var import_lodash_es4 = require("lodash-es");
-var import_center3 = require("@turf/center");
+var import_lodash19 = require("lodash");
+var import_center12 = require("@turf/center");
 var THREE4 = __toESM(require("three"));
 
 // src/IndoorMap/renderer/3d/Element3DRenderer.ts
@@ -2749,10 +4321,10 @@ var maptalks4 = __toESM(require("maptalks-gl"));
 var THREE = __toESM(require("three"));
 var import_maptalks7 = require("maptalks.three");
 var import_buffer2 = __toESM(require("@turf/buffer"));
-var import_clean_coords = require("@turf/clean-coords");
+var import_clean_coords2 = require("@turf/clean-coords");
 var import_polygon_to_line = require("@turf/polygon-to-line");
 var import_nearest_point_on_line = require("@turf/nearest-point-on-line");
-var import_length = require("@turf/length");
+var import_length2 = require("@turf/length");
 var import_along = require("@turf/along");
 var import_point_to_line_distance = require("@turf/point-to-line-distance");
 
@@ -2761,7 +4333,7 @@ var maptalks3 = __toESM(require("maptalks-gl"));
 var import_maptalks6 = require("maptalks.three");
 var import_three5 = require("three");
 var import_d3plus_shape = require("d3plus-shape");
-var import_lodash_es3 = require("lodash-es");
+var import_lodash17 = require("lodash");
 var OPTIONS3 = {
   // Allowing click through and prevent interaction
   interactive: false,
@@ -2779,9 +4351,9 @@ var defaultFlatLabelOptions = {
   textBaseline: "middle",
   fillStyle: "#000"
 };
-var defaultRectAngleToCalc = (0, import_lodash_es3.range)(-90, 92, 2);
+var defaultRectAngleToCalc = (0, import_lodash17.range)(-90, 92, 2);
 var getMaterial = (text, flatLabelOptions) => {
-  const options = (0, import_lodash_es3.merge)({}, defaultFlatLabelOptions, flatLabelOptions);
+  const options = (0, import_lodash17.merge)({}, defaultFlatLabelOptions, flatLabelOptions);
   const {
     fontSize: initialFontSize,
     fontFamily,
@@ -2834,23 +4406,23 @@ var getMaterial = (text, flatLabelOptions) => {
     const maxWidth = SIZE - 2 * margin;
     texts = wrapText(ctx, text, maxWidth);
   }
-  let textWidth = (0, import_lodash_es3.max)(texts.map((text2) => ctx.measureText(text2).width));
+  let textWidth = (0, import_lodash17.max)(texts.map((text2) => ctx.measureText(text2).width));
   let scale3 = 1;
   while (scale3 > 0 && textWidth + 2 * margin > SIZE) {
     scale3 -= scaleStep;
     ctx.font = `${fontWeight} ${scale3 * fontSize}px "${fontFamily}", Arial`;
-    textWidth = (0, import_lodash_es3.max)(texts.map((text2) => ctx.measureText(text2).width));
+    textWidth = (0, import_lodash17.max)(texts.map((text2) => ctx.measureText(text2).width));
   }
-  const center2 = { x: 0.5 * SIZE, y: 0.5 * SIZE };
+  const center8 = { x: 0.5 * SIZE, y: 0.5 * SIZE };
   if (scale3 > scaleMin) {
     const totalHeight = texts.length * (fontSize * scale3 * lineHeight);
-    const startY = center2.y - totalHeight / 2 + fontSize * scale3 * lineHeight * 0.5;
+    const startY = center8.y - totalHeight / 2 + fontSize * scale3 * lineHeight * 0.5;
     texts.forEach((text2, index) => {
       const yOffset = startY + index * (fontSize * scale3 * lineHeight);
       if (strokeStyle && lineWidth) {
-        ctx.strokeText(text2, center2.x, yOffset);
+        ctx.strokeText(text2, center8.x, yOffset);
       }
-      ctx.fillText(text2, center2.x, yOffset);
+      ctx.fillText(text2, center8.x, yOffset);
     });
   }
   const texture = new import_three5.Texture(canvas);
@@ -2907,7 +4479,7 @@ var GroundLabel = class extends import_maptalks6.BaseObject {
       strokeStyle,
       lineWidth
     });
-    const rectAngles = (0, import_lodash_es3.isArray)(angle) ? angle : [angle];
+    const rectAngles = (0, import_lodash17.isArray)(angle) ? angle : [angle];
     material.needsUpdate = true;
     const rect = (0, import_d3plus_shape.largestRect)(bound, {
       cache: true,
@@ -2980,32 +4552,32 @@ var GroundLabel = class extends import_maptalks6.BaseObject {
     return { x: this.#offsetX, y: this.#offsetY };
   }
   set offsetX(value) {
-    if ((0, import_lodash_es3.isNumber)(value)) {
+    if ((0, import_lodash17.isNumber)(value)) {
       this.#offsetX = value;
       this.#updatePosition();
     }
   }
   set offsetY(value) {
-    if ((0, import_lodash_es3.isNumber)(value)) {
+    if ((0, import_lodash17.isNumber)(value)) {
       this.#offsetY = value;
       this.#updatePosition();
     }
   }
   set angle(newAngle) {
-    if ((0, import_lodash_es3.isNumber)(newAngle)) {
+    if ((0, import_lodash17.isNumber)(newAngle)) {
       this.#angle = newAngle;
       this.getObject3d().rotation.z = Math.PI / 180 * this.#angle;
     }
   }
   setOffset(offsetX, offsetY) {
-    if ((0, import_lodash_es3.isNumber)(offsetX) && (0, import_lodash_es3.isNumber)(offsetY)) {
+    if ((0, import_lodash17.isNumber)(offsetX) && (0, import_lodash17.isNumber)(offsetY)) {
       this.#offsetX = offsetX;
       this.#offsetY = offsetY;
       this.#updatePosition();
     }
   }
   addOffset(deltaX, deltaY) {
-    if ((0, import_lodash_es3.isNumber)(deltaX) && (0, import_lodash_es3.isNumber)(deltaY)) {
+    if ((0, import_lodash17.isNumber)(deltaX) && (0, import_lodash17.isNumber)(deltaY)) {
       this.#offsetX += deltaX;
       this.#offsetY += deltaY;
       this.#updatePosition();
@@ -3107,6 +4679,7 @@ var Element3DRenderer = class extends EventTarget {
   threeLayer;
   scene;
   lineMaterial;
+  navigationLineMaterial;
   materialByColorMap;
   // Renderer is Ready
   isReady = false;
@@ -3118,6 +4691,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() {
@@ -3233,7 +4807,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 = (0, import_clean_coords.cleanCoords)((0, import_polygon_to_line.polygonToLine)(polygon([ring])));
+        const roomWall = (0, import_clean_coords2.cleanCoords)((0, import_polygon_to_line.polygonToLine)(polygon([ring])));
         if (openings.length === 0) {
           const color = "#ababab";
           const material = this.getOrCreateMaterialByColor(color);
@@ -3261,7 +4835,7 @@ var Element3DRenderer = class extends EventTarget {
         try {
           const split = (0, import_line_split.default)(roomWall, multiPoint(openingPoints));
           const wallsOnly = split.features.filter((seg) => {
-            const mid = (0, import_along.along)(seg, (0, import_length.length)(seg, { units: "meters" }) / 2, { units: "meters" });
+            const mid = (0, import_along.along)(seg, (0, import_length2.length)(seg, { units: "meters" }) / 2, { units: "meters" });
             for (const opening of openings) {
               const dist = (0, import_point_to_line_distance.pointToLineDistance)(mid, opening, { units: "meters" });
               if (dist < 0.05) return false;
@@ -3320,10 +4894,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);
@@ -3382,11 +4956,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));
   }
 };
@@ -3526,6 +5112,8 @@ var Element2DRenderer = class extends EventTarget {
       }
     };
   }
+  drawNavigation(route) {
+  }
 };
 
 // src/IndoorMap/renderer/2d/Marker2DRenderer.ts
@@ -3571,7 +5159,7 @@ var THREE3 = __toESM(require("three"));
 var import_maptalks8 = require("maptalks");
 var THREE2 = __toESM(require("three"));
 var import_maptalks9 = require("maptalks.three");
-var import_lodash5 = require("lodash");
+var import_lodash18 = require("lodash");
 
 // src/IndoorMap/renderer/utils/interpolateStops.ts
 var interpolateStops = ({ stops }, zoom) => {
@@ -3581,8 +5169,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);
     }
   }
 };
@@ -3666,7 +5254,7 @@ var TextSpriteMarker = class extends import_maptalks9.BaseObject {
     const paragraphs = String(text).split("\n");
     const wrappedLines = [];
     paragraphs.forEach((paragraph) => {
-      if ((0, import_lodash5.isNil)(maxWidth) || isNaN(maxWidth)) {
+      if ((0, import_lodash18.isNil)(maxWidth) || isNaN(maxWidth)) {
         wrappedLines.push(paragraph);
         return;
       }
@@ -3727,7 +5315,7 @@ var TextSpriteMarker = class extends import_maptalks9.BaseObject {
     const altitude = (options.altitude || 0) + this.#altitudeOffset;
     const z = layer.altitudeToVector3(altitude, altitude).x;
     const position = layer.coordinateToVector3(this._coordinate, z);
-    (0, import_lodash5.set)(this.properties, "default.position", position);
+    (0, import_lodash18.set)(this.properties, "default.position", position);
     this.getObject3d().position.copy(position);
   }
   _animation() {
@@ -3901,478 +5489,11 @@ var angleBetweenLineStrings = (line1, line2) => {
   return Math.atan2(dy, dx);
 };
 
-// ../../node_modules/point-in-polygon-hao/node_modules/robust-predicates/esm/util.js
-var epsilon = 11102230246251565e-32;
-var splitter = 134217729;
-var resulterrbound = (3 + 8 * epsilon) * epsilon;
-function sum(elen, e, flen, f, h) {
-  let Q, Qnew, hh, bvirt;
-  let enow = e[0];
-  let fnow = f[0];
-  let eindex = 0;
-  let findex = 0;
-  if (fnow > enow === fnow > -enow) {
-    Q = enow;
-    enow = e[++eindex];
-  } else {
-    Q = fnow;
-    fnow = f[++findex];
-  }
-  let hindex = 0;
-  if (eindex < elen && findex < flen) {
-    if (fnow > enow === fnow > -enow) {
-      Qnew = enow + Q;
-      hh = Q - (Qnew - enow);
-      enow = e[++eindex];
-    } else {
-      Qnew = fnow + Q;
-      hh = Q - (Qnew - fnow);
-      fnow = f[++findex];
-    }
-    Q = Qnew;
-    if (hh !== 0) {
-      h[hindex++] = hh;
-    }
-    while (eindex < elen && findex < flen) {
-      if (fnow > enow === fnow > -enow) {
-        Qnew = Q + enow;
-        bvirt = Qnew - Q;
-        hh = Q - (Qnew - bvirt) + (enow - bvirt);
-        enow = e[++eindex];
-      } else {
-        Qnew = Q + fnow;
-        bvirt = Qnew - Q;
-        hh = Q - (Qnew - bvirt) + (fnow - bvirt);
-        fnow = f[++findex];
-      }
-      Q = Qnew;
-      if (hh !== 0) {
-        h[hindex++] = hh;
-      }
-    }
-  }
-  while (eindex < elen) {
-    Qnew = Q + enow;
-    bvirt = Qnew - Q;
-    hh = Q - (Qnew - bvirt) + (enow - bvirt);
-    enow = e[++eindex];
-    Q = Qnew;
-    if (hh !== 0) {
-      h[hindex++] = hh;
-    }
-  }
-  while (findex < flen) {
-    Qnew = Q + fnow;
-    bvirt = Qnew - Q;
-    hh = Q - (Qnew - bvirt) + (fnow - bvirt);
-    fnow = f[++findex];
-    Q = Qnew;
-    if (hh !== 0) {
-      h[hindex++] = hh;
-    }
-  }
-  if (Q !== 0 || hindex === 0) {
-    h[hindex++] = Q;
-  }
-  return hindex;
-}
-function estimate(elen, e) {
-  let Q = e[0];
-  for (let i = 1; i < elen; i++) Q += e[i];
-  return Q;
-}
-function vec(n) {
-  return new Float64Array(n);
-}
-
-// ../../node_modules/point-in-polygon-hao/node_modules/robust-predicates/esm/orient2d.js
-var ccwerrboundA = (3 + 16 * epsilon) * epsilon;
-var ccwerrboundB = (2 + 12 * epsilon) * epsilon;
-var ccwerrboundC = (9 + 64 * epsilon) * epsilon * epsilon;
-var B = vec(4);
-var C1 = vec(8);
-var C2 = vec(12);
-var D = vec(16);
-var u = vec(4);
-function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
-  let acxtail, acytail, bcxtail, bcytail;
-  let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u32;
-  const acx = ax - cx;
-  const bcx = bx - cx;
-  const acy = ay - cy;
-  const bcy = by - cy;
-  s1 = acx * bcy;
-  c = splitter * acx;
-  ahi = c - (c - acx);
-  alo = acx - ahi;
-  c = splitter * bcy;
-  bhi = c - (c - bcy);
-  blo = bcy - bhi;
-  s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
-  t1 = acy * bcx;
-  c = splitter * acy;
-  ahi = c - (c - acy);
-  alo = acy - ahi;
-  c = splitter * bcx;
-  bhi = c - (c - bcx);
-  blo = bcx - bhi;
-  t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
-  _i = s0 - t0;
-  bvirt = s0 - _i;
-  B[0] = s0 - (_i + bvirt) + (bvirt - t0);
-  _j = s1 + _i;
-  bvirt = _j - s1;
-  _0 = s1 - (_j - bvirt) + (_i - bvirt);
-  _i = _0 - t1;
-  bvirt = _0 - _i;
-  B[1] = _0 - (_i + bvirt) + (bvirt - t1);
-  u32 = _j + _i;
-  bvirt = u32 - _j;
-  B[2] = _j - (u32 - bvirt) + (_i - bvirt);
-  B[3] = u32;
-  let det = estimate(4, B);
-  let errbound = ccwerrboundB * detsum;
-  if (det >= errbound || -det >= errbound) {
-    return det;
-  }
-  bvirt = ax - acx;
-  acxtail = ax - (acx + bvirt) + (bvirt - cx);
-  bvirt = bx - bcx;
-  bcxtail = bx - (bcx + bvirt) + (bvirt - cx);
-  bvirt = ay - acy;
-  acytail = ay - (acy + bvirt) + (bvirt - cy);
-  bvirt = by - bcy;
-  bcytail = by - (bcy + bvirt) + (bvirt - cy);
-  if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) {
-    return det;
-  }
-  errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);
-  det += acx * bcytail + bcy * acxtail - (acy * bcxtail + bcx * acytail);
-  if (det >= errbound || -det >= errbound) return det;
-  s1 = acxtail * bcy;
-  c = splitter * acxtail;
-  ahi = c - (c - acxtail);
-  alo = acxtail - ahi;
-  c = splitter * bcy;
-  bhi = c - (c - bcy);
-  blo = bcy - bhi;
-  s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
-  t1 = acytail * bcx;
-  c = splitter * acytail;
-  ahi = c - (c - acytail);
-  alo = acytail - ahi;
-  c = splitter * bcx;
-  bhi = c - (c - bcx);
-  blo = bcx - bhi;
-  t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
-  _i = s0 - t0;
-  bvirt = s0 - _i;
-  u[0] = s0 - (_i + bvirt) + (bvirt - t0);
-  _j = s1 + _i;
-  bvirt = _j - s1;
-  _0 = s1 - (_j - bvirt) + (_i - bvirt);
-  _i = _0 - t1;
-  bvirt = _0 - _i;
-  u[1] = _0 - (_i + bvirt) + (bvirt - t1);
-  u32 = _j + _i;
-  bvirt = u32 - _j;
-  u[2] = _j - (u32 - bvirt) + (_i - bvirt);
-  u[3] = u32;
-  const C1len = sum(4, B, 4, u, C1);
-  s1 = acx * bcytail;
-  c = splitter * acx;
-  ahi = c - (c - acx);
-  alo = acx - ahi;
-  c = splitter * bcytail;
-  bhi = c - (c - bcytail);
-  blo = bcytail - bhi;
-  s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
-  t1 = acy * bcxtail;
-  c = splitter * acy;
-  ahi = c - (c - acy);
-  alo = acy - ahi;
-  c = splitter * bcxtail;
-  bhi = c - (c - bcxtail);
-  blo = bcxtail - bhi;
-  t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
-  _i = s0 - t0;
-  bvirt = s0 - _i;
-  u[0] = s0 - (_i + bvirt) + (bvirt - t0);
-  _j = s1 + _i;
-  bvirt = _j - s1;
-  _0 = s1 - (_j - bvirt) + (_i - bvirt);
-  _i = _0 - t1;
-  bvirt = _0 - _i;
-  u[1] = _0 - (_i + bvirt) + (bvirt - t1);
-  u32 = _j + _i;
-  bvirt = u32 - _j;
-  u[2] = _j - (u32 - bvirt) + (_i - bvirt);
-  u[3] = u32;
-  const C2len = sum(C1len, C1, 4, u, C2);
-  s1 = acxtail * bcytail;
-  c = splitter * acxtail;
-  ahi = c - (c - acxtail);
-  alo = acxtail - ahi;
-  c = splitter * bcytail;
-  bhi = c - (c - bcytail);
-  blo = bcytail - bhi;
-  s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
-  t1 = acytail * bcxtail;
-  c = splitter * acytail;
-  ahi = c - (c - acytail);
-  alo = acytail - ahi;
-  c = splitter * bcxtail;
-  bhi = c - (c - bcxtail);
-  blo = bcxtail - bhi;
-  t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
-  _i = s0 - t0;
-  bvirt = s0 - _i;
-  u[0] = s0 - (_i + bvirt) + (bvirt - t0);
-  _j = s1 + _i;
-  bvirt = _j - s1;
-  _0 = s1 - (_j - bvirt) + (_i - bvirt);
-  _i = _0 - t1;
-  bvirt = _0 - _i;
-  u[1] = _0 - (_i + bvirt) + (bvirt - t1);
-  u32 = _j + _i;
-  bvirt = u32 - _j;
-  u[2] = _j - (u32 - bvirt) + (_i - bvirt);
-  u[3] = u32;
-  const Dlen = sum(C2len, C2, 4, u, D);
-  return D[Dlen - 1];
-}
-function orient2d(ax, ay, bx, by, cx, cy) {
-  const detleft = (ay - cy) * (bx - cx);
-  const detright = (ax - cx) * (by - cy);
-  const det = detleft - detright;
-  const detsum = Math.abs(detleft + detright);
-  if (Math.abs(det) >= ccwerrboundA * detsum) return det;
-  return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum);
-}
-
-// ../../node_modules/point-in-polygon-hao/node_modules/robust-predicates/esm/orient3d.js
-var o3derrboundA = (7 + 56 * epsilon) * epsilon;
-var o3derrboundB = (3 + 28 * epsilon) * epsilon;
-var o3derrboundC = (26 + 288 * epsilon) * epsilon * epsilon;
-var bc = vec(4);
-var ca = vec(4);
-var ab = vec(4);
-var at_b = vec(4);
-var at_c = vec(4);
-var bt_c = vec(4);
-var bt_a = vec(4);
-var ct_a = vec(4);
-var ct_b = vec(4);
-var bct = vec(8);
-var cat = vec(8);
-var abt = vec(8);
-var u2 = vec(4);
-var _8 = vec(8);
-var _8b = vec(8);
-var _16 = vec(8);
-var _12 = vec(12);
-var fin = vec(192);
-var fin2 = vec(192);
-
-// ../../node_modules/point-in-polygon-hao/node_modules/robust-predicates/esm/incircle.js
-var iccerrboundA = (10 + 96 * epsilon) * epsilon;
-var iccerrboundB = (4 + 48 * epsilon) * epsilon;
-var iccerrboundC = (44 + 576 * epsilon) * epsilon * epsilon;
-var bc2 = vec(4);
-var ca2 = vec(4);
-var ab2 = vec(4);
-var aa = vec(4);
-var bb = vec(4);
-var cc = vec(4);
-var u3 = vec(4);
-var v = vec(4);
-var axtbc = vec(8);
-var aytbc = vec(8);
-var bxtca = vec(8);
-var bytca = vec(8);
-var cxtab = vec(8);
-var cytab = vec(8);
-var abt2 = vec(8);
-var bct2 = vec(8);
-var cat2 = vec(8);
-var abtt = vec(4);
-var bctt = vec(4);
-var catt = vec(4);
-var _82 = vec(8);
-var _162 = vec(16);
-var _16b = vec(16);
-var _16c = vec(16);
-var _32 = vec(32);
-var _32b = vec(32);
-var _48 = vec(48);
-var _64 = vec(64);
-var fin3 = vec(1152);
-var fin22 = vec(1152);
-
-// ../../node_modules/point-in-polygon-hao/node_modules/robust-predicates/esm/insphere.js
-var isperrboundA = (16 + 224 * epsilon) * epsilon;
-var isperrboundB = (5 + 72 * epsilon) * epsilon;
-var isperrboundC = (71 + 1408 * epsilon) * epsilon * epsilon;
-var ab3 = vec(4);
-var bc3 = vec(4);
-var cd = vec(4);
-var de = vec(4);
-var ea = vec(4);
-var ac = vec(4);
-var bd = vec(4);
-var ce = vec(4);
-var da = vec(4);
-var eb = vec(4);
-var abc = vec(24);
-var bcd = vec(24);
-var cde = vec(24);
-var dea = vec(24);
-var eab = vec(24);
-var abd = vec(24);
-var bce = vec(24);
-var cda = vec(24);
-var deb = vec(24);
-var eac = vec(24);
-var adet = vec(1152);
-var bdet = vec(1152);
-var cdet = vec(1152);
-var ddet = vec(1152);
-var edet = vec(1152);
-var abdet = vec(2304);
-var cddet = vec(2304);
-var cdedet = vec(3456);
-var deter = vec(5760);
-var _83 = vec(8);
-var _8b2 = vec(8);
-var _8c = vec(8);
-var _163 = vec(16);
-var _24 = vec(24);
-var _482 = vec(48);
-var _48b = vec(48);
-var _96 = vec(96);
-var _192 = vec(192);
-var _384x = vec(384);
-var _384y = vec(384);
-var _384z = vec(384);
-var _768 = vec(768);
-var xdet = vec(96);
-var ydet = vec(96);
-var zdet = vec(96);
-var fin4 = vec(1152);
-
-// ../../node_modules/point-in-polygon-hao/dist/esm/index.js
-function pointInPolygon(p, polygon2) {
-  var i;
-  var ii;
-  var k = 0;
-  var f;
-  var u1;
-  var v1;
-  var u22;
-  var v2;
-  var currentP;
-  var nextP;
-  var x = p[0];
-  var y = p[1];
-  var numContours = polygon2.length;
-  for (i = 0; i < numContours; i++) {
-    ii = 0;
-    var contour = polygon2[i];
-    var contourLen = contour.length - 1;
-    currentP = contour[0];
-    if (currentP[0] !== contour[contourLen][0] && currentP[1] !== contour[contourLen][1]) {
-      throw new Error("First and last coordinates in a ring must be the same");
-    }
-    u1 = currentP[0] - x;
-    v1 = currentP[1] - y;
-    for (ii; ii < contourLen; ii++) {
-      nextP = contour[ii + 1];
-      u22 = nextP[0] - x;
-      v2 = nextP[1] - y;
-      if (v1 === 0 && v2 === 0) {
-        if (u22 <= 0 && u1 >= 0 || u1 <= 0 && u22 >= 0) {
-          return 0;
-        }
-      } else if (v2 >= 0 && v1 <= 0 || v2 <= 0 && v1 >= 0) {
-        f = orient2d(u1, u22, v1, v2, 0, 0);
-        if (f === 0) {
-          return 0;
-        }
-        if (f > 0 && v2 > 0 && v1 <= 0 || f < 0 && v2 <= 0 && v1 > 0) {
-          k++;
-        }
-      }
-      currentP = nextP;
-      v1 = v2;
-      u1 = u22;
-    }
-  }
-  if (k % 2 === 0) {
-    return false;
-  }
-  return true;
-}
-
-// ../../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];
-    }
-  }
-  if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
-    return [...coord];
-  }
-  throw new Error("coord must be GeoJSON Point or an Array of numbers");
-}
-function getGeom(geojson) {
-  if (geojson.type === "Feature") {
-    return geojson.geometry;
-  }
-  return geojson;
-}
-
-// ../../node_modules/@turf/boolean-point-in-polygon/dist/esm/index.js
-function booleanPointInPolygon(point2, polygon2, options = {}) {
-  if (!point2) {
-    throw new Error("point is required");
-  }
-  if (!polygon2) {
-    throw new Error("polygon is required");
-  }
-  const pt = getCoord(point2);
-  const geom = getGeom(polygon2);
-  const type = geom.type;
-  const bbox2 = polygon2.bbox;
-  let polys = geom.coordinates;
-  if (bbox2 && inBBox(pt, bbox2) === false) {
-    return false;
-  }
-  if (type === "Polygon") {
-    polys = [polys];
-  }
-  let result = false;
-  for (var i = 0; i < polys.length; ++i) {
-    const polyResult = pointInPolygon(pt, polys[i]);
-    if (polyResult === 0) return options.ignoreBoundary ? false : true;
-    else if (polyResult) result = true;
-  }
-  return result;
-}
-function inBBox(pt, bbox2) {
-  return bbox2[0] <= pt[0] && bbox2[1] <= pt[1] && bbox2[2] >= pt[0] && bbox2[3] >= pt[1];
-}
-
 // src/IndoorMap/renderer/utils/findUnitOnPoint.ts
+var import_boolean_point_in_polygon5 = require("@turf/boolean-point-in-polygon");
 var findUnitOnPoint = (units, point2) => {
   try {
-    return units.find((unit) => booleanPointInPolygon(point2, polygon(unit.geometry.coordinates)));
+    return units.find((unit) => (0, import_boolean_point_in_polygon5.booleanPointInPolygon)(point2, polygon(unit.geometry.coordinates)));
   } catch (err) {
     return null;
   }
@@ -4421,9 +5542,9 @@ var RendererManager = class extends EventTarget {
             const pos = geom?.attributes?.position?.array;
             if (!pos || pos.length === 0) return;
             for (let i = 0; i < pos.length; i++) {
-              const v2 = pos[i];
-              if (!Number.isFinite(v2)) {
-                bad.push({ mesh: obj, index: i, value: v2 });
+              const v = pos[i];
+              if (!Number.isFinite(v)) {
+                bad.push({ mesh: obj, index: i, value: v });
                 break;
               }
             }
@@ -4459,6 +5580,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);
@@ -4476,7 +5598,7 @@ var RendererManager = class extends EventTarget {
     if (this.#isClicked) return;
     this.#isClicked = true;
     const onClickElement = this.#onClickElement;
-    if (!(0, import_lodash_es4.isFunction)(onClickElement)) return;
+    if (!(0, import_lodash19.isFunction)(onClickElement)) return;
     this.#onClickElement(e);
     this.#isClicked = false;
   };
@@ -4519,7 +5641,7 @@ var RendererManager = class extends EventTarget {
       populate: true
     });
     units.filter(
-      (u4) => !["opentobelow", "escalator", "room"].includes(u4.properties.category)
+      (u) => !["opentobelow", "escalator", "room"].includes(u.properties.category)
     ).forEach((unit) => {
       const element = this.elementRenderer.createGeometry(unit);
       if (element) {
@@ -4527,9 +5649,9 @@ var RendererManager = class extends EventTarget {
         this.addElementsToManager(unit.id, _elements, unit.properties.level.properties.ordinal);
       }
     });
-    units.filter((u4) => u4.properties.category === "room").forEach((unit) => {
+    units.filter((u) => u.properties.category === "room").forEach((unit) => {
       const openingRelationships = relationships.filter((r) => r.properties.origin?.id === unit.id || r.properties.destination?.id === unit.id);
-      const roomOpenings = (0, import_lodash_es4.compact)(openingRelationships.map((rel) => {
+      const roomOpenings = (0, import_lodash19.compact)(openingRelationships.map((rel) => {
         const openingId = rel?.properties.intermediary[0].id;
         return openings.find((o) => o.id === openingId);
       }));
@@ -4553,7 +5675,7 @@ var RendererManager = class extends EventTarget {
         this.addElementsToManager(kiosk.id, _elements, kiosk.properties.level.properties.ordinal);
       }
     });
-    const escalators = units.filter((u4) => u4.properties.category === "escalator");
+    const escalators = units.filter((u) => u.properties.category === "escalator");
     for (const escalator of escalators) {
       try {
         const escalatorRelationships = relationships.filter((r) => (r.properties?.intermediary || []).some((inter) => inter.id === escalator.id));
@@ -4575,7 +5697,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 = (0, import_center3.center)(thisLevelOpening).geometry.coordinates;
+        const escalatorEntryPoint = (0, import_center12.center)(thisLevelOpening).geometry.coordinates;
         const element = await this.elementRenderer.createEscalator(escalator, escalatorEntryPoint, { direction, angle });
         if (element) {
           const _elements = Array.isArray(element) ? element : [element];
@@ -4587,8 +5709,8 @@ var RendererManager = class extends EventTarget {
     }
     const groundLabels = await this.#dataClient.filterByType("label");
     for (const label of groundLabels) {
-      const center2 = (0, import_center3.center)(polygon(label.geometry.coordinates)).geometry.coordinates;
-      const unit = findUnitOnPoint(units, center2);
+      const center8 = (0, import_center12.center)(polygon(label.geometry.coordinates)).geometry.coordinates;
+      const unit = findUnitOnPoint(units, center8);
       if (unit) {
         const element = this.elementRenderer.createGroundLabel(label, unit);
         if (element) {
@@ -4597,12 +5719,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"));
   }
@@ -4617,7 +5733,7 @@ var RendererManager = class extends EventTarget {
         this.markerRenderer.showMarkers(markers, ordinal - baseOrdinal);
       }
     } else {
-      const baseOrdinal = Array.isArray(targetOrdinal) ? (0, import_lodash_es4.min)(targetOrdinal) : targetOrdinal;
+      const baseOrdinal = Array.isArray(targetOrdinal) ? (0, import_lodash19.min)(targetOrdinal) : targetOrdinal;
       for (const [ordinal, elements] of this.elementsByOrdinal) {
         const inOrdinal = Array.isArray(targetOrdinal) ? targetOrdinal.includes(ordinal) : ordinal === targetOrdinal;
         if (inOrdinal) {
@@ -4644,7 +5760,7 @@ var RendererManager = class extends EventTarget {
     const elements = elemIds.map((id) => this.elementsMap.get(id)).flat();
     elements.forEach((element) => {
       const controller = this.elementRenderer.createHighlightController(element);
-      if (controller && (0, import_lodash_es4.isFunction)(controller.start)) {
+      if (controller && (0, import_lodash19.isFunction)(controller.start)) {
         controller.start();
         this.highlightControllers.push(controller);
       }
@@ -4652,7 +5768,7 @@ var RendererManager = class extends EventTarget {
   };
   clearHighlightElements = () => {
     this.highlightControllers.forEach((controller) => {
-      if ((0, import_lodash_es4.isFunction)(controller?.clear)) controller.clear();
+      if ((0, import_lodash19.isFunction)(controller?.clear)) controller.clear();
     });
   };
   /** 
@@ -4687,6 +5803,9 @@ var RendererManager = class extends EventTarget {
       this.markerRenderer.removeMarker(marker);
     }
   }
+  drawNavigation(route) {
+    this.elementRenderer.drawNavigation(route);
+  }
 };
 
 // src/IndoorMap/IndoorMap.ts
@@ -4764,7 +5883,7 @@ var IndoorMap = class extends EventTarget {
   };
   constructor(elementId, options) {
     super();
-    const combinedOptions = import_lodash6.default.merge({}, defaultOptions, options);
+    const combinedOptions = import_lodash20.default.merge({}, defaultOptions, options);
     this.options = combinedOptions;
     const {
       onMapReady,
@@ -4811,7 +5930,7 @@ var IndoorMap = class extends EventTarget {
     this.dataClient = options.dataClient;
   }
   setOptions(options) {
-    const combinedOptions = import_lodash6.default.merge({}, defaultOptions, options);
+    const combinedOptions = import_lodash20.default.merge({}, defaultOptions, options);
     this.options = combinedOptions;
     const maptalksOptions = parseMaptalksOptions(combinedOptions);
     this.map.setOptions(maptalksOptions);
@@ -4821,10 +5940,10 @@ var IndoorMap = class extends EventTarget {
     if (!this.options.camera?.defaultView?.center) {
       this.#dataClient.filterByType("venue").then((venues) => {
         this.#venues = venues;
-        const venueCenters = (0, import_center4.default)(featureCollection(venues));
+        const venueCenters = (0, import_center13.default)(featureCollection(venues));
         const [x, y] = venueCenters.geometry.coordinates;
-        const center2 = new import_maptalks_gl.Coordinate(x, y);
-        this.camera.setView({ center: center2, pitch: 60, zoom: 19 });
+        const center8 = new import_maptalks_gl.Coordinate(x, y);
+        this.camera.setView({ center: center8, pitch: 60, zoom: 19 });
       });
     }
   }
@@ -4837,7 +5956,7 @@ var IndoorMap = class extends EventTarget {
   handleMapClick = ({ coordinate }) => {
     const { x, y } = coordinate;
     console.log(
-      `[Coordinates]: x: ${import_lodash6.default.round(x, 8)} y: ${import_lodash6.default.round(
+      `[Coordinates]: x: ${import_lodash20.default.round(x, 8)} y: ${import_lodash20.default.round(
         y,
         8
       )}, [Bearing]: ${this.map.getBearing()}, [Pitch]: ${this.map.getPitch()}`
@@ -4923,7 +6042,7 @@ var IndoorMap = class extends EventTarget {
     if (this.#isClicked) return;
     this.#isClicked = true;
     const onClickElement = this.#onClickElement;
-    if (!import_lodash6.default.isFunction(onClickElement)) return;
+    if (!import_lodash20.default.isFunction(onClickElement)) return;
     this.#onClickElement(e);
     this.#isClicked = false;
   };
@@ -4943,16 +6062,16 @@ var IndoorMap = class extends EventTarget {
     for (const feature2 of this.#features) {
       try {
         const { feature_type: featureType, properties, id } = feature2;
-        const layerName = import_lodash6.default.get(
+        const layerName = import_lodash20.default.get(
           LAYER_FEATURE_TYPE_OBJ,
           featureType,
           featureType
         );
         const layer = this.map.getLayer(layerName);
         let geometry;
-        const category = import_lodash6.default.get(feature2, "properties.category");
-        const extrudeConfig = import_lodash6.default.get(this.#mapConfig, "extrude");
-        const textMarkerType = import_lodash6.default.get(
+        const category = import_lodash20.default.get(feature2, "properties.category");
+        const extrudeConfig = import_lodash20.default.get(this.#mapConfig, "extrude");
+        const textMarkerType = import_lodash20.default.get(
           this.#mapConfig,
           "text_marker_type",
           "ui-marker"
@@ -4984,7 +6103,7 @@ var IndoorMap = class extends EventTarget {
           case "opening": {
             switch (category) {
               case "emergencyexit":
-                const { geometry: geometry2 } = (0, import_center4.default)(feature2);
+                const { geometry: geometry2 } = (0, import_center13.default)(feature2);
                 const markerFeature = {
                   ...feature2,
                   geometry: geometry2
@@ -5067,9 +6186,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 = (0, import_distance.default)(displayPoint, [mapCenter.x, mapCenter.y]);
-      if (!closest || distance < closest.distance) {
-        return { venueId: venue.id, distance };
+      const distance5 = (0, import_distance6.default)(displayPoint, [mapCenter.x, mapCenter.y]);
+      if (!closest || distance5 < closest.distance) {
+        return { venueId: venue.id, distance: distance5 };
       }
       return closest;
     }, null);
@@ -5119,15 +6238,15 @@ var IndoorMap = class extends EventTarget {
     }
   }
   updateUserLocationSymbolByLocale(locale) {
-    const userLocationGeometry = import_lodash6.default.get(
+    const userLocationGeometry = import_lodash20.default.get(
       this.#elements,
       `${USER_LOCATION_ELEMENT_ID}.geometry`
     );
     if (!userLocationGeometry) return;
     const currentSymbol = userLocationGeometry.getSymbol();
     const localeSymbolToUpdate = currentSymbol.map((symbol) => {
-      const localeSymbol = import_lodash6.default.get(symbol, `${LOCALE_SYMBOL_KEY}.${locale}`) || import_lodash6.default.get(symbol, `${LOCALE_SYMBOL_KEY}.default`);
-      if (!import_lodash6.default.isPlainObject(localeSymbol)) return symbol;
+      const localeSymbol = import_lodash20.default.get(symbol, `${LOCALE_SYMBOL_KEY}.${locale}`) || import_lodash20.default.get(symbol, `${LOCALE_SYMBOL_KEY}.default`);
+      if (!import_lodash20.default.isPlainObject(localeSymbol)) return symbol;
       return {
         ...symbol,
         ...localeSymbol
@@ -5201,14 +6320,14 @@ var IndoorMap = class extends EventTarget {
    * END of User Location
    ****************************/
   showGeometryByElementId = (elementId) => {
-    const geometry = import_lodash6.default.get(
+    const geometry = import_lodash20.default.get(
       this.#elements,
       `${elementId}.geometry`
     );
     if (geometry) geometry.show();
   };
   hideGeometryByElementId = (elementId) => {
-    const geometry = import_lodash6.default.get(this.#elements, `${elementId}.geometry`);
+    const geometry = import_lodash20.default.get(this.#elements, `${elementId}.geometry`);
     if (geometry) geometry.hide();
   };
   setSpriteMarkersOpacity = (opacity = 1) => {
@@ -5247,7 +6366,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;
@@ -5255,14 +6374,14 @@ var IndoorMap = class extends EventTarget {
       const line = lineStrings[i];
       const coords = line.geometry.coordinates;
       const prevLine = lineStrings[i - 1];
-      const firstCoord = import_lodash6.default.first(coords);
+      const firstCoord = import_lodash20.default.first(coords);
       const isFirstLine = i === 0;
       if (isFirstLine) {
         accLine.push(...coords);
         continue;
       }
-      const prevLastCoord = import_lodash6.default.last(prevLine.geometry.coordinates);
-      const isNearby = (0, import_distance.default)(point(firstCoord), point(prevLastCoord)) < distance;
+      const prevLastCoord = import_lodash20.default.last(prevLine.geometry.coordinates);
+      const isNearby = (0, import_distance6.default)(point(firstCoord), point(prevLastCoord)) < distance5;
       if (!isNearby) {
         const remainingLines = lineStrings.slice(i);
         const res = this.combineNearbyLineStrings(remainingLines, properties);
@@ -5282,8 +6401,8 @@ var IndoorMap = class extends EventTarget {
       create3DStepPath
     } = this.#styler;
     const routeMarkerLayer = this.map.getLayer(HIGHLIGHT_LAYER_NAME);
-    const linesByOrdinal = (0, import_lodash6.default)(stepGeometries).filter(({ geometry }) => geometry.type === "LineString").groupBy("properties.ordinal").value();
-    const joinedLines = (0, import_lodash6.default)(linesByOrdinal).reduce((acc, lines, key) => {
+    const linesByOrdinal = (0, import_lodash20.default)(stepGeometries).filter(({ geometry }) => geometry.type === "LineString").groupBy("properties.ordinal").value();
+    const joinedLines = (0, import_lodash20.default)(linesByOrdinal).reduce((acc, lines, key) => {
       const joined = this.combineNearbyLineStrings(lines, {
         properties: { ordinal: +key }
       });
@@ -5311,14 +6430,14 @@ var IndoorMap = class extends EventTarget {
                 stepElement = createOriginMarker(stepGeometry).addTo(routeMarkerLayer);
                 break;
               case "destination-marker":
-                const extrudeConfig = import_lodash6.default.get(this.#mapConfig, "extrude");
+                const extrudeConfig = import_lodash20.default.get(this.#mapConfig, "extrude");
                 if (destinationFeature.feature_type === "occupant") {
-                  const stepId = import_lodash6.default.get(stepGeometry, "id");
+                  const stepId = import_lodash20.default.get(stepGeometry, "id");
                   const normalizedDestinationFeature = {
                     ...destinationFeature,
                     id: stepId
                   };
-                  const logoUrl = import_lodash6.default.get(
+                  const logoUrl = import_lodash20.default.get(
                     normalizedDestinationFeature,
                     "properties.logo.url"
                   );
@@ -5363,15 +6482,15 @@ var IndoorMap = class extends EventTarget {
     const routeMarkerLayer = this.map.getLayer(
       HIGHLIGHT_LAYER_NAME
     );
-    const originMarkerGeometry = import_lodash6.default.get(
+    const originMarkerGeometry = import_lodash20.default.get(
       this.#elements,
       `${ORIGIN_MARKER_ID}.geometry`
     );
-    const destinationMarkerGeometry = import_lodash6.default.get(
+    const destinationMarkerGeometry = import_lodash20.default.get(
       this.#elements,
       `${DESTINATION_MARKER_ID}.geometry`
     );
-    const geometriesToRemove = import_lodash6.default.compact([
+    const geometriesToRemove = import_lodash20.default.compact([
       originMarkerGeometry,
       destinationMarkerGeometry
     ]);
@@ -5382,7 +6501,7 @@ var IndoorMap = class extends EventTarget {
       (obj) => !(obj instanceof NavigationPath)
     );
     const objects = this.#navigationGeometries || {};
-    import_lodash6.default.forEach(objects, (obj) => {
+    import_lodash20.default.forEach(objects, (obj) => {
       if (!obj) return;
       this.#navigationGeometries[obj.properties.id] = null;
       obj.remove();
@@ -5419,7 +6538,7 @@ var IndoorMap = class extends EventTarget {
     }
     if (this.threeLayer) {
       const currentView = this.camera.getView();
-      const objectOpacity = import_lodash6.default.clamp(38 - 2 * currentView.zoom, 0, 1);
+      const objectOpacity = import_lodash20.default.clamp(38 - 2 * currentView.zoom, 0, 1);
       this.#objects.forEach((object) => {
         object.getObject3d().traverse((child) => {
           if (child.isMesh) child.material.opacity = objectOpacity;
@@ -5429,7 +6548,7 @@ var IndoorMap = class extends EventTarget {
       });
       if (this.#billboardObjects) {
         this.#billboardObjects.forEach((object) => {
-          const objectScale = import_lodash6.default.clamp(
+          const objectScale = import_lodash20.default.clamp(
             20 - 1 * currentView.zoom,
             1,
             1.05
@@ -5438,7 +6557,7 @@ var IndoorMap = class extends EventTarget {
         });
       }
       if (this.#isLayersFadingOnZoom) {
-        const layerOpacity = import_lodash6.default.clamp(1 - objectOpacity, 0, 1);
+        const layerOpacity = import_lodash20.default.clamp(1 - objectOpacity, 0, 1);
         LAYERS.forEach((layerKey) => {
           const layer = this.map.getLayer(layerKey);
           if (layer) layer.setOpacity(layerOpacity);
@@ -5468,6 +6587,7 @@ var IndoorMap = class extends EventTarget {
   GEOJSON_FEATURE_TYPES,
   HIGHLIGHT_LAYER_NAME,
   IMDF_FEATURE_TYPES,
+  IMDF_UNIT_CATEGORIES,
   IndoorMap,
   LAST_USER_LOCATION_ELEMENT_ID_PREFIX,
   LAYERS,
@@ -5499,11 +6619,13 @@ var IndoorMap = class extends EventTarget {
   getLocationByFeature,
   getLocationByOccupant,
   getLocationIdByFeature,
+  getNavigateClient,
   getOrdinalByLocationId,
   getRelatedLocationIdsByFeature,
   getRelatedLocationsByAmenity,
   getRelatedLocationsByFeature,
   getRelatedLocationsByOccupant,
+  getSearchClient,
   getSuitablyValueBetweenBearings,
   isClickableFeature,
   isValidCoordinate,