@proximap/core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2221 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CATEGORIES: () => CATEGORIES,
+  CATEGORY_LABELS: () => CATEGORY_LABELS,
+  DEFAULT_DAILY_NEEDS: () => DEFAULT_DAILY_NEEDS,
+  DEFAULT_USER_AGENT: () => DEFAULT_USER_AGENT,
+  DEFAULT_WALK_CATEGORIES: () => DEFAULT_WALK_CATEGORIES,
+  DatasetPlacesProvider: () => DatasetPlacesProvider,
+  HaversineRoutingProvider: () => HaversineRoutingProvider,
+  HttpError: () => HttpError,
+  InMemoryCache: () => InMemoryCache,
+  MODE_SPEED_MPS: () => MODE_SPEED_MPS,
+  NominatimGeocoder: () => NominatimGeocoder,
+  ODBL_ATTRIBUTION: () => ODBL_ATTRIBUTION,
+  OsrmRoutingProvider: () => OsrmRoutingProvider,
+  OverpassPlacesProvider: () => OverpassPlacesProvider,
+  RateLimiter: () => RateLimiter,
+  VERSION: () => VERSION,
+  ValhallaRoutingProvider: () => ValhallaRoutingProvider,
+  accessibleScorer: () => accessibleScorer,
+  buildOverpassQuery: () => buildOverpassQuery,
+  buildTargetedOverpassQuery: () => buildTargetedOverpassQuery,
+  categorize: () => categorize,
+  categoryVocabulary: () => categoryVocabulary,
+  circlePolygon: () => circlePolygon,
+  compareLocations: () => compareLocations,
+  compileFacets: () => compileFacets,
+  completenessOf: () => completenessOf,
+  dedupePois: () => dedupePois,
+  detectGaps: () => detectGaps,
+  disambiguateLocation: () => disambiguateLocation,
+  findNearbyAmenities: () => findNearbyAmenities,
+  formatDistance: () => formatDistance,
+  formatDuration: () => formatDuration,
+  haversineMeters: () => haversineMeters,
+  isCategory: () => isCategory,
+  isKnownTerm: () => isKnownTerm,
+  isOpenAt: () => isOpenAt,
+  lastVerifiedOf: () => lastVerifiedOf,
+  matchesFacets: () => matchesFacets,
+  nearestMatchingPoi: () => nearestMatchingPoi,
+  parseCoordinates: () => parseCoordinates,
+  planErrands: () => planErrands,
+  pointInPolygon: () => pointInPolygon,
+  rankByProximity: () => rankByProximity,
+  reachableAmenities: () => reachableAmenities,
+  requestJson: () => requestJson,
+  resolveCategories: () => resolveCategories,
+  resolveOrigin: () => resolveOrigin,
+  selectorToOverpassFilter: () => selectorToOverpassFilter,
+  snapshotArea: () => snapshotArea,
+  suggestCategories: () => suggestCategories,
+  tagsMatchAnySelector: () => tagsMatchAnySelector,
+  tagsMatchSelector: () => tagsMatchSelector,
+  toCSV: () => toCSV,
+  toGeoJSON: () => toGeoJSON,
+  walkSubScore: () => walkSubScore,
+  walkabilityScore: () => walkabilityScore
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var CATEGORIES = [
+  "food",
+  "grocery",
+  "shopping",
+  "healthcare",
+  "education",
+  "finance",
+  "transport",
+  "fuel",
+  "parking",
+  "accommodation",
+  "leisure",
+  "tourism",
+  "worship",
+  "public_service",
+  "utility",
+  "other"
+];
+
+// src/geo.ts
+var EARTH_RADIUS_M = 63710088e-1;
+var toRadians = (degrees) => degrees * Math.PI / 180;
+function haversineMeters(a2, b) {
+  const dLat = toRadians(b.lat - a2.lat);
+  const dLng = toRadians(b.lng - a2.lng);
+  const lat1 = toRadians(a2.lat);
+  const lat2 = toRadians(b.lat);
+  const sinLat = Math.sin(dLat / 2);
+  const sinLng = Math.sin(dLng / 2);
+  const h = sinLat * sinLat + Math.cos(lat1) * Math.cos(lat2) * sinLng * sinLng;
+  return 2 * EARTH_RADIUS_M * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+function formatDistance(meters) {
+  if (!Number.isFinite(meters) || meters < 0) return "\u2014";
+  if (meters < 1e3) return `${Math.round(meters)} m`;
+  const km = meters / 1e3;
+  return `${km < 10 ? km.toFixed(1) : Math.round(km)} km`;
+}
+function formatDuration(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) return "\u2014";
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes} min`;
+  const hours = Math.floor(minutes / 60);
+  const remainder = minutes % 60;
+  return remainder === 0 ? `${hours} h` : `${hours} h ${remainder} min`;
+}
+function parseCoordinates(input) {
+  const match = input.trim().match(/^(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)$/);
+  if (!match) return null;
+  const lat = Number(match[1]);
+  const lng = Number(match[2]);
+  if (Number.isNaN(lat) || Number.isNaN(lng)) return null;
+  if (lat < -90 || lat > 90 || lng < -180 || lng > 180) return null;
+  return { lat, lng };
+}
+
+// src/categories.ts
+var AMENITY_GROUPS = {
+  food: ["restaurant", "cafe", "fast_food", "bar", "pub", "food_court", "biergarten", "ice_cream"],
+  healthcare: [
+    "hospital",
+    "clinic",
+    "doctors",
+    "dentist",
+    "pharmacy",
+    "veterinary",
+    "nursing_home"
+  ],
+  education: ["school", "college", "university", "kindergarten", "library", "language_school"],
+  finance: ["bank", "atm", "bureau_de_change"],
+  fuel: ["fuel", "charging_station"],
+  parking: ["parking", "bicycle_parking", "motorcycle_parking", "parking_entrance"],
+  transport: [
+    "bus_station",
+    "taxi",
+    "ferry_terminal",
+    "car_rental",
+    "bicycle_rental",
+    "car_sharing"
+  ],
+  worship: ["place_of_worship"],
+  public_service: [
+    "police",
+    "fire_station",
+    "post_office",
+    "townhall",
+    "courthouse",
+    "community_centre"
+  ],
+  leisure: ["cinema", "theatre", "nightclub", "arts_centre"],
+  shopping: ["marketplace"],
+  utility: [
+    "toilets",
+    "drinking_water",
+    "shower",
+    "recycling",
+    "waste_disposal",
+    "post_box",
+    "telephone",
+    "fountain",
+    "shelter"
+  ]
+};
+var AMENITY_TO_CATEGORY = /* @__PURE__ */ new Map();
+for (const [category, values] of Object.entries(AMENITY_GROUPS)) {
+  for (const value of values) AMENITY_TO_CATEGORY.set(value, category);
+}
+var GROCERY_SHOPS = /* @__PURE__ */ new Set([
+  "supermarket",
+  "convenience",
+  "greengrocer",
+  "bakery",
+  "butcher",
+  "general",
+  "deli",
+  "farm",
+  "dairy",
+  "health_food"
+]);
+var LODGING_TOURISM = /* @__PURE__ */ new Set([
+  "hotel",
+  "hostel",
+  "guest_house",
+  "motel",
+  "apartment",
+  "chalet",
+  "camp_site",
+  "caravan_site"
+]);
+var TRANSPORT_RAILWAY = /* @__PURE__ */ new Set(["station", "halt", "tram_stop", "subway_entrance", "stop"]);
+function categorize(tags) {
+  const {
+    amenity,
+    shop: shop2,
+    tourism: tourism2,
+    leisure: leisure2,
+    healthcare,
+    railway,
+    public_transport,
+    highway,
+    aeroway,
+    office
+  } = tags;
+  if (amenity) {
+    const category = AMENITY_TO_CATEGORY.get(amenity);
+    return category ? { category, kind: amenity } : { category: "other", kind: amenity };
+  }
+  if (shop2) return { category: GROCERY_SHOPS.has(shop2) ? "grocery" : "shopping", kind: shop2 };
+  if (tourism2)
+    return { category: LODGING_TOURISM.has(tourism2) ? "accommodation" : "tourism", kind: tourism2 };
+  if (healthcare) return { category: "healthcare", kind: healthcare };
+  if (leisure2) return { category: "leisure", kind: leisure2 };
+  if (railway && TRANSPORT_RAILWAY.has(railway)) return { category: "transport", kind: railway };
+  if (public_transport) return { category: "transport", kind: public_transport };
+  if (highway === "bus_stop") return { category: "transport", kind: "bus_stop" };
+  if (aeroway) return { category: "transport", kind: aeroway };
+  if (office)
+    return {
+      category: office === "government" ? "public_service" : "other",
+      kind: `office:${office}`
+    };
+  return { category: "other" };
+}
+var CATEGORY_LABELS = {
+  food: "Food & drink",
+  grocery: "Groceries",
+  shopping: "Shopping",
+  healthcare: "Healthcare",
+  education: "Education",
+  finance: "Money",
+  transport: "Transport",
+  fuel: "Fuel & charging",
+  parking: "Parking",
+  accommodation: "Accommodation",
+  leisure: "Leisure",
+  tourism: "Tourism",
+  worship: "Places of worship",
+  public_service: "Public services",
+  utility: "Utilities",
+  other: "Other"
+};
+function isCategory(value) {
+  return CATEGORIES.includes(value);
+}
+
+// src/taxonomy.ts
+var a = (value) => ({ key: "amenity", value });
+var shop = (value) => ({ key: "shop", value });
+var leisure = (value) => ({ key: "leisure", value });
+var tourism = (value) => ({ key: "tourism", value });
+var rx = (key, value) => ({ key, value, regex: true });
+var present = (key) => ({ key });
+var TERMS = [
+  // food
+  {
+    term: "food",
+    category: "food",
+    selectors: [a("restaurant"), a("cafe"), a("fast_food"), a("bar"), a("pub"), a("food_court")],
+    synonyms: ["food and drink", "places to eat", "eat", "dining", "somewhere to eat"]
+  },
+  { term: "restaurant", category: "food", selectors: [a("restaurant")], synonyms: ["restaurants"] },
+  { term: "cafe", category: "food", selectors: [a("cafe")], synonyms: ["caf\xE9", "cafes"] },
+  {
+    term: "coffee",
+    category: "food",
+    selectors: [a("cafe"), rx("cuisine", "coffee_shop"), shop("coffee")],
+    synonyms: ["coffee shop", "coffeehouse"]
+  },
+  {
+    term: "fast food",
+    category: "food",
+    selectors: [a("fast_food")],
+    synonyms: ["fastfood", "takeaway food"]
+  },
+  { term: "bar", category: "food", selectors: [a("bar")], synonyms: ["bars"] },
+  { term: "pub", category: "food", selectors: [a("pub")], synonyms: ["pubs"] },
+  { term: "pizza", category: "food", selectors: [rx("cuisine", "pizza")], synonyms: ["pizzeria"] },
+  { term: "ice cream", category: "food", selectors: [a("ice_cream")], synonyms: ["gelato"] },
+  // grocery
+  {
+    term: "grocery",
+    category: "grocery",
+    selectors: [shop("supermarket"), shop("convenience"), shop("greengrocer"), shop("grocery")],
+    synonyms: ["groceries", "grocery store", "food shopping"]
+  },
+  { term: "supermarket", category: "grocery", selectors: [shop("supermarket")] },
+  {
+    term: "convenience",
+    category: "grocery",
+    selectors: [shop("convenience")],
+    synonyms: ["convenience store", "corner shop"]
+  },
+  { term: "bakery", category: "grocery", selectors: [shop("bakery")], synonyms: ["baker"] },
+  // shopping
+  {
+    term: "shopping",
+    category: "shopping",
+    selectors: [present("shop")],
+    synonyms: ["shops", "stores", "retail"]
+  },
+  {
+    term: "mall",
+    category: "shopping",
+    selectors: [shop("mall"), shop("department_store")],
+    synonyms: ["shopping mall", "shopping centre", "shopping center"]
+  },
+  {
+    term: "clothes",
+    category: "shopping",
+    selectors: [shop("clothes")],
+    synonyms: ["clothing", "fashion"]
+  },
+  // healthcare
+  {
+    term: "healthcare",
+    category: "healthcare",
+    selectors: [
+      a("hospital"),
+      a("clinic"),
+      a("doctors"),
+      a("dentist"),
+      a("pharmacy"),
+      present("healthcare")
+    ],
+    synonyms: ["health", "medical", "health care"]
+  },
+  {
+    term: "pharmacy",
+    category: "healthcare",
+    selectors: [a("pharmacy"), rx("healthcare", "pharmacy")],
+    synonyms: ["chemist", "drugstore", "drug store"]
+  },
+  {
+    term: "hospital",
+    category: "healthcare",
+    selectors: [a("hospital")],
+    synonyms: ["hospitals", "emergency room", "a&e"]
+  },
+  { term: "clinic", category: "healthcare", selectors: [a("clinic"), rx("healthcare", "clinic")] },
+  {
+    term: "doctor",
+    category: "healthcare",
+    selectors: [a("doctors"), rx("healthcare", "doctor")],
+    synonyms: ["doctors", "gp", "physician"]
+  },
+  {
+    term: "dentist",
+    category: "healthcare",
+    selectors: [a("dentist"), rx("healthcare", "dentist")],
+    synonyms: ["dental"]
+  },
+  // education
+  {
+    term: "education",
+    category: "education",
+    selectors: [a("school"), a("college"), a("university"), a("kindergarten"), a("library")],
+    synonyms: ["schools"]
+  },
+  { term: "school", category: "education", selectors: [a("school")] },
+  {
+    term: "university",
+    category: "education",
+    selectors: [a("university"), a("college")],
+    synonyms: ["college", "uni"]
+  },
+  { term: "library", category: "education", selectors: [a("library")], synonyms: ["libraries"] },
+  // finance
+  {
+    term: "finance",
+    category: "finance",
+    selectors: [a("bank"), a("atm"), a("bureau_de_change")],
+    synonyms: ["money", "banking"]
+  },
+  {
+    term: "atm",
+    category: "finance",
+    selectors: [a("atm")],
+    synonyms: ["cash machine", "cashpoint"]
+  },
+  { term: "bank", category: "finance", selectors: [a("bank")], synonyms: ["banks"] },
+  // transport
+  {
+    term: "transport",
+    category: "transport",
+    selectors: [
+      a("bus_station"),
+      { key: "public_transport", value: "station" },
+      rx("railway", "station|halt|tram_stop|subway_entrance|stop"),
+      { key: "highway", value: "bus_stop" },
+      { key: "aeroway", value: "aerodrome" }
+    ],
+    synonyms: ["public transport", "transit"]
+  },
+  {
+    term: "bus stop",
+    category: "transport",
+    selectors: [{ key: "highway", value: "bus_stop" }, a("bus_station")],
+    synonyms: ["bus", "bus station"]
+  },
+  {
+    term: "train station",
+    category: "transport",
+    selectors: [rx("railway", "station|halt"), { key: "public_transport", value: "station" }],
+    synonyms: ["railway station", "train", "metro", "metro station", "subway", "subway station"]
+  },
+  { term: "taxi", category: "transport", selectors: [a("taxi")] },
+  {
+    term: "airport",
+    category: "transport",
+    selectors: [{ key: "aeroway", value: "aerodrome" }],
+    synonyms: ["airports"]
+  },
+  // fuel
+  {
+    term: "fuel",
+    category: "fuel",
+    selectors: [a("fuel"), a("charging_station")],
+    synonyms: ["petrol", "gas", "gas station", "petrol station", "filling station"]
+  },
+  {
+    term: "ev charging",
+    category: "fuel",
+    selectors: [a("charging_station")],
+    synonyms: ["charging station", "ev charger", "charger"]
+  },
+  // parking
+  {
+    term: "parking",
+    category: "parking",
+    selectors: [a("parking")],
+    synonyms: ["car park", "parking lot"]
+  },
+  {
+    term: "bicycle parking",
+    category: "parking",
+    selectors: [a("bicycle_parking")],
+    synonyms: ["bike parking"]
+  },
+  // accommodation
+  {
+    term: "accommodation",
+    category: "accommodation",
+    selectors: [tourism("hotel"), tourism("hostel"), tourism("guest_house"), tourism("motel")],
+    synonyms: ["lodging", "places to stay", "stay"]
+  },
+  { term: "hotel", category: "accommodation", selectors: [tourism("hotel")], synonyms: ["hotels"] },
+  { term: "hostel", category: "accommodation", selectors: [tourism("hostel")] },
+  // leisure
+  {
+    term: "leisure",
+    category: "leisure",
+    selectors: [present("leisure")],
+    synonyms: ["recreation"]
+  },
+  { term: "park", category: "leisure", selectors: [leisure("park")], synonyms: ["parks"] },
+  {
+    term: "gym",
+    category: "leisure",
+    selectors: [leisure("fitness_centre"), leisure("sports_centre")],
+    synonyms: ["fitness", "fitness centre", "gymnasium"]
+  },
+  {
+    term: "cinema",
+    category: "leisure",
+    selectors: [a("cinema")],
+    synonyms: ["movie theater", "movie theatre", "movies"]
+  },
+  { term: "playground", category: "leisure", selectors: [leisure("playground")] },
+  // tourism
+  {
+    term: "tourism",
+    category: "tourism",
+    selectors: [present("tourism")],
+    synonyms: ["attractions", "sights", "things to do"]
+  },
+  { term: "museum", category: "tourism", selectors: [tourism("museum")], synonyms: ["museums"] },
+  { term: "viewpoint", category: "tourism", selectors: [tourism("viewpoint")] },
+  // worship
+  {
+    term: "worship",
+    category: "worship",
+    selectors: [a("place_of_worship")],
+    synonyms: ["place of worship", "church", "mosque", "temple", "synagogue"]
+  },
+  // public_service
+  {
+    term: "public_service",
+    category: "public_service",
+    selectors: [a("police"), a("fire_station"), a("post_office"), a("townhall")],
+    synonyms: ["public services", "government", "civic"]
+  },
+  {
+    term: "police",
+    category: "public_service",
+    selectors: [a("police")],
+    synonyms: ["police station"]
+  },
+  {
+    term: "post office",
+    category: "public_service",
+    selectors: [a("post_office")],
+    synonyms: ["postal"]
+  },
+  { term: "fire station", category: "public_service", selectors: [a("fire_station")] },
+  // utility
+  {
+    term: "utility",
+    category: "utility",
+    selectors: [a("toilets"), a("drinking_water"), a("recycling"), a("post_box")],
+    synonyms: ["utilities"]
+  },
+  {
+    term: "toilets",
+    category: "utility",
+    selectors: [a("toilets")],
+    synonyms: ["toilet", "restroom", "restrooms", "wc", "public toilet", "bathroom"]
+  },
+  {
+    term: "drinking water",
+    category: "utility",
+    selectors: [a("drinking_water")],
+    synonyms: ["water fountain", "water point"]
+  },
+  // other (catch-all; not directly queryable)
+  { term: "other", category: "other", selectors: [] }
+];
+var normalize = (term) => term.trim().toLowerCase().replace(/\s+/g, " ");
+var TERM_INDEX = /* @__PURE__ */ new Map();
+for (const def of TERMS) {
+  TERM_INDEX.set(normalize(def.term), def);
+  for (const synonym of def.synonyms ?? []) TERM_INDEX.set(normalize(synonym), def);
+}
+var selectorKey = (s) => `${s.key}|${s.value ?? ""}|${s.regex ? 1 : 0}`;
+function resolveCategories(terms) {
+  const selectors = [];
+  const seen = /* @__PURE__ */ new Set();
+  const matched = [];
+  const unknown = [];
+  for (const input of terms) {
+    const def = TERM_INDEX.get(normalize(input));
+    if (!def) {
+      unknown.push(input);
+      continue;
+    }
+    matched.push({ input, term: def.term, category: def.category });
+    for (const selector of def.selectors) {
+      const key = selectorKey(selector);
+      if (!seen.has(key)) {
+        seen.add(key);
+        selectors.push(selector);
+      }
+    }
+  }
+  return { selectors, matched, unknown };
+}
+function isKnownTerm(term) {
+  return TERM_INDEX.has(normalize(term));
+}
+function categoryVocabulary() {
+  return TERMS.map(({ term, category }) => ({ term, category }));
+}
+function editDistance(a2, b) {
+  const m = a2.length;
+  const n = b.length;
+  const row = Array.from({ length: n + 1 }, (_, i) => i);
+  for (let i = 1; i <= m; i++) {
+    let prev = row[0];
+    row[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const temp = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a2[i - 1] === b[j - 1] ? 0 : 1));
+      prev = temp;
+    }
+  }
+  return row[n];
+}
+function suggestCategories(term, limit = 5) {
+  const query = normalize(term);
+  const scored = [];
+  for (const def of TERMS) {
+    const candidates = [def.term, ...def.synonyms ?? []].map(normalize);
+    let best = Infinity;
+    for (const candidate of candidates) {
+      if (candidate.includes(query) || query.includes(candidate)) best = Math.min(best, 0);
+      else best = Math.min(best, editDistance(query, candidate));
+    }
+    if (best <= 2) scored.push({ term: def.term, score: best });
+  }
+  scored.sort((x, y) => x.score - y.score || x.term.localeCompare(y.term));
+  return scored.slice(0, limit).map((s) => s.term);
+}
+function selectorToOverpassFilter(selector) {
+  if (selector.value === void 0) return `["${selector.key}"]`;
+  const op = selector.regex ? "~" : "=";
+  return `["${selector.key}"${op}"${selector.value}"]`;
+}
+function tagsMatchSelector(tags, selector) {
+  const value = tags[selector.key];
+  if (value === void 0) return false;
+  if (selector.value === void 0) return true;
+  return selector.regex ? new RegExp(selector.value).test(value) : value === selector.value;
+}
+function tagsMatchAnySelector(tags, selectors) {
+  return selectors.some((selector) => tagsMatchSelector(tags, selector));
+}
+
+// src/quality.ts
+var BASE_EXPECTED = ["name"];
+var EXPECTED_BY_CATEGORY = {
+  food: ["name", "opening_hours", "cuisine", "website", "phone", "wheelchair"],
+  grocery: ["name", "opening_hours", "website", "phone"],
+  shopping: ["name", "opening_hours", "website", "phone"],
+  healthcare: ["name", "opening_hours", "phone", "website", "wheelchair"],
+  education: ["name", "website", "phone"],
+  finance: ["name", "opening_hours", "operator"],
+  transport: ["name", "network", "operator"],
+  fuel: ["name", "opening_hours", "operator"],
+  parking: ["capacity", "fee", "access"],
+  accommodation: ["name", "website", "phone", "stars"],
+  leisure: ["name", "opening_hours"],
+  tourism: ["name", "website", "opening_hours"],
+  worship: ["name", "religion"],
+  public_service: ["name", "opening_hours", "phone"],
+  utility: ["fee", "access"],
+  other: ["name"]
+};
+function completenessOf(category, tags) {
+  const expected = EXPECTED_BY_CATEGORY[category] ?? BASE_EXPECTED;
+  if (expected.length === 0) return 1;
+  const present2 = expected.filter((key) => {
+    const value = tags[key];
+    return value !== void 0 && value.trim() !== "";
+  }).length;
+  return Math.round(present2 / expected.length * 100) / 100;
+}
+var DATE_TAGS = ["check_date", "check_date:opening_hours", "survey:date"];
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}/;
+function lastVerifiedOf(tags, timestamp) {
+  for (const key of DATE_TAGS) {
+    const value = tags[key];
+    if (value && ISO_DATE.test(value)) return value.slice(0, 10);
+  }
+  if (timestamp && ISO_DATE.test(timestamp)) return timestamp.slice(0, 10);
+  return void 0;
+}
+var normalizeName = (poi) => (poi.name ?? "").trim().toLowerCase();
+function isDuplicate(a2, b) {
+  if (a2.category !== b.category) return false;
+  const distance = haversineMeters(a2.location, b.location);
+  if (distance > 40) return false;
+  const an = normalizeName(a2);
+  const bn = normalizeName(b);
+  if (an && bn) return an === bn;
+  return distance <= 15 && a2.kind === b.kind;
+}
+function richness(poi) {
+  let score = 0;
+  if (poi.name) score += 100;
+  score += (poi.completeness ?? 0) * 10;
+  if (poi.id.startsWith("way/") || poi.id.startsWith("relation/")) score += 1;
+  return score;
+}
+function dedupePois(pois) {
+  const kept = [];
+  for (const poi of pois) {
+    const index = kept.findIndex((other) => isDuplicate(other, poi));
+    if (index === -1) kept.push(poi);
+    else if (richness(poi) > richness(kept[index])) kept[index] = poi;
+  }
+  return kept;
+}
+
+// src/hours.ts
+function isOpenAt(openingHours, when) {
+  const raw = (openingHours ?? "").trim();
+  if (!raw) return { state: "unknown" };
+  const lower = raw.toLowerCase();
+  if (/^24\s*\/\s*7$/.test(lower) || lower === "24/7") return { state: "open" };
+  if (lower === "off" || lower === "closed") return { state: "closed" };
+  if (hasUnsupported(lower)) return { state: "unknown" };
+  const segments = buildSegments(lower);
+  if (!segments) return { state: "unknown" };
+  const day = when.getDay();
+  const minute = when.getHours() * 60 + when.getMinutes();
+  const open = isOpenInSegments(segments, day, minute);
+  const evaluation = { state: open ? "open" : "closed" };
+  const next = nextChange(segments, when, open);
+  if (next) evaluation.nextChange = next;
+  return evaluation;
+}
+var DAY_INDEX = { su: 0, mo: 1, tu: 2, we: 3, th: 4, fr: 5, sa: 6 };
+var WEEK_ORDER = ["mo", "tu", "we", "th", "fr", "sa", "su"];
+var MONTHS = /\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\b/;
+function hasUnsupported(s) {
+  return /sunrise|sunset|dawn|dusk|easter|\bweek\b/.test(s) || /\+/.test(s) || // open-ended times like 08:00+
+  /\b\d{4}\b/.test(s) || // explicit years
+  MONTHS.test(s);
+}
+function buildSegments(input) {
+  const own = new Array(7).fill(void 0);
+  for (const rulePart of input.split(";")) {
+    const rule = rulePart.trim();
+    if (!rule) continue;
+    const parsed = parseRule(rule.replace(/\s*([,:\-])\s*/g, "$1"));
+    if (parsed === "unknown") return null;
+    if (parsed === null) continue;
+    for (const day of parsed.days) own[day] = parsed.intervals;
+  }
+  const segments = Array.from({ length: 7 }, () => []);
+  for (let day = 0; day < 7; day++) {
+    const intervals = own[day];
+    if (!intervals) continue;
+    for (const [start, end] of intervals) {
+      if (start === end)
+        segments[day].push([0, 1440]);
+      else if (end > start) segments[day].push([start, end]);
+      else {
+        segments[day].push([start, 1440]);
+        segments[(day + 1) % 7].push([0, end]);
+      }
+    }
+  }
+  return segments;
+}
+function parseRule(rule) {
+  let dayPart;
+  let timePart;
+  const space = rule.indexOf(" ");
+  if (space === -1) {
+    if (/\d/.test(rule)) {
+      dayPart = "";
+      timePart = rule;
+    } else if (rule === "off" || rule === "closed") {
+      dayPart = "";
+      timePart = rule;
+    } else {
+      dayPart = rule;
+      timePart = "";
+    }
+  } else {
+    dayPart = rule.slice(0, space);
+    timePart = rule.slice(space + 1).trim();
+  }
+  const days = parseDays(dayPart);
+  if (days === "unknown") return "unknown";
+  if (days === null) return null;
+  if (timePart === "") return { days, intervals: [[0, 1440]] };
+  if (timePart === "off" || timePart === "closed") return { days, intervals: [] };
+  const intervals = parseTimes(timePart);
+  if (!intervals) return "unknown";
+  return { days, intervals };
+}
+function parseDays(part) {
+  if (part === "") return [0, 1, 2, 3, 4, 5, 6];
+  const days = /* @__PURE__ */ new Set();
+  let sawReal = false;
+  let sawHoliday = false;
+  for (const token of part.split(",")) {
+    if (token === "ph" || token === "sh") {
+      sawHoliday = true;
+      continue;
+    }
+    const match = token.match(/^([a-z]{2})(?:-([a-z]{2}))?$/);
+    if (!match) return "unknown";
+    const from = match[1];
+    if (!(from in DAY_INDEX)) return "unknown";
+    if (match[2] === void 0) {
+      days.add(DAY_INDEX[from]);
+      sawReal = true;
+    } else {
+      const to = match[2];
+      if (!(to in DAY_INDEX)) return "unknown";
+      addWeekdayRange(days, from, to);
+      sawReal = true;
+    }
+  }
+  if (!sawReal) return sawHoliday ? null : "unknown";
+  return [...days];
+}
+function addWeekdayRange(set, from, to) {
+  let i = WEEK_ORDER.indexOf(from);
+  const end = WEEK_ORDER.indexOf(to);
+  for (; ; ) {
+    set.add(DAY_INDEX[WEEK_ORDER[i]]);
+    if (i === end) break;
+    i = (i + 1) % 7;
+  }
+}
+function parseTimes(part) {
+  const intervals = [];
+  for (const piece of part.split(",")) {
+    const match = piece.match(/^(\d{1,2}):(\d{2})-(\d{1,2}):(\d{2})$/);
+    if (!match) return null;
+    const h1 = Number(match[1]);
+    const m1 = Number(match[2]);
+    const h2 = Number(match[3]);
+    const m2 = Number(match[4]);
+    if (h1 > 24 || h2 > 24 || m1 > 59 || m2 > 59) return null;
+    intervals.push([h1 * 60 + m1, h2 * 60 + m2]);
+  }
+  return intervals;
+}
+function isOpenInSegments(segments, day, minute) {
+  return segments[day].some(([start, end]) => minute >= start && minute < end);
+}
+function nextChange(segments, when, currentlyOpen) {
+  const nowMinute = when.getHours() * 60 + when.getMinutes();
+  const baseDay = when.getDay();
+  const candidates = [];
+  for (let offset = 0; offset <= 8; offset++) {
+    const day = (baseDay + offset) % 7;
+    for (const [start, end] of segments[day]) {
+      candidates.push(offset * 1440 + start, offset * 1440 + end);
+    }
+  }
+  candidates.sort((a2, b) => a2 - b);
+  for (const candidate of candidates) {
+    if (candidate <= nowMinute) continue;
+    const day = (baseDay + Math.floor(candidate / 1440)) % 7;
+    const open = isOpenInSegments(segments, day, candidate % 1440);
+    if (open !== currentlyOpen) {
+      const midnight = new Date(when.getFullYear(), when.getMonth(), when.getDate(), 0, 0, 0, 0);
+      return new Date(midnight.getTime() + candidate * 6e4).toISOString();
+    }
+  }
+  return void 0;
+}
+
+// src/http.ts
+var DEFAULT_USER_AGENT = "proximap/0.1 (+https://github.com/AmeyaBorkar/proximap)";
+var InMemoryCache = class {
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.store.get(key);
+  }
+  set(key, value) {
+    this.store.set(key, value);
+  }
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var RateLimiter = class {
+  constructor(minIntervalMs) {
+    this.minIntervalMs = minIntervalMs;
+  }
+  minIntervalMs;
+  last = 0;
+  chain = Promise.resolve();
+  acquire() {
+    this.chain = this.chain.then(async () => {
+      if (this.minIntervalMs <= 0) return;
+      const wait = this.last + this.minIntervalMs - Date.now();
+      if (wait > 0) await sleep(wait);
+      this.last = Date.now();
+    });
+    return this.chain;
+  }
+};
+var HttpError = class extends Error {
+  constructor(status, url, message) {
+    super(message);
+    this.status = status;
+    this.url = url;
+    this.name = "HttpError";
+  }
+  status;
+  url;
+};
+function isRetryable(error) {
+  if (error instanceof HttpError) {
+    return error.status === 0 || error.status === 429 || error.status >= 500;
+  }
+  if (error instanceof Error && error.name === "AbortError") return false;
+  return true;
+}
+async function fetchJsonOnce(url, options) {
+  const { method = "GET", headers = {}, body, signal, timeoutMs = 2e4 } = options;
+  const timeout = AbortSignal.timeout(timeoutMs);
+  const composite = signal ? AbortSignal.any([signal, timeout]) : timeout;
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers: { "User-Agent": DEFAULT_USER_AGENT, Accept: "application/json", ...headers },
+      ...body === void 0 ? {} : { body },
+      signal: composite
+    });
+  } catch (error) {
+    if (timeout.aborted) throw new HttpError(0, url, `Request timed out after ${timeoutMs} ms`);
+    throw error;
+  }
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new HttpError(
+      response.status,
+      url,
+      `${response.status} ${response.statusText}: ${detail.slice(0, 200)}`.trim()
+    );
+  }
+  return await response.json();
+}
+async function requestJson(url, options = {}) {
+  const { method = "GET", body, retries = 0, retryDelayMs = 500, cache } = options;
+  const cacheKey = cache ? `${method} ${url} ${body ?? ""}` : void 0;
+  if (cache && cacheKey !== void 0) {
+    const cached = await cache.get(cacheKey);
+    if (cached !== void 0) return cached;
+  }
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    if (attempt > 0) await sleep(retryDelayMs * 2 ** (attempt - 1));
+    try {
+      const value = await fetchJsonOnce(url, options);
+      if (cache && cacheKey !== void 0) await cache.set(cacheKey, value);
+      return value;
+    } catch (error) {
+      lastError = error;
+      if (attempt === retries || !isRetryable(error)) throw error;
+    }
+  }
+  throw lastError;
+}
+
+// src/providers/nominatim.ts
+var NominatimGeocoder = class {
+  name = "nominatim";
+  endpoint;
+  userAgent;
+  timeoutMs;
+  retries;
+  cache;
+  limiter;
+  constructor(options = {}) {
+    this.endpoint = (options.endpoint ?? "https://nominatim.openstreetmap.org").replace(/\/+$/, "");
+    this.userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+    this.timeoutMs = options.timeoutMs;
+    this.retries = options.retries ?? 2;
+    this.cache = options.cache;
+    this.limiter = new RateLimiter(options.minIntervalMs ?? 1e3);
+  }
+  async geocode(query, options = {}) {
+    const params = new URLSearchParams({
+      q: query,
+      format: "jsonv2",
+      limit: String(options.limit ?? 5)
+    });
+    if (options.language) params.set("accept-language", options.language);
+    const results = await this.request(`/search?${params}`, options.signal);
+    return results.map((result) => this.toPlace(result));
+  }
+  async reverse(location, options = {}) {
+    const params = new URLSearchParams({
+      lat: String(location.lat),
+      lon: String(location.lng),
+      format: "jsonv2"
+    });
+    if (options.language) params.set("accept-language", options.language);
+    const result = await this.request(
+      `/reverse?${params}`,
+      options.signal
+    );
+    if (!result || "error" in result) return null;
+    return this.toPlace(result);
+  }
+  async request(path, signal) {
+    await this.limiter.acquire();
+    return requestJson(`${this.endpoint}${path}`, {
+      headers: { "User-Agent": this.userAgent },
+      retries: this.retries,
+      ...this.cache ? { cache: this.cache } : {},
+      ...signal ? { signal } : {},
+      ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {}
+    });
+  }
+  toPlace(result) {
+    const fallbackName = result.display_name.split(",")[0]?.trim() ?? result.display_name;
+    const place = {
+      name: result.name && result.name.length > 0 ? result.name : fallbackName,
+      displayName: result.display_name,
+      location: { lat: Number(result.lat), lng: Number(result.lon) },
+      source: this.name,
+      raw: result
+    };
+    const kind = result.type ?? result.class;
+    if (kind) place.kind = kind;
+    if (result.boundingbox) {
+      const [s, n, w, e] = result.boundingbox;
+      place.boundingBox = [Number(s), Number(n), Number(w), Number(e)];
+    }
+    return place;
+  }
+};
+
+// src/providers/overpass.ts
+var SELECTORS = [
+  'nwr["amenity"]',
+  'nwr["shop"]',
+  'nwr["tourism"]',
+  'nwr["leisure"]',
+  'nwr["healthcare"]',
+  'nwr["office"="government"]',
+  'nwr["railway"~"^(station|halt|tram_stop|subway_entrance|stop)$"]',
+  'nwr["public_transport"="station"]',
+  'node["highway"="bus_stop"]',
+  'nwr["aeroway"="aerodrome"]'
+];
+function buildOverpassQuery(center, radiusMeters) {
+  const around = `around:${Math.max(1, Math.round(radiusMeters))},${center.lat},${center.lng}`;
+  const body = SELECTORS.map((selector) => `  ${selector}(${around});`).join("\n");
+  return `[out:json][timeout:25];
+(
+${body}
+);
+out center tags meta;`;
+}
+function buildTargetedOverpassQuery(center, radiusMeters, selectors) {
+  const around = `around:${Math.max(1, Math.round(radiusMeters))},${center.lat},${center.lng}`;
+  const body = selectors.map((selector) => `  nwr${selectorToOverpassFilter(selector)}(${around});`).join("\n");
+  return `[out:json][timeout:25];
+(
+${body}
+);
+out center tags meta;`;
+}
+function coordOf(lat, lon) {
+  if (typeof lat === "number" && typeof lon === "number" && Number.isFinite(lat) && Number.isFinite(lon)) {
+    return { lat, lng: lon };
+  }
+  return null;
+}
+var OverpassPlacesProvider = class {
+  name = "overpass";
+  endpoint;
+  userAgent;
+  timeoutMs;
+  retries;
+  cache;
+  limiter;
+  constructor(options = {}) {
+    this.endpoint = options.endpoint ?? "https://overpass-api.de/api/interpreter";
+    this.userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+    this.retries = options.retries ?? 2;
+    this.cache = options.cache;
+    this.limiter = new RateLimiter(options.minIntervalMs ?? 1e3);
+  }
+  async findNearby(center, options) {
+    const query = options.selectors && options.selectors.length > 0 ? buildTargetedOverpassQuery(center, options.radiusMeters, options.selectors) : buildOverpassQuery(center, options.radiusMeters);
+    await this.limiter.acquire();
+    const data = await requestJson(this.endpoint, {
+      method: "POST",
+      headers: {
+        "User-Agent": this.userAgent,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: `data=${encodeURIComponent(query)}`,
+      timeoutMs: this.timeoutMs,
+      retries: this.retries,
+      ...this.cache ? { cache: this.cache } : {},
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    if (data.remark && /error|timed out|rate_limited|too many|memory/i.test(data.remark)) {
+      throw new HttpError(0, this.endpoint, `Overpass: ${data.remark}`);
+    }
+    const wanted = options.categories ? new Set(options.categories) : null;
+    const pois = [];
+    for (const element of data.elements ?? []) {
+      const poi = this.toPoi(element);
+      if (!poi) continue;
+      if (wanted && !wanted.has(poi.category)) continue;
+      pois.push(poi);
+    }
+    return dedupePois(pois);
+  }
+  toPoi(element) {
+    const tags = element.tags;
+    if (!tags) return null;
+    const coords = element.type === "node" ? coordOf(element.lat, element.lon) : element.center ? coordOf(element.center.lat, element.center.lon) : null;
+    if (!coords) return null;
+    const { category, kind } = categorize(tags);
+    const poi = {
+      id: `${element.type}/${element.id}`,
+      category,
+      location: coords,
+      tags,
+      source: this.name
+    };
+    if (tags.name) poi.name = tags.name;
+    if (kind) poi.kind = kind;
+    poi.completeness = completenessOf(category, tags);
+    const lastVerified = lastVerifiedOf(tags, element.timestamp);
+    if (lastVerified) poi.lastVerified = lastVerified;
+    return poi;
+  }
+};
+
+// src/providers/valhalla.ts
+var COSTING = {
+  walk: "pedestrian",
+  bike: "bicycle",
+  drive: "auto"
+};
+var ValhallaRoutingProvider = class {
+  name = "valhalla";
+  endpoint;
+  userAgent;
+  timeoutMs;
+  retries;
+  cache;
+  limiter;
+  constructor(options = {}) {
+    this.endpoint = (options.endpoint ?? "https://valhalla1.openstreetmap.de").replace(/\/+$/, "");
+    this.userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+    this.timeoutMs = options.timeoutMs;
+    this.retries = options.retries ?? 1;
+    this.cache = options.cache;
+    this.limiter = new RateLimiter(options.minIntervalMs ?? 1e3);
+  }
+  async matrix(origin, targets, mode, options = {}) {
+    if (targets.length === 0) return [];
+    const body = JSON.stringify({
+      sources: [{ lat: origin.lat, lon: origin.lng }],
+      targets: targets.map((target) => ({ lat: target.lat, lon: target.lng })),
+      costing: COSTING[mode]
+    });
+    const data = await this.post("/sources_to_targets", body, options.signal);
+    if (data.error) throw new HttpError(0, this.endpoint, `Valhalla: ${data.error}`);
+    const row = data.sources_to_targets?.[0] ?? [];
+    const metrics = targets.map(() => null);
+    for (const cell of row) {
+      if (cell.time === null || cell.distance === null) continue;
+      if (cell.to_index < 0 || cell.to_index >= metrics.length) continue;
+      metrics[cell.to_index] = {
+        seconds: Math.round(cell.time),
+        meters: Math.round(cell.distance * 1e3)
+      };
+    }
+    return metrics;
+  }
+  async isochrone(origin, minutes, mode, options = {}) {
+    const body = JSON.stringify({
+      locations: [{ lat: origin.lat, lon: origin.lng }],
+      costing: COSTING[mode],
+      contours: [{ time: minutes }],
+      polygons: true
+    });
+    const data = await this.post("/isochrone", body, options.signal);
+    if (data.error) throw new HttpError(0, this.endpoint, `Valhalla: ${data.error}`);
+    const ring = extractRing(data.features ?? []);
+    if (!ring) throw new HttpError(0, this.endpoint, "Valhalla: no isochrone polygon returned");
+    return ring;
+  }
+  async post(path, body, signal) {
+    await this.limiter.acquire();
+    return requestJson(`${this.endpoint}${path}`, {
+      method: "POST",
+      headers: { "User-Agent": this.userAgent, "Content-Type": "application/json" },
+      body,
+      retries: this.retries,
+      ...this.cache ? { cache: this.cache } : {},
+      ...signal ? { signal } : {},
+      ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {}
+    });
+  }
+};
+function extractRing(features) {
+  for (const feature of features) {
+    const geometry = feature.geometry;
+    if (!geometry) continue;
+    const coords = geometry.coordinates;
+    if (geometry.type === "LineString" && isRing(coords)) return coords;
+    if (geometry.type === "Polygon" && Array.isArray(coords) && isRing(coords[0])) {
+      return coords[0];
+    }
+    if (geometry.type === "MultiPolygon" && Array.isArray(coords) && Array.isArray(coords[0]) && isRing(coords[0][0])) {
+      return coords[0][0];
+    }
+  }
+  return null;
+}
+function isRing(value) {
+  return Array.isArray(value) && value.length >= 3 && value.every(
+    (point) => Array.isArray(point) && point.length >= 2 && typeof point[0] === "number" && typeof point[1] === "number"
+  );
+}
+
+// src/providers/osrm.ts
+var PROFILE = { walk: "foot", bike: "bike", drive: "driving" };
+var OsrmRoutingProvider = class {
+  name = "osrm";
+  endpoint;
+  userAgent;
+  timeoutMs;
+  retries;
+  cache;
+  limiter;
+  constructor(options = {}) {
+    this.endpoint = (options.endpoint ?? "https://router.project-osrm.org").replace(/\/+$/, "");
+    this.userAgent = options.userAgent ?? DEFAULT_USER_AGENT;
+    this.timeoutMs = options.timeoutMs;
+    this.retries = options.retries ?? 1;
+    this.cache = options.cache;
+    this.limiter = new RateLimiter(options.minIntervalMs ?? 1e3);
+  }
+  async matrix(origin, targets, mode, options = {}) {
+    if (targets.length === 0) return [];
+    const coordinates = [origin, ...targets].map((c) => `${c.lng},${c.lat}`).join(";");
+    const params = new URLSearchParams({ sources: "0", annotations: "duration,distance" });
+    const url = `${this.endpoint}/table/v1/${PROFILE[mode]}/${coordinates}?${params}`;
+    await this.limiter.acquire();
+    const data = await requestJson(url, {
+      headers: { "User-Agent": this.userAgent },
+      retries: this.retries,
+      ...this.cache ? { cache: this.cache } : {},
+      ...options.signal ? { signal: options.signal } : {},
+      ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {}
+    });
+    const durations = data.durations?.[0] ?? [];
+    const distances = data.distances?.[0] ?? [];
+    return targets.map((_, index) => {
+      const seconds = durations[index + 1];
+      if (seconds === null || seconds === void 0) return null;
+      const meters = distances[index + 1];
+      return { seconds: Math.round(seconds), meters: meters == null ? 0 : Math.round(meters) };
+    });
+  }
+};
+
+// src/ranking.ts
+var clamp01 = (n) => Math.min(1, Math.max(0, n));
+function defaultScorer(weights) {
+  return ({ poi, distanceMeters, radiusMeters }) => {
+    const proximity = 1 - clamp01(distanceMeters / radiusMeters);
+    const completeness = poi.name ? 0.05 : 0;
+    const weight = weights?.[poi.category] ?? 1;
+    return (proximity + completeness) * weight;
+  };
+}
+function rankByProximity(origin, pois, options = {}) {
+  if (pois.length === 0) return [];
+  const measured = pois.map((poi) => ({
+    poi,
+    distanceMeters: haversineMeters(origin, poi.location)
+  }));
+  const maxDistance = measured.reduce((max, m) => Math.max(max, m.distanceMeters), 0);
+  const radiusMeters = options.radiusMeters ?? Math.max(maxDistance, 1);
+  const score = options.scoreFn ?? defaultScorer(options.categoryWeights);
+  const scored = measured.map(({ poi, distanceMeters }) => ({
+    poi,
+    distanceMeters,
+    score: clamp01(score({ poi, distanceMeters, radiusMeters }))
+  }));
+  const byScore = Boolean(options.scoreFn || options.categoryWeights);
+  scored.sort((a2, b) => {
+    const primary = byScore ? b.score - a2.score || a2.distanceMeters - b.distanceMeters : a2.distanceMeters - b.distanceMeters;
+    return primary || a2.poi.id.localeCompare(b.poi.id);
+  });
+  return scored.map((entry, index) => ({
+    ...entry.poi,
+    distanceMeters: entry.distanceMeters,
+    score: entry.score,
+    rank: index + 1
+  }));
+}
+
+// src/routing.ts
+var MODE_SPEED_MPS = { walk: 1.4, bike: 4.2, drive: 11.1 };
+var HaversineRoutingProvider = class {
+  name = "haversine";
+  async matrix(origin, targets, mode) {
+    const speed = MODE_SPEED_MPS[mode];
+    return targets.map((target) => {
+      const meters = haversineMeters(origin, target);
+      return { meters: Math.round(meters), seconds: Math.round(meters / speed) };
+    });
+  }
+  async isochrone(origin, minutes, mode) {
+    return circlePolygon(origin, MODE_SPEED_MPS[mode] * minutes * 60);
+  }
+};
+function circlePolygon(center, radiusMeters, steps = 48) {
+  const latDelta = radiusMeters / 111320;
+  const lngDelta = radiusMeters / (111320 * Math.cos(center.lat * Math.PI / 180));
+  const ring = [];
+  for (let i = 0; i <= steps; i++) {
+    const angle = 2 * Math.PI * i / steps;
+    ring.push([center.lng + lngDelta * Math.cos(angle), center.lat + latDelta * Math.sin(angle)]);
+  }
+  return ring;
+}
+function pointInPolygon(point, ring) {
+  const x = point.lng;
+  const y = point.lat;
+  let inside = false;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const a2 = ring[i];
+    const b = ring[j];
+    const intersect = a2[1] > y !== b[1] > y && x < (b[0] - a2[0]) * (y - a2[1]) / (b[1] - a2[1]) + a2[0];
+    if (intersect) inside = !inside;
+  }
+  return inside;
+}
+
+// src/filters.ts
+var toArray = (v) => v === void 0 ? [] : Array.isArray(v) ? v : [v];
+var YES_ONLY = /* @__PURE__ */ new Set(["yes", "only"]);
+var NEGATIVE = /* @__PURE__ */ new Set(["no", "false", "0", ""]);
+var isAffirmative = (value) => value !== void 0 && !NEGATIVE.has(value.trim().toLowerCase());
+var cuisineTokens = (tags) => (tags.cuisine ?? "").toLowerCase().split(";").map((s) => s.trim()).filter(Boolean);
+function compileFacets(filters) {
+  const preds = [];
+  for (const diet of toArray(filters.diet)) {
+    const key = `diet:${diet.toLowerCase()}`;
+    preds.push((t) => YES_ONLY.has((t[key] ?? "").toLowerCase()));
+  }
+  for (const cuisine of toArray(filters.cuisine)) {
+    const want = cuisine.toLowerCase();
+    preds.push((t) => cuisineTokens(t).includes(want));
+  }
+  for (const payment of toArray(filters.payment)) {
+    const key = `payment:${payment.toLowerCase()}`;
+    preds.push((t) => isAffirmative(t[key]));
+  }
+  if (filters.internetAccess) preds.push((t) => isAffirmative(t.internet_access));
+  if (filters.outdoorSeating) preds.push((t) => isAffirmative(t.outdoor_seating));
+  if (filters.takeaway) preds.push((t) => YES_ONLY.has((t.takeaway ?? "").toLowerCase()));
+  if (filters.delivery) preds.push((t) => isAffirmative(t.delivery));
+  const wheelchair = toArray(filters.wheelchair).map((v) => v.toLowerCase());
+  if (wheelchair.length > 0) {
+    preds.push((t) => wheelchair.includes((t.wheelchair ?? "").toLowerCase()));
+  }
+  for (const [key, value] of Object.entries(filters.tags ?? {})) {
+    if (value === true) preds.push((t) => t[key] !== void 0);
+    else if (value === false) preds.push((t) => t[key] === void 0);
+    else {
+      const want = String(value).toLowerCase();
+      preds.push((t) => (t[key] ?? "").toLowerCase() === want);
+    }
+  }
+  return preds;
+}
+function matchesFacets(tags, predicates) {
+  return predicates.every((predicate) => predicate(tags));
+}
+var clamp012 = (n) => Math.min(1, Math.max(0, n));
+function accessibleScorer() {
+  return ({ poi, distanceMeters, radiusMeters }) => {
+    const proximity = 1 - clamp012(distanceMeters / radiusMeters);
+    const wheelchair = (poi.tags.wheelchair ?? "").toLowerCase();
+    const tierBase = wheelchair === "yes" ? 0.66 : wheelchair === "limited" ? 0.33 : 0;
+    return tierBase + proximity * 0.33;
+  };
+}
+
+// src/origin.ts
+async function resolveOrigin(query, geocoder, options = {}) {
+  if (typeof query !== "string") return originFromCoords(query, geocoder, options);
+  const coords = parseCoordinates(query);
+  if (coords) return originFromCoords(coords, geocoder, options);
+  const matches = await geocoder.geocode(query, { limit: 1, ...geoOptions(options) });
+  const first = matches[0];
+  if (!first) throw new Error(`No location found for query: "${query}"`);
+  return first;
+}
+async function originFromCoords(coords, geocoder, options) {
+  const label = `${coords.lat}, ${coords.lng}`;
+  const fallback = {
+    name: label,
+    displayName: label,
+    location: coords,
+    source: "coordinates"
+  };
+  if (geocoder.reverse) {
+    try {
+      const reversed = await geocoder.reverse(coords, geoOptions(options));
+      if (reversed) return reversed;
+    } catch {
+    }
+  }
+  return fallback;
+}
+function geoOptions(options) {
+  const out = {};
+  if (options.language) out.language = options.language;
+  if (options.signal) out.signal = options.signal;
+  return out;
+}
+
+// src/disambiguate.ts
+var DISTINCT_KM = 25;
+var RIVAL_IMPORTANCE_RATIO = 0.8;
+async function disambiguateLocation(query, options = {}) {
+  const geocoder = options.geocoder ?? new NominatimGeocoder();
+  const limit = options.limit ?? 5;
+  const candidates = await geocoder.geocode(query, {
+    limit,
+    ...options.language ? { language: options.language } : {},
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  const best = candidates[0] ?? null;
+  return { query, ambiguous: isAmbiguous(candidates), best, candidates };
+}
+var importanceOf = (place) => {
+  const raw = place.raw;
+  return typeof raw?.importance === "number" ? raw.importance : 0;
+};
+var shortName = (place) => (place.name || place.displayName.split(",")[0] || "").trim().toLowerCase();
+function isAmbiguous(candidates) {
+  if (candidates.length < 2) return false;
+  const best = candidates[0];
+  const bestImportance = importanceOf(best);
+  const bestName = shortName(best);
+  return candidates.slice(1).some((rival) => {
+    const farApart = haversineMeters(best.location, rival.location) > DISTINCT_KM * 1e3;
+    if (!farApart) return false;
+    const comparablyRelevant = bestImportance > 0 && importanceOf(rival) >= bestImportance * RIVAL_IMPORTANCE_RATIO;
+    const sameName = bestName.length > 0 && shortName(rival) === bestName;
+    return comparablyRelevant || sameName;
+  });
+}
+
+// src/proximity.ts
+function nearestMatchingPoi(origin, pois, selectors) {
+  let bestMeters = null;
+  let bestPoi = null;
+  for (const poi of pois) {
+    if (!tagsMatchAnySelector(poi.tags, selectors)) continue;
+    const meters = haversineMeters(origin, poi.location);
+    if (bestMeters === null || meters < bestMeters) {
+      bestMeters = meters;
+      bestPoi = poi;
+    }
+  }
+  return { meters: bestMeters, poi: bestPoi };
+}
+
+// src/nearby.ts
+var DEFAULT_RADIUS_M = 1e3;
+var DEFAULT_LIMIT = 30;
+async function findNearbyAmenities(query, options = {}) {
+  const radiusMeters = options.radiusMeters ?? DEFAULT_RADIUS_M;
+  const geocoder = options.geocoder ?? new NominatimGeocoder();
+  const places = options.places ?? new OverpassPlacesProvider();
+  const selectors = resolveSelectors(options.categories);
+  const origin = await resolveOrigin(query, geocoder, {
+    language: options.language,
+    signal: options.signal
+  });
+  const nearbyOptions = { radiusMeters };
+  if (selectors.length > 0) nearbyOptions.selectors = selectors;
+  if (options.signal) nearbyOptions.signal = options.signal;
+  const found = await places.findNearby(origin.location, nearbyOptions);
+  let pois = selectors.length > 0 ? found.filter((poi) => tagsMatchAnySelector(poi.tags, selectors)) : found;
+  if (options.filters) {
+    const predicates = compileFacets(options.filters);
+    if (predicates.length > 0) pois = pois.filter((poi) => matchesFacets(poi.tags, predicates));
+  }
+  let openEval = null;
+  if (options.open) {
+    const when = options.open === "now" ? /* @__PURE__ */ new Date() : new Date(options.open.at);
+    openEval = /* @__PURE__ */ new Map();
+    pois = pois.filter((poi) => {
+      const evaluation = isOpenAt(poi.tags.opening_hours, when);
+      openEval.set(poi.id, evaluation);
+      return evaluation.state !== "closed";
+    });
+  }
+  let ranked;
+  let routingInfo;
+  if (options.rankBy === "travelTime") {
+    const outcome = await rankByTravelTime(origin.location, pois, {
+      mode: options.mode ?? "walk",
+      routing: options.routing ?? new HaversineRoutingProvider(),
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    ranked = outcome.ranked;
+    routingInfo = outcome.info;
+  } else {
+    const rankOptions = { radiusMeters, ...options.rank };
+    if (options.accessible && !rankOptions.scoreFn) rankOptions.scoreFn = accessibleScorer();
+    ranked = rankByProximity(origin.location, pois, rankOptions);
+  }
+  if (openEval) {
+    ranked = ranked.map((poi) => {
+      const evaluation = openEval.get(poi.id);
+      if (!evaluation) return poi;
+      const annotated = { ...poi, openState: evaluation.state };
+      if (evaluation.nextChange) annotated.nextChange = evaluation.nextChange;
+      return annotated;
+    });
+  }
+  if (options.explain) {
+    const mode = options.mode ?? "walk";
+    ranked = ranked.map((poi) => ({ ...poi, rankingReason: rankingReasonFor(poi, mode) }));
+  }
+  const limit = options.limit ?? DEFAULT_LIMIT;
+  const results = limit > 0 ? ranked.slice(0, limit) : ranked;
+  return {
+    origin,
+    results,
+    total: ranked.length,
+    ...routingInfo ? { routing: routingInfo } : {}
+  };
+}
+var MODE_ADVERB = {
+  walk: "on foot",
+  bike: "by bike",
+  drive: "by car"
+};
+function ordinalCloseness(rank) {
+  if (rank === 1) return "closest";
+  const mod100 = rank % 100;
+  const mod10 = rank % 10;
+  const suffix = mod10 === 1 && mod100 !== 11 ? "st" : mod10 === 2 && mod100 !== 12 ? "nd" : mod10 === 3 && mod100 !== 13 ? "rd" : "th";
+  return `${rank}${suffix}-closest`;
+}
+function rankingReasonFor(poi, mode) {
+  const what = poi.kind ?? CATEGORY_LABELS[poi.category].toLowerCase();
+  const openness = poi.openState === "open" ? "open " : "";
+  if (poi.travelSeconds !== void 0) {
+    return `${ordinalCloseness(poi.rank)} ${openness}${what} ${MODE_ADVERB[mode]}, ${formatDuration(poi.travelSeconds)}`;
+  }
+  return `${ordinalCloseness(poi.rank)} ${openness}${what}, ${formatDistance(poi.distanceMeters)}`;
+}
+var TRAVEL_MATRIX_CAP = 80;
+async function rankByTravelTime(origin, pois, options) {
+  const candidates = [...pois].sort((a2, b) => haversineMeters(origin, a2.location) - haversineMeters(origin, b.location)).slice(0, TRAVEL_MATRIX_CAP);
+  const points = candidates.map((poi) => poi.location);
+  const requestOptions = options.signal ? { signal: options.signal } : {};
+  let metrics;
+  let provider = options.routing.name;
+  let fellBack = false;
+  try {
+    metrics = await options.routing.matrix(origin, points, options.mode, requestOptions);
+  } catch (error) {
+    if (options.routing instanceof HaversineRoutingProvider) throw error;
+    const fallback = new HaversineRoutingProvider();
+    metrics = await fallback.matrix(origin, points, options.mode);
+    provider = fallback.name;
+    fellBack = true;
+  }
+  const reachable = candidates.map((poi, index) => ({ poi, metric: metrics[index] ?? null })).filter((entry) => entry.metric !== null).sort((a2, b) => a2.metric.seconds - b.metric.seconds);
+  const slowest = reachable.reduce((max, entry) => Math.max(max, entry.metric.seconds), 0) || 1;
+  const ranked = reachable.map((entry, index) => ({
+    ...entry.poi,
+    distanceMeters: haversineMeters(origin, entry.poi.location),
+    score: Math.round((1 - entry.metric.seconds / slowest) * 100) / 100,
+    rank: index + 1,
+    travelSeconds: entry.metric.seconds,
+    travelMeters: entry.metric.meters
+  }));
+  return { ranked, info: { provider, mode: options.mode, fellBack } };
+}
+function resolveSelectors(categories) {
+  if (!categories || categories.length === 0) return [];
+  const { selectors, unknown } = resolveCategories(categories);
+  if (unknown.length > 0) {
+    const detail = unknown.map((term) => {
+      const suggestions = suggestCategories(term);
+      return suggestions.length > 0 ? `"${term}" (did you mean: ${suggestions.join(", ")}?)` : `"${term}"`;
+    }).join("; ");
+    throw new Error(`Unknown categor${unknown.length > 1 ? "ies" : "y"}: ${detail}`);
+  }
+  return selectors;
+}
+
+// src/reachable.ts
+var MAX_FETCH_RADIUS_M = 15e3;
+var REACHABLE_MATRIX_CAP = 100;
+async function reachableAmenities(query, options) {
+  const withinMinutes = options.within;
+  if (!(withinMinutes > 0)) {
+    throw new Error("reachableAmenities needs a positive `within` (minutes).");
+  }
+  const mode = options.mode ?? "walk";
+  const routing = options.routing ?? new HaversineRoutingProvider();
+  const geocoder = options.geocoder ?? new NominatimGeocoder();
+  const places = options.places ?? new OverpassPlacesProvider();
+  const budgetSeconds = withinMinutes * 60;
+  const selectors = resolveSelectors2(options.categories);
+  const origin = await resolveOrigin(query, geocoder, {
+    language: options.language,
+    signal: options.signal
+  });
+  const fetchRadius = Math.min(
+    Math.round(MODE_SPEED_MPS[mode] * budgetSeconds),
+    MAX_FETCH_RADIUS_M
+  );
+  const nearbyOptions = { radiusMeters: fetchRadius };
+  if (selectors.length > 0) nearbyOptions.selectors = selectors;
+  if (options.signal) nearbyOptions.signal = options.signal;
+  const found = await places.findNearby(origin.location, nearbyOptions);
+  const pois = selectors.length > 0 ? found.filter((poi) => tagsMatchAnySelector(poi.tags, selectors)) : found;
+  const isochrone = await tryIsochrone(
+    routing,
+    origin.location,
+    withinMinutes,
+    mode,
+    options.signal
+  );
+  const candidates = isochrone ? pois.filter((poi) => pointInPolygon(poi.location, isochrone)) : pois;
+  const nearest = [...candidates].sort(
+    (a2, b) => haversineMeters(origin.location, a2.location) - haversineMeters(origin.location, b.location)
+  ).slice(0, REACHABLE_MATRIX_CAP);
+  const metrics = await safeMatrix(routing, origin.location, nearest, mode, options.signal);
+  const members = nearest.map((poi, index) => ({ poi, metric: metrics[index] ?? null })).filter((entry) => isochrone !== null || withinBudget(entry.metric, budgetSeconds));
+  members.sort(
+    (a2, b) => (a2.metric?.seconds ?? Infinity) - (b.metric?.seconds ?? Infinity) || haversineMeters(origin.location, a2.poi.location) - haversineMeters(origin.location, b.poi.location)
+  );
+  const results = members.map((entry, index) => {
+    const ranked = {
+      ...entry.poi,
+      distanceMeters: haversineMeters(origin.location, entry.poi.location),
+      score: entry.metric ? Math.round((1 - entry.metric.seconds / budgetSeconds) * 100) / 100 : 0,
+      rank: index + 1
+    };
+    if (entry.metric) {
+      ranked.travelSeconds = entry.metric.seconds;
+      ranked.travelMeters = entry.metric.meters;
+    }
+    return ranked;
+  });
+  return { origin, withinMinutes, mode, isochrone, results, count: results.length };
+}
+function withinBudget(metric, budgetSeconds) {
+  return metric !== null && metric.seconds <= budgetSeconds;
+}
+async function tryIsochrone(routing, origin, minutes, mode, signal) {
+  if (!routing.isochrone) return null;
+  try {
+    return await routing.isochrone(origin, minutes, mode, signal ? { signal } : {});
+  } catch {
+    return null;
+  }
+}
+async function safeMatrix(routing, origin, pois, mode, signal) {
+  if (pois.length === 0) return [];
+  const points = pois.map((poi) => poi.location);
+  try {
+    return await routing.matrix(origin, points, mode, signal ? { signal } : {});
+  } catch {
+    if (routing instanceof HaversineRoutingProvider) return points.map(() => null);
+    return new HaversineRoutingProvider().matrix(origin, points, mode);
+  }
+}
+function resolveSelectors2(categories) {
+  if (!categories || categories.length === 0) return [];
+  const { selectors, unknown } = resolveCategories(categories);
+  if (unknown.length > 0) {
+    const detail = unknown.map((term) => {
+      const suggestions = suggestCategories(term);
+      return suggestions.length > 0 ? `"${term}" (did you mean: ${suggestions.join(", ")}?)` : `"${term}"`;
+    }).join("; ");
+    throw new Error(`Unknown categor${unknown.length > 1 ? "ies" : "y"}: ${detail}`);
+  }
+  return selectors;
+}
+
+// src/gaps.ts
+var DEFAULT_DAILY_NEEDS = [
+  "grocery",
+  "pharmacy",
+  "healthcare",
+  "food",
+  "finance",
+  "transport",
+  "education",
+  "park"
+];
+var DEFAULT_SEARCH_RADIUS_M = 5e3;
+var DEFAULT_THRESHOLD_M = 1500;
+async function detectGaps(query, options = {}) {
+  const terms = options.categories && options.categories.length > 0 ? options.categories : [...DEFAULT_DAILY_NEEDS];
+  const searchRadiusMeters = options.searchRadiusMeters ?? DEFAULT_SEARCH_RADIUS_M;
+  const thresholdMeters = options.thresholdMeters ?? DEFAULT_THRESHOLD_M;
+  const geocoder = options.geocoder ?? new NominatimGeocoder();
+  const places = options.places ?? new OverpassPlacesProvider();
+  const resolved = resolveCategories(terms);
+  if (resolved.unknown.length > 0) {
+    const detail = resolved.unknown.map((term) => {
+      const suggestions = suggestCategories(term);
+      return suggestions.length > 0 ? `"${term}" (did you mean: ${suggestions.join(", ")}?)` : `"${term}"`;
+    }).join("; ");
+    throw new Error(`Unknown categor${resolved.unknown.length > 1 ? "ies" : "y"}: ${detail}`);
+  }
+  const origin = await resolveOrigin(query, geocoder, {
+    language: options.language,
+    signal: options.signal
+  });
+  const nearbyOptions = {
+    radiusMeters: searchRadiusMeters,
+    selectors: resolved.selectors
+  };
+  if (options.signal) nearbyOptions.signal = options.signal;
+  const pois = await places.findNearby(origin.location, nearbyOptions);
+  const gaps = terms.map((term) => {
+    const selectors = resolveCategories([term]).selectors;
+    const { meters, poi } = nearestMatchingPoi(origin.location, pois, selectors);
+    const gap = {
+      category: term,
+      nearestMeters: meters === null ? null : Math.round(meters),
+      isGap: meters === null || meters > thresholdMeters
+    };
+    if (poi?.completeness !== void 0) gap.nearestCompleteness = poi.completeness;
+    return gap;
+  });
+  return {
+    origin,
+    searchRadiusMeters,
+    thresholdMeters,
+    gaps,
+    missing: gaps.filter((gap) => gap.isGap).map((gap) => gap.category)
+  };
+}
+
+// src/walkability.ts
+var DEFAULT_WALK_CATEGORIES = [
+  { term: "grocery", weight: 3 },
+  { term: "food", weight: 2 },
+  { term: "pharmacy", weight: 2 },
+  { term: "transport", weight: 2 },
+  { term: "education", weight: 1 },
+  { term: "healthcare", weight: 1 },
+  { term: "finance", weight: 1 },
+  { term: "park", weight: 1 },
+  { term: "shopping", weight: 1 }
+];
+var DEFAULT_IDEAL_M = 400;
+var DEFAULT_MAX_M = 2400;
+function walkSubScore(meters, idealMeters, maxMeters) {
+  if (meters === null) return 0;
+  if (meters <= idealMeters) return 1;
+  if (meters >= maxMeters) return 0;
+  return round2((maxMeters - meters) / (maxMeters - idealMeters));
+}
+var round2 = (n) => Math.round(n * 100) / 100;
+var mean = (xs) => xs.length ? xs.reduce((s, x) => s + x, 0) / xs.length : 0;
+async function walkabilityScore(query, options = {}) {
+  const categories = options.categories && options.categories.length > 0 ? options.categories : DEFAULT_WALK_CATEGORIES;
+  const idealMeters = options.decay?.idealMeters ?? DEFAULT_IDEAL_M;
+  const maxMeters = options.decay?.maxMeters ?? DEFAULT_MAX_M;
+  const searchRadiusMeters = options.searchRadiusMeters ?? maxMeters;
+  const geocoder = options.geocoder ?? new NominatimGeocoder();
+  const places = options.places ?? new OverpassPlacesProvider();
+  const terms = categories.map((c) => c.term);
+  const resolved = resolveCategories(terms);
+  if (resolved.unknown.length > 0) {
+    const detail = resolved.unknown.map((term) => {
+      const suggestions = suggestCategories(term);
+      return suggestions.length > 0 ? `"${term}" (did you mean: ${suggestions.join(", ")}?)` : `"${term}"`;
+    }).join("; ");
+    throw new Error(`Unknown categor${resolved.unknown.length > 1 ? "ies" : "y"}: ${detail}`);
+  }
+  const origin = await resolveOrigin(query, geocoder, {
+    language: options.language,
+    signal: options.signal
+  });
+  const nearbyOptions = {
+    radiusMeters: searchRadiusMeters,
+    selectors: resolved.selectors
+  };
+  if (options.signal) nearbyOptions.signal = options.signal;
+  const pois = await places.findNearby(origin.location, nearbyOptions);
+  const breakdown = categories.map(({ term, weight }) => {
+    const selectors = resolveCategories([term]).selectors;
+    const { meters, poi } = nearestMatchingPoi(origin.location, pois, selectors);
+    const nearestMeters = meters === null ? null : Math.round(meters);
+    const entry = {
+      category: term,
+      weight,
+      nearestMeters,
+      subScore: walkSubScore(meters, idealMeters, maxMeters)
+    };
+    if (poi?.completeness !== void 0) entry.nearestCompleteness = poi.completeness;
+    return entry;
+  });
+  const totalWeight = categories.reduce((sum, c) => sum + c.weight, 0) || 1;
+  const weighted = breakdown.reduce((sum, b) => sum + b.weight * b.subScore, 0);
+  const score = Math.round(100 * weighted / totalWeight);
+  const found = breakdown.filter((b) => b.nearestMeters !== null);
+  const coverage = breakdown.length ? found.length / breakdown.length : 0;
+  const avgCompleteness = mean(found.map((b) => b.nearestCompleteness ?? 0));
+  const confidence = round2(0.7 * coverage + 0.3 * avgCompleteness);
+  return {
+    origin,
+    score,
+    confidence,
+    breakdown,
+    missing: breakdown.filter((b) => b.nearestMeters === null).map((b) => b.category),
+    decay: { idealMeters, maxMeters }
+  };
+}
+
+// src/compare.ts
+async function compareLocations(queries, options = {}) {
+  if (queries.length < 2) {
+    throw new Error("compareLocations needs at least two locations to compare.");
+  }
+  const categories = options.categories && options.categories.length > 0 ? options.categories : DEFAULT_WALK_CATEGORIES;
+  const geocoder = options.geocoder ?? new NominatimGeocoder();
+  const places = options.places ?? new OverpassPlacesProvider();
+  const locations = [];
+  for (const query of queries) {
+    const walk = await walkabilityScore(query, {
+      categories,
+      geocoder,
+      places,
+      ...options.decay ? { decay: options.decay } : {},
+      ...options.searchRadiusMeters ? { searchRadiusMeters: options.searchRadiusMeters } : {},
+      ...options.language ? { language: options.language } : {},
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    locations.push({
+      origin: walk.origin,
+      score: walk.score,
+      confidence: walk.confidence,
+      breakdown: walk.breakdown,
+      missing: walk.missing
+    });
+  }
+  const ranked = locations.map((location, index) => ({ index, location })).sort(
+    (a2, b) => b.location.score - a2.location.score || b.location.confidence - a2.location.confidence || a2.index - b.index
+  ).map(({ index, location }) => ({ index, score: location.score, origin: location.origin }));
+  const dimensions = categories.map(({ term, weight }) => ({
+    category: term,
+    weight,
+    bestIndex: bestForDimension(locations, term)
+  }));
+  return {
+    locations,
+    ranked,
+    best: ranked[0] ?? null,
+    dimensions,
+    weights: categories
+  };
+}
+function bestForDimension(locations, term) {
+  let bestIndex = null;
+  let bestSub = -1;
+  let bestMeters = Infinity;
+  locations.forEach((location, index) => {
+    const entry = location.breakdown.find((b) => b.category === term);
+    if (!entry || entry.nearestMeters === null) return;
+    if (entry.subScore > bestSub || entry.subScore === bestSub && entry.nearestMeters < bestMeters) {
+      bestSub = entry.subScore;
+      bestMeters = entry.nearestMeters;
+      bestIndex = index;
+    }
+  });
+  return bestIndex;
+}
+
+// src/errands.ts
+var DEFAULT_CANDIDATES = 5;
+var DEFAULT_SEARCH_RADIUS_M2 = 3e3;
+var MAX_CATEGORIES = 12;
+async function planErrands(query, options) {
+  const terms = options.categories ?? [];
+  if (terms.length === 0) throw new Error("planErrands needs at least one category.");
+  if (terms.length > MAX_CATEGORIES) {
+    throw new Error(
+      `planErrands supports up to ${MAX_CATEGORIES} categories (got ${terms.length}).`
+    );
+  }
+  const mode = options.mode ?? "walk";
+  const perCategory = options.candidatesPerCategory ?? DEFAULT_CANDIDATES;
+  const searchRadiusMeters = options.searchRadiusMeters ?? DEFAULT_SEARCH_RADIUS_M2;
+  const routing = options.routing ?? new HaversineRoutingProvider();
+  const geocoder = options.geocoder ?? new NominatimGeocoder();
+  const places = options.places ?? new OverpassPlacesProvider();
+  const resolved = resolveCategories(terms);
+  if (resolved.unknown.length > 0) {
+    const detail = resolved.unknown.map((term) => {
+      const suggestions = suggestCategories(term);
+      return suggestions.length > 0 ? `"${term}" (did you mean: ${suggestions.join(", ")}?)` : `"${term}"`;
+    }).join("; ");
+    throw new Error(`Unknown categor${resolved.unknown.length > 1 ? "ies" : "y"}: ${detail}`);
+  }
+  const origin = await resolveOrigin(query, geocoder, {
+    language: options.language,
+    signal: options.signal
+  });
+  const end = options.end !== void 0 ? await resolveEnd(options.end, geocoder, options) : null;
+  const nearbyOptions = {
+    radiusMeters: searchRadiusMeters,
+    selectors: resolved.selectors
+  };
+  if (options.signal) nearbyOptions.signal = options.signal;
+  const pois = await places.findNearby(origin.location, nearbyOptions);
+  const missing = [];
+  const groups = [];
+  for (const term of terms) {
+    const selectors = resolveCategories([term]).selectors;
+    const candidates = pois.filter((poi) => tagsMatchAnySelector(poi.tags, selectors)).sort(
+      (a2, b) => haversineMeters(origin.location, a2.location) - haversineMeters(origin.location, b.location)
+    ).slice(0, perCategory);
+    if (candidates.length === 0) missing.push(String(term));
+    else groups.push({ term: String(term), candidates });
+  }
+  if (groups.length === 0) {
+    return {
+      origin,
+      end,
+      mode,
+      stops: [],
+      totalSeconds: 0,
+      totalMeters: 0,
+      missing,
+      candidatesPerCategory: perCategory
+    };
+  }
+  const solution = await solveGeneralizedTsp(
+    origin.location,
+    groups,
+    end?.location ?? null,
+    mode,
+    routing
+  );
+  return {
+    origin,
+    end,
+    mode,
+    stops: solution.stops,
+    totalSeconds: solution.totalSeconds,
+    totalMeters: solution.totalMeters,
+    missing,
+    candidatesPerCategory: perCategory
+  };
+}
+async function solveGeneralizedTsp(origin, groups, end, mode, routing) {
+  const nodes = [];
+  groups.forEach((group, groupIndex) => {
+    for (const poi of group.candidates) nodes.push({ group: groupIndex, term: group.term, poi });
+  });
+  const points = [origin, ...nodes.map((node2) => node2.poi.location)];
+  const endPointIndex = end ? points.push(end) - 1 : -1;
+  const matrix = await buildCostMatrix(points, mode, routing);
+  const seconds = (from, to) => matrix[from][to].seconds;
+  const groupCount = groups.length;
+  const nodeCount = nodes.length;
+  const full = (1 << groupCount) - 1;
+  const cost = Array.from(
+    { length: 1 << groupCount },
+    () => new Array(nodeCount).fill(Infinity)
+  );
+  const parent = Array.from(
+    { length: 1 << groupCount },
+    () => new Array(nodeCount).fill(-1)
+  );
+  for (let n = 0; n < nodeCount; n++) {
+    cost[1 << nodes[n].group][n] = seconds(0, n + 1);
+  }
+  for (let mask2 = 1; mask2 <= full; mask2++) {
+    const row = cost[mask2];
+    for (let n = 0; n < nodeCount; n++) {
+      const here = row[n];
+      if (here === Infinity || !(mask2 & 1 << nodes[n].group)) continue;
+      for (let m = 0; m < nodeCount; m++) {
+        const groupBit = 1 << nodes[m].group;
+        if (mask2 & groupBit) continue;
+        const nextMask = mask2 | groupBit;
+        const candidate = here + seconds(n + 1, m + 1);
+        if (candidate < cost[nextMask][m]) {
+          cost[nextMask][m] = candidate;
+          parent[nextMask][m] = n;
+        }
+      }
+    }
+  }
+  let best = Infinity;
+  let lastNode = -1;
+  for (let n = 0; n < nodeCount; n++) {
+    let total = cost[full][n];
+    if (total === Infinity) continue;
+    if (endPointIndex >= 0) total += seconds(n + 1, endPointIndex);
+    if (total < best) {
+      best = total;
+      lastNode = n;
+    }
+  }
+  const order = [];
+  let mask = full;
+  let node = lastNode;
+  while (node !== -1) {
+    order.push(node);
+    const previous = parent[mask][node];
+    mask &= ~(1 << nodes[node].group);
+    node = previous;
+  }
+  order.reverse();
+  const stops = [];
+  let previousPoint = 0;
+  let totalMeters = 0;
+  for (const n of order) {
+    const leg = matrix[previousPoint][n + 1];
+    totalMeters += leg.meters;
+    stops.push({
+      category: nodes[n].term,
+      poi: nodes[n].poi,
+      legSeconds: leg.seconds,
+      legMeters: leg.meters
+    });
+    previousPoint = n + 1;
+  }
+  if (endPointIndex >= 0) totalMeters += matrix[previousPoint][endPointIndex].meters;
+  return { stops, totalSeconds: best === Infinity ? 0 : best, totalMeters };
+}
+async function buildCostMatrix(points, mode, routing) {
+  const rows = [];
+  for (const source of points) {
+    const row = await routing.matrix(source, points, mode);
+    rows.push(row.map((metric) => metric ?? { seconds: Infinity, meters: Infinity }));
+  }
+  return rows;
+}
+async function resolveEnd(end, geocoder, options) {
+  return resolveOrigin(end, geocoder, {
+    language: options.language,
+    signal: options.signal
+  });
+}
+
+// src/export.ts
+var ODBL_ATTRIBUTION = "\xA9 OpenStreetMap contributors, ODbL (https://www.openstreetmap.org/copyright)";
+function toGeoJSON(result) {
+  return {
+    type: "FeatureCollection",
+    attribution: ODBL_ATTRIBUTION,
+    features: result.results.map(poiToFeature)
+  };
+}
+function poiToFeature(poi) {
+  const properties = {
+    rank: poi.rank,
+    name: poi.name ?? null,
+    category: poi.category,
+    kind: poi.kind ?? null,
+    distanceMeters: Math.round(poi.distanceMeters),
+    osmId: poi.id
+  };
+  if (poi.completeness !== void 0) properties.completeness = poi.completeness;
+  if (poi.lastVerified) properties.lastVerified = poi.lastVerified;
+  if (poi.openState) properties.openState = poi.openState;
+  if (poi.nextChange) properties.nextChange = poi.nextChange;
+  return {
+    type: "Feature",
+    geometry: { type: "Point", coordinates: [poi.location.lng, poi.location.lat] },
+    properties
+  };
+}
+var CSV_COLUMNS = [
+  "rank",
+  "name",
+  "category",
+  "kind",
+  "distance_m",
+  "lat",
+  "lng",
+  "osm_id",
+  "completeness",
+  "last_verified",
+  "open_state"
+];
+function toCSV(result) {
+  const rows = [CSV_COLUMNS.join(",")];
+  for (const poi of result.results) {
+    rows.push(
+      [
+        poi.rank,
+        csvField(poi.name ?? ""),
+        poi.category,
+        csvField(poi.kind ?? ""),
+        Math.round(poi.distanceMeters),
+        poi.location.lat,
+        poi.location.lng,
+        poi.id,
+        poi.completeness ?? "",
+        poi.lastVerified ?? "",
+        poi.openState ?? ""
+      ].join(",")
+    );
+  }
+  return rows.join("\n");
+}
+function csvField(value) {
+  return /[",\n\r]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value;
+}
+
+// src/snapshot.ts
+var DEFAULT_SNAPSHOT_RADIUS_M = 2e3;
+async function snapshotArea(query, options = {}) {
+  const radiusMeters = options.radiusMeters ?? DEFAULT_SNAPSHOT_RADIUS_M;
+  const geocoder = options.geocoder ?? new NominatimGeocoder();
+  const places = options.places ?? new OverpassPlacesProvider();
+  let selectors;
+  if (options.categories && options.categories.length > 0) {
+    const resolved = resolveCategories(options.categories);
+    if (resolved.unknown.length > 0) {
+      const detail = resolved.unknown.map((term) => {
+        const suggestions = suggestCategories(term);
+        return suggestions.length > 0 ? `"${term}" (did you mean: ${suggestions.join(", ")}?)` : `"${term}"`;
+      }).join("; ");
+      throw new Error(`Unknown categor${resolved.unknown.length > 1 ? "ies" : "y"}: ${detail}`);
+    }
+    selectors = resolved.selectors;
+  }
+  const origin = await resolveOrigin(query, geocoder, {
+    language: options.language,
+    signal: options.signal
+  });
+  const nearbyOptions = { radiusMeters };
+  if (selectors && selectors.length > 0) nearbyOptions.selectors = selectors;
+  if (options.signal) nearbyOptions.signal = options.signal;
+  const pois = await places.findNearby(origin.location, nearbyOptions);
+  return {
+    attribution: ODBL_ATTRIBUTION,
+    createdAt: options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    center: origin.location,
+    radiusMeters,
+    pois
+  };
+}
+var DatasetPlacesProvider = class {
+  name = "dataset";
+  pois;
+  constructor(dataset) {
+    this.pois = dataset.pois;
+  }
+  async findNearby(center, options) {
+    const { radiusMeters, selectors } = options;
+    return this.pois.filter((poi) => {
+      if (haversineMeters(center, poi.location) > radiusMeters) return false;
+      if (selectors && selectors.length > 0) return tagsMatchAnySelector(poi.tags, selectors);
+      return true;
+    });
+  }
+};
+
+// src/index.ts
+var VERSION = "1.0.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CATEGORIES,
+  CATEGORY_LABELS,
+  DEFAULT_DAILY_NEEDS,
+  DEFAULT_USER_AGENT,
+  DEFAULT_WALK_CATEGORIES,
+  DatasetPlacesProvider,
+  HaversineRoutingProvider,
+  HttpError,
+  InMemoryCache,
+  MODE_SPEED_MPS,
+  NominatimGeocoder,
+  ODBL_ATTRIBUTION,
+  OsrmRoutingProvider,
+  OverpassPlacesProvider,
+  RateLimiter,
+  VERSION,
+  ValhallaRoutingProvider,
+  accessibleScorer,
+  buildOverpassQuery,
+  buildTargetedOverpassQuery,
+  categorize,
+  categoryVocabulary,
+  circlePolygon,
+  compareLocations,
+  compileFacets,
+  completenessOf,
+  dedupePois,
+  detectGaps,
+  disambiguateLocation,
+  findNearbyAmenities,
+  formatDistance,
+  formatDuration,
+  haversineMeters,
+  isCategory,
+  isKnownTerm,
+  isOpenAt,
+  lastVerifiedOf,
+  matchesFacets,
+  nearestMatchingPoi,
+  parseCoordinates,
+  planErrands,
+  pointInPolygon,
+  rankByProximity,
+  reachableAmenities,
+  requestJson,
+  resolveCategories,
+  resolveOrigin,
+  selectorToOverpassFilter,
+  snapshotArea,
+  suggestCategories,
+  tagsMatchAnySelector,
+  tagsMatchSelector,
+  toCSV,
+  toGeoJSON,
+  walkSubScore,
+  walkabilityScore
+});
+//# sourceMappingURL=index.cjs.map