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

package/dist/data/index.js

@@ -0,0 +1,2573 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/data/index.ts
+var data_exports = {};
+__export(data_exports, {
+  ALL_FEATURE_TYPES: () => ALL_FEATURE_TYPES,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  GEOJSON_FEATURE_TYPES: () => GEOJSON_FEATURE_TYPES,
+  IMDF_FEATURE_TYPES: () => IMDF_FEATURE_TYPES,
+  IMDF_UNIT_CATEGORIES: () => IMDF_UNIT_CATEGORIES,
+  NONIMDF_FEATURE_TYPES: () => NONIMDF_FEATURE_TYPES,
+  OccupantHelpers: () => occupant_helper_exports,
+  QueryObserver: () => import_query_core2.QueryObserver,
+  defaultFeatureQueryOptionsMap: () => defaultFeatureQueryOptionsMap,
+  fetchDeliveryApi: () => fetchDeliveryApi,
+  fetchPreviewApi: () => fetchPreviewApi,
+  getDataClient: () => getDataClient,
+  getNavigateClient: () => getNavigateClient,
+  getSearchClient: () => getSearchClient,
+  isValidCoordinate: () => isValidCoordinate,
+  isValidLineString: () => isValidLineString,
+  isValidLineStringCoordinates: () => isValidLineStringCoordinates,
+  isValidMultiPolygon: () => isValidMultiPolygon,
+  isValidMultiPolygonCoordinates: () => isValidMultiPolygonCoordinates,
+  isValidPoint: () => isValidPoint,
+  isValidPolygon: () => isValidPolygon,
+  isValidPolygonCoordinates: () => isValidPolygonCoordinates,
+  matchFilter: () => matchFilter,
+  matchFilters: () => matchFilters,
+  safeFetchFeature: () => safeFetchFeature
+});
+module.exports = __toCommonJS(data_exports);
+var import_query_core2 = require("@tanstack/query-core");
+
+// src/data/constant.ts
+var DEFAULT_BASE_URL = "https://service.venue.in.th/api";
+var IMDF_FEATURE_TYPES = [
+  "address",
+  "amenity",
+  "anchor",
+  "building",
+  "detail",
+  "fixture",
+  "footprint",
+  "geofence",
+  "kiosk",
+  "level",
+  "occupant",
+  "opening",
+  "relationship",
+  "section",
+  "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",
+  "promotion",
+  "label",
+  "privilege"
+];
+var GEOJSON_FEATURE_TYPES = [
+  ...IMDF_FEATURE_TYPES,
+  ...NONIMDF_FEATURE_TYPES
+];
+var ALL_FEATURE_TYPES = [
+  ...GEOJSON_FEATURE_TYPES,
+  "sponsored-content",
+  "element"
+];
+var defaultFeatureQueryOptionsMap = {
+  // IMDF
+  address: {},
+  amenity: {},
+  anchor: {},
+  building: {},
+  detail: { enabled: false },
+  fixture: {},
+  footprint: {},
+  geofence: { enabled: false },
+  kiosk: {},
+  level: {},
+  occupant: {
+    refetchInterval: 5 * 60 * 1e3,
+    // refresh every 5 min
+    staleTime: 5 * 60 * 1e3
+  },
+  opening: {},
+  relationship: {},
+  section: {},
+  unit: {},
+  venue: {},
+  // OTHERS GEOJSON
+  taxonomy: {},
+  privilege: {},
+  event: {},
+  promotion: {
+    refetchInterval: 0.5 * 60 * 1e3,
+    // refresh every 5 min
+    staleTime: 0.5 * 60 * 1e3
+  },
+  label: {},
+  // NON GEOJSON
+  "sponsored-content": {
+    refetchInterval: 1 * 60 * 1e3
+    // refresh every 5 min
+  },
+  element: {},
+  page: {},
+  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) {
+    case "label":
+    case "element": {
+      const pluralFeatureType = `${featureType}s`;
+      const res = await fetch(
+        `${baseUrl}/delivery/projects/${projectId}/${pluralFeatureType}.geojson?api-key=${apiKey}`
+      );
+      if (res.status !== 200) return [];
+      const items = await res.json();
+      return items;
+    }
+    case "model3d": {
+      const res = await fetch(
+        `${baseUrl}/delivery/projects/${projectId}/${featureType}.geojson?api-key=${apiKey}`
+      );
+      if (res.status !== 200) return [];
+      const items = await res.json();
+      return items.features;
+    }
+    case "sponsored-content": {
+      const res = await fetch(
+        `${baseUrl}/delivery/projects/${projectId}/sponsored-content.json?api-key=${apiKey}`
+      );
+      if (res.status !== 200) return [];
+      const jsonRes = await res.json();
+      const items = jsonRes.data;
+      return items.map((item) => ({
+        id: item.id,
+        ...item.attributes
+      }));
+    }
+    default: {
+      const res = await fetch(
+        `${baseUrl}/delivery/projects/${projectId}/imdf/${featureType}.geojson?api-key=${apiKey}`
+      );
+      if (res.status !== 200) return [];
+      const collections = await res.json();
+      return collections.features;
+    }
+  }
+}
+async function fetchPreviewApi(projectId, previewToken, featureType, baseUrl = DEFAULT_BASE_URL) {
+  switch (featureType) {
+    case "label":
+    case "element": {
+      const pluralFeatureType = `${featureType}s`;
+      const res = await fetch(
+        `${baseUrl}/preview/projects/${projectId}/${pluralFeatureType}.geojson`,
+        {
+          headers: {
+            Authorization: `Bearer ${previewToken}`
+          }
+        }
+      );
+      if (res.status !== 200) return [];
+      const items = await res.json();
+      return items;
+    }
+    case "sponsored-content": {
+      const res = await fetch(
+        `${baseUrl}/preview/projects/${projectId}/sponsored-content.json`,
+        {
+          headers: {
+            Authorization: `Bearer ${previewToken}`
+          }
+        }
+      );
+      if (res.status !== 200) return [];
+      const jsonRes = await res.json();
+      const items = jsonRes.data;
+      return items.map((item) => ({
+        id: item.id,
+        ...item.attributes
+      }));
+    }
+    default: {
+      const res = await fetch(
+        `${baseUrl}/preview/projects/${projectId}/imdf/${featureType}.geojson`,
+        {
+          headers: {
+            Authorization: `Bearer ${previewToken}`
+          }
+        }
+      );
+      if (res.status !== 200) return [];
+      const collections = await res.json();
+      return collections.features;
+    }
+  }
+}
+var safeFetchFeature = async (featureType, params) => {
+  const mode = params.mode ?? "delivery";
+  const projectId = params.projectId;
+  const apiKey = params.apiKey;
+  const previewToken = params.previewToken;
+  const baseUrl = params.baseUrl ?? DEFAULT_BASE_URL;
+  try {
+    let result = [];
+    if (mode === "delivery") {
+      result = await fetchDeliveryApi(
+        projectId,
+        apiKey,
+        featureType,
+        baseUrl
+      );
+    } else if (mode === "preview") {
+      result = await fetchPreviewApi(
+        projectId,
+        previewToken,
+        featureType,
+        baseUrl
+      );
+    }
+    return result ?? [];
+  } catch (e) {
+    return Promise.resolve([]);
+  }
+};
+
+// 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 unit;
+};
+var findContainingUnitAtPoint = (point2, levelId, units) => {
+  const unit = units.find(
+    (unit2) => {
+      try {
+        return unit2.properties.level_id === levelId && (0, import_boolean_point_in_polygon.booleanPointInPolygon)(point2, unit2);
+      } catch (e) {
+        console.log(`Cannot find containing unit of (point: ${point2}, levelId: ${levelId}):`, e.message);
+        return false;
+      }
+    }
+  );
+  return unit;
+};
+
+// src/data/populator/index.ts
+var createPopulator = ({
+  internalFindById,
+  internalFilterByType
+}) => {
+  const populateAddress = (address) => Promise.resolve(address);
+  const populateBuilding = (building) => Promise.resolve(building);
+  const populateDetail = (detail) => Promise.resolve(detail);
+  const populateFootprint = (footprint) => Promise.resolve(footprint);
+  const populateGeofence = (geofence) => Promise.resolve(geofence);
+  const populatePrivilege = (privilege) => Promise.resolve(privilege);
+  const populateEvent = (event) => Promise.resolve(event);
+  const populatePromotion = async (promotion) => {
+    const venue = await internalFindById(promotion.properties.venue_id);
+    return {
+      ...promotion,
+      properties: {
+        ...promotion.properties,
+        venue
+      }
+    };
+  };
+  const populateAmenity = async (amenity) => {
+    const units = await Promise.all(
+      amenity.properties.unit_ids.map(internalFindById)
+    );
+    const populatedUnits = await Promise.all(units.map(populateUnit));
+    const venue = await internalFindById(amenity.properties.venue_id);
+    const defaultLevel = populatedUnits[0].properties.level;
+    const kiosks = await internalFilterByType("kiosk");
+    const ordinalKiosks = kiosks.filter(
+      (kiosk2) => kiosk2.properties.level_id === defaultLevel.id
+    );
+    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
+      }
+    };
+  };
+  const populateAnchor = async (anchor) => {
+    const unit = await internalFindById(anchor.properties.unit_id);
+    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_point_in_polygon2.booleanPointInPolygon)(anchor, section2));
+    return {
+      ...anchor,
+      properties: {
+        ...anchor.properties,
+        level: await populateLevel(level),
+        unit: await populateUnit(unit),
+        section: section ? await populateSection(section) : null,
+        venue: await populateVenue(venue),
+        ordinal: level.properties.ordinal
+      }
+    };
+  };
+  const populateFixture = async (fixture) => {
+    const level = await internalFindById(fixture.properties.level_id);
+    const venue = await internalFindById(fixture.properties.venue_id);
+    const anchor = await internalFindById(fixture.properties.anchor_id);
+    return {
+      ...fixture,
+      properties: {
+        ...fixture.properties,
+        anchor: anchor ? await populateAnchor(anchor) : null,
+        level: await populateLevel(level),
+        venue: await populateVenue(venue),
+        ordinal: level.properties.ordinal
+      }
+    };
+  };
+  const populateKiosk = async (kiosk) => {
+    const level = await internalFindById(kiosk.properties.level_id);
+    const venue = await internalFindById(kiosk.properties.venue_id);
+    const anchor = await internalFindById(kiosk.properties.anchor_id);
+    const units = await internalFilterByType("unit");
+    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_point_in_polygon2.booleanPointInPolygon)(anchor, section2));
+    }
+    return {
+      ...kiosk,
+      properties: {
+        ...kiosk.properties,
+        anchor: anchor ? await populateAnchor(anchor) : null,
+        level: await populateLevel(level),
+        venue: await populateVenue(venue),
+        ordinal: level.properties.ordinal,
+        unit: unit ? await populateUnit(unit) : null,
+        section: section ? await populateSection(section) : null
+      }
+    };
+  };
+  const populateLevel = async (level) => {
+    const venue = await internalFindById(level.properties.venue_id);
+    return {
+      ...level,
+      properties: {
+        ...level.properties,
+        venue
+      }
+    };
+  };
+  const populateOccupant = async (occupant) => {
+    const {
+      anchor_id,
+      venue_id,
+      local_category_ids,
+      promotion_ids = [],
+      privilege_ids = [],
+      kiosk_id,
+      unit_id,
+      kiosk_ids = [],
+      unit_ids = []
+    } = occupant.properties;
+    const anchor = await internalFindById(anchor_id);
+    const venue = await internalFindById(venue_id);
+    const localCategories = await Promise.all(
+      local_category_ids.map(internalFindById)
+    );
+    const promotions = await Promise.all(
+      promotion_ids.map(internalFindById)
+    );
+    const privileges = await Promise.all(
+      privilege_ids.map(internalFindById)
+    );
+    const kiosk = await internalFindById(kiosk_id);
+    const unit = await internalFindById(unit_id);
+    const kiosks = await Promise.all(kiosk_ids.map(internalFindById));
+    const units = await Promise.all(unit_ids.map(internalFindById));
+    return {
+      ...occupant,
+      properties: {
+        ...occupant.properties,
+        anchor: anchor ? await populateAnchor(anchor) : null,
+        local_categories: await Promise.all(
+          compact(localCategories).map(populateTaxonomy)
+        ),
+        venue,
+        promotions,
+        privileges,
+        kiosk: kiosk ? await populateKiosk(kiosk) : null,
+        unit: unit ? await populateUnit(unit) : null,
+        kiosks: await Promise.all(kiosks.map(populateKiosk)),
+        units: await Promise.all(units.map(populateUnit))
+      }
+    };
+  };
+  const populateOpening = async (opening) => {
+    const venue = await internalFindById(opening.properties.venue_id);
+    const level = await internalFindById(opening.properties.level_id);
+    return {
+      ...opening,
+      properties: {
+        venue,
+        level: await populateLevel(level),
+        ordinal: level.properties.ordinal
+      }
+    };
+  };
+  const populateSection = async (section) => {
+    const venue = await internalFindById(section.properties.venue_id);
+    const level = await internalFindById(section.properties.level_id);
+    return {
+      ...section,
+      properties: {
+        ...section.properties,
+        venue,
+        level: await populateLevel(level),
+        ordinal: level.properties.ordinal
+      }
+    };
+  };
+  const populateRelationship = async (relationship) => {
+    const originId = relationship.properties.origin?.id;
+    const destinationId = relationship.properties.destination?.id;
+    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_point_in_polygon2.booleanPointInPolygon)((0, import_center2.center)(unit), section2)) : null;
+      return {
+        ...unit,
+        properties: {
+          ...unit.properties,
+          venue,
+          ordinal: level.properties.ordinal,
+          level: await populateLevel(level),
+          section: section ? await populateSection(section) : null
+        }
+      };
+    } catch (err) {
+      console.log(`error finding section `, { unit, sections });
+    }
+  };
+  const populateVenue = (venue) => {
+    return Promise.resolve(venue);
+  };
+  const populateTaxonomy = async (taxonomy) => {
+    const venue = await internalFindById(taxonomy.properties.venue_id);
+    return {
+      ...taxonomy,
+      properties: {
+        ...taxonomy.properties,
+        venue: venue ? await populateVenue(venue) : null
+      }
+    };
+  };
+  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,
+    building: populateBuilding,
+    detail: populateDetail,
+    fixture: populateFixture,
+    footprint: populateFootprint,
+    geofence: populateGeofence,
+    opening: populateOpening,
+    relationship: populateRelationship,
+    privilege: populatePrivilege,
+    promotion: populatePromotion,
+    event: populateEvent,
+    label: populateFeature,
+    element: populateFeature,
+    page: populateFeature,
+    amenity: populateAmenity,
+    anchor: populateAnchor,
+    kiosk: populateKiosk,
+    level: populateLevel,
+    occupant: populateOccupant,
+    section: populateSection,
+    unit: populateUnit,
+    venue: populateVenue,
+    taxonomy: populateTaxonomy,
+    model3d: populateModel3D
+  };
+};
+
+// 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 center7 = (0, import_center4.center)(feat);
+      for (const opening of openings) {
+        try {
+          const openingCenter = (0, import_center4.center)(opening);
+          const dis = (0, import_distance2.distance)(center7, openingCenter, { units: "meters" }) + BASE_POI_BASEDISTANCE;
+          import_lodash9.default.set(nodeMap, `${opening.id}.${feat.id}`, dis);
+          import_lodash9.default.set(nodeMap, `${feat.id}.${opening.id}`, dis);
+          counter++;
+        } catch (err) {
+          console.log(err, opening);
+        }
+      }
+    } catch (err) {
+      console.log(err);
+      console.log(`cannot connect poi to openings`, err.message, { feat });
+    }
+  });
+  const type = features.length > 0 ? features[0].feature_type : "-";
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} ${type} relationships`, t1 - t0);
+  return nodeMap;
+};
+
+// 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 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"
+    );
+  const createDeliveryApiQueryOptions = (featureType) => ({
+    queryKey: ["_deliveryapi", featureType],
+    queryFn: () => safeFetchFeature(featureType, { mode, projectId, apiKey, previewToken, baseUrl })
+  });
+  const internalFilterByType = async (featureType) => {
+    try {
+      const features = await queryClient.ensureQueryData(createDeliveryApiQueryOptions(featureType));
+      return features;
+    } catch (error) {
+      throw error;
+    }
+  };
+  const internalFindById = async (id) => {
+    if (id === null || id === void 0) return null;
+    const featureType = id.slice(0, id.lastIndexOf("-"));
+    const feature2 = await queryClient.ensureQueryData({
+      queryKey: ["_deliveryapi", featureType, id],
+      queryFn: async () => {
+        const features = await internalFilterByType(featureType);
+        const feature3 = features.find(
+          (f) => f.id === id
+        );
+        return feature3 ?? null;
+      }
+    });
+    return feature2;
+  };
+  const populator = createPopulator({ internalFindById, internalFilterByType });
+  const registerObserver = (featureType, refetchInterval) => {
+    if (observers.has(featureType)) {
+      console.warn(`Observer for ${featureType} already exists`);
+      const record = observers.get(featureType);
+      return record.observer;
+    }
+    const options2 = createDeliveryApiQueryOptions(featureType);
+    const observer = new import_query_core.QueryObserver(queryClient, {
+      ...options2,
+      refetchInterval
+    });
+    const unsubscribe = observer.subscribe(() => {
+      console.log(`[venue-js] Listening to ${featureType} changes (interval = ${refetchInterval}ms)`);
+    });
+    observers.set(featureType, { observer, unsubscribe });
+    return observer;
+  };
+  const destroyObserver = (featureType) => {
+    const record = observers.get(featureType);
+    if (!record) return;
+    record.unsubscribe();
+    observers.delete(featureType);
+  };
+  const destroyObservers = () => {
+    observers.forEach(({ observer, unsubscribe }) => {
+      unsubscribe();
+      observer.destroy();
+    });
+    observers.clear();
+  };
+  const createFilterByTypeQueryOptions = (featureType, params = {}, options2 = {}) => ({
+    queryKey: [featureType, "list", params],
+    queryFn: async () => {
+      const features = await internalFilterByType(featureType);
+      const filters = params.filters ?? {};
+      let result = features;
+      if (params.filters) {
+        result = features.filter((f) => matchFilters(f, filters));
+      }
+      return params.populate === true ? await Promise.all(result.map((f) => populator[featureType](f))) : result;
+    },
+    ...options2 ?? {}
+  });
+  const createFindByIdQueryOptions = (featureType, id, params = {}, options2 = {}) => ({
+    queryKey: [featureType, "detail", id, params],
+    queryFn: async () => {
+      const feature2 = await internalFindById(id);
+      return params.populate === true ? await populator[featureType](feature2) : Promise.resolve(feature2);
+    },
+    ...options2 ?? {}
+  });
+  async function filterByType(featureType, params) {
+    const filterQueryOptions = createFilterByTypeQueryOptions(
+      featureType,
+      params
+    );
+    const features = await queryClient.ensureQueryData(filterQueryOptions);
+    return params?.populate === true ? features : features;
+  }
+  async function findById(featureType, id, params) {
+    const findQueryOptions = createFindByIdQueryOptions(
+      featureType,
+      id,
+      params
+    );
+    const feature2 = await queryClient.ensureQueryData(findQueryOptions);
+    return feature2;
+  }
+  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);
+  };
+  const navigateFn = async (origin, destination) => {
+    if (!navigateClient) {
+      const [levels, occupants, openings, relationships, units, fixtures, kiosks, amenities, anchors] = await Promise.all([
+        filterByType("level"),
+        filterByType("occupant"),
+        filterByType("opening"),
+        filterByType("relationship"),
+        filterByType("unit"),
+        filterByType("fixture"),
+        filterByType("kiosk"),
+        filterByType("amenity"),
+        filterByType("anchor")
+      ]);
+      const haystack = { levels, occupants, openings, relationships, units, fixtures, kiosks, amenities, anchors };
+      navigateClient = getNavigateClient({ data: haystack });
+    }
+    return navigateClient.findRoute(origin, destination);
+  };
+  return {
+    projectId,
+    queryClient,
+    registerObserver,
+    destroyObserver,
+    destroyObservers,
+    createFilterByTypeQueryOptions,
+    createFindByIdQueryOptions,
+    _internalFindById: internalFindById,
+    filterByType,
+    findById,
+    search: searchFn,
+    navigate: navigateFn
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALL_FEATURE_TYPES,
+  DEFAULT_BASE_URL,
+  GEOJSON_FEATURE_TYPES,
+  IMDF_FEATURE_TYPES,
+  IMDF_UNIT_CATEGORIES,
+  NONIMDF_FEATURE_TYPES,
+  OccupantHelpers,
+  QueryObserver,
+  defaultFeatureQueryOptionsMap,
+  fetchDeliveryApi,
+  fetchPreviewApi,
+  getDataClient,
+  getNavigateClient,
+  getSearchClient,
+  isValidCoordinate,
+  isValidLineString,
+  isValidLineStringCoordinates,
+  isValidMultiPolygon,
+  isValidMultiPolygonCoordinates,
+  isValidPoint,
+  isValidPolygon,
+  isValidPolygonCoordinates,
+  matchFilter,
+  matchFilters,
+  safeFetchFeature
+});
+//# sourceMappingURL=index.js.map