@magmacomputing/tempo-plugin-geo 1.2.0 → 1.3.0

package/dist/install.js

@@ -2774,8 +2774,8 @@ __export(sdk_exports, {
 __reExport(sdk_exports, sdk_star);
 import * as sdk_star from "@magmacomputing/tempo/plugin/sdk";
 import { definePlugin as originalPlugin, defineTerm as originalTerm } from "@magmacomputing/tempo/plugin/sdk";
-var definePlugin = (config) => originalPlugin({ ...config, version: "1.2.0" });
-var defineTerm = (config) => originalTerm({ ...config, version: "1.2.0" });
+var definePlugin = (config) => originalPlugin({ ...config, version: "1.3.0" });
+var defineTerm = (config) => originalTerm({ ...config, version: "1.3.0" });
 
 // ../../library/dist/common/runtime/mapper.library.js
 init_utility_library();
@@ -2794,6 +2794,7 @@ function evaluate(...values) {
 }
 
 // ../../library/dist/common/runtime/mapper.library.js
+init_international_library();
 var MAP_KEY2 = "_magma_geo_";
 var DEFAULT_GEO_TTL = 24 * 60 * 60 * 1e3;
 var GEO_PROPERTIES = [
@@ -2895,16 +2896,25 @@ var resolveCacheKey = (keyOrOpts) => {
     return trimmed.startsWith(MAP_KEY2) ? trimmed : `${MAP_KEY2}:${trimmed}`;
   }
   if (keyOrOpts && isObject(keyOrOpts)) {
+    const provider = keyOrOpts.provider ?? activeGeoProvider;
+    const providerPrefix = provider && isString(provider.name) && !isEmpty(provider.name) ? `provider:${provider.name}` : void 0;
     const k = keyOrOpts.key ?? keyOrOpts.ip ?? keyOrOpts.query;
-    if (isString(k) && !isEmpty(k))
-      return `${MAP_KEY2}:${k.trim()}`;
+    if (isString(k) && !isEmpty(k)) {
+      const trimmedKey = k.trim();
+      return providerPrefix ? `${MAP_KEY2}:${providerPrefix}:${trimmedKey}` : `${MAP_KEY2}:${trimmedKey}`;
+    }
+    if (providerPrefix) {
+      return `${MAP_KEY2}:${providerPrefix}`;
+    }
+  } else if (activeGeoProvider && isString(activeGeoProvider.name) && !isEmpty(activeGeoProvider.name)) {
+    return `${MAP_KEY2}:provider:${activeGeoProvider.name}`;
   }
   return MAP_KEY2;
 };
 var getStashedGeo = (keyOrOpts) => {
   const cacheKey = resolveCacheKey(keyOrOpts);
   try {
-    const raw = getStorage(cacheKey) ?? (typeof localStorage !== "undefined" ? localStorage.getItem(cacheKey) : void 0);
+    const raw = getStorage(cacheKey) ?? (isCallable(globalThis.localStorage?.getItem) ? globalThis.localStorage.getItem(cacheKey) : void 0);
     if (!raw)
       return void 0;
     const parsed = isString(raw) && (raw.startsWith("{") || raw.startsWith("[")) ? JSON.parse(raw) : raw;
@@ -2958,7 +2968,15 @@ var clearStashedGeo = (keyOrOpts) => {
   const cacheKey = resolveCacheKey(keyOrOpts);
   setStorage(cacheKey, void 0);
 };
+var activeGeoProvider;
+function setGeoProvider(provider) {
+  activeGeoProvider = provider;
+}
+function getGeoProvider() {
+  return activeGeoProvider;
+}
 var geoLookup = async (opts = {}) => {
+  const provider = opts.provider ?? activeGeoProvider;
   const useCache = opts.refresh !== true;
   if (useCache) {
     const stashed = getStashedGeo(opts);
@@ -2974,26 +2992,45 @@ var geoLookup = async (opts = {}) => {
       };
     }
   }
-  const { type } = getContext();
   let res;
-  switch (type) {
-    case CONTEXT.Browser: {
-      const { geoLocation: geoLocation2 } = await Promise.resolve().then(() => (init_mapper_library(), mapper_library_exports));
-      const browserRes = await geoLocation2(opts);
-      if (browserRes.error)
-        return { error: browserRes.error };
-      const lat = browserRes.coords?.latitude;
-      const lng = browserRes.coords?.longitude;
-      res = { ...browserRes, lat, lng, latitude: lat, longitude: lng };
-      break;
+  if (provider && isFunction(provider.lookup)) {
+    try {
+      const providerRes = await provider.lookup(opts);
+      if (providerRes) {
+        res = providerRes;
+        if (providerRes.error && opts.fallback === false)
+          return providerRes;
+      } else if (opts.fallback === false) {
+        return { error: "Provider returned null and fallback is disabled" };
+      }
+    } catch (err) {
+      if (opts.fallback === false)
+        return { error: err?.message ?? "Provider lookup failed" };
     }
-    case CONTEXT.WebWorker:
-    case CONTEXT.NodeJS:
-    case CONTEXT.Deno:
-    default: {
-      const { serverGeoLocation: serverGeoLocation2 } = await Promise.resolve().then(() => (init_mapper_library2(), mapper_library_exports2));
-      res = await serverGeoLocation2(opts);
-      break;
+  }
+  if (!res || res.error) {
+    if (opts.fallback === false && (provider || res?.error))
+      return res && res.error ? res : { error: "Geolocation resolution failed and fallback is disabled" };
+    const { type } = getContext();
+    switch (type) {
+      case CONTEXT.Browser: {
+        const { geoLocation: geoLocation2 } = await Promise.resolve().then(() => (init_mapper_library(), mapper_library_exports));
+        const browserRes = await geoLocation2(opts);
+        if (browserRes.error)
+          return { error: browserRes.error };
+        const lat = browserRes.coords?.latitude;
+        const lng = browserRes.coords?.longitude;
+        res = { ...browserRes, lat, lng, latitude: lat, longitude: lng };
+        break;
+      }
+      case CONTEXT.WebWorker:
+      case CONTEXT.NodeJS:
+      case CONTEXT.Deno:
+      default: {
+        const { serverGeoLocation: serverGeoLocation2 } = await Promise.resolve().then(() => (init_mapper_library2(), mapper_library_exports2));
+        res = await serverGeoLocation2(opts);
+        break;
+      }
     }
   }
   const rawLat = res.latitude ?? res.lat;
@@ -3023,6 +3060,21 @@ var geoLookup = async (opts = {}) => {
   }
   return res;
 };
+async function reverseGeocode(coords, opts) {
+  const provider = opts?.provider ?? activeGeoProvider;
+  if (provider && isFunction(provider.reverseGeocode)) {
+    return provider.reverseGeocode(coords, opts);
+  }
+  const resolved = coerceGeo(coords);
+  return resolved ?? null;
+}
+async function forwardGeocode(query, opts) {
+  const provider = opts?.provider ?? activeGeoProvider;
+  if (provider && isFunction(provider.forwardGeocode)) {
+    return provider.forwardGeocode(query, opts);
+  }
+  return null;
+}
 var resolveGeoCoordinates = async (input, opts = {}) => {
   const coerced = coerceGeo(input);
   if (coerced && isNumber(coerced.latitude) && isNumber(coerced.longitude))
@@ -3053,35 +3105,80 @@ var resolveGeoCoordinates = async (input, opts = {}) => {
   }
   return null;
 };
-function haversineDistance(from, to, unit = "km") {
+var extractRawCoords = (input) => {
+  if (isNullish(input))
+    return void 0;
+  if (isString(input) && input.includes(",")) {
+    const segments = input.split(",").map((s) => s.trim());
+    if (segments.length >= 2 && segments[0] !== "" && segments[1] !== "") {
+      const lat = Number(segments[0]);
+      const lng = Number(segments[1]);
+      if (isNumber(lat) && isNumber(lng) && lat >= -90 && lat <= 90 && lng >= -180 && lng <= 180) {
+        return { lat, lng };
+      }
+    }
+    return void 0;
+  }
+  if (Array.isArray(input) && input.length >= 2) {
+    const rawLat = input[0];
+    const rawLng = input[1];
+    if (rawLat !== null && rawLng !== null && rawLat !== "" && rawLng !== "" && typeof rawLat !== "boolean" && typeof rawLng !== "boolean") {
+      const lat = typeof rawLat === "string" && rawLat.trim() === "" ? NaN : Number(rawLat);
+      const lng = typeof rawLng === "string" && rawLng.trim() === "" ? NaN : Number(rawLng);
+      if (isNumber(lat) && isNumber(lng) && lat >= -90 && lat <= 90 && lng >= -180 && lng <= 180) {
+        return { lat, lng };
+      }
+    }
+    return void 0;
+  }
+  if (isReference(input)) {
+    const geo = input.geo ?? input.config?.geo ?? input;
+    const cfg = input.config?.geo ?? input.config;
+    const rawLat = evaluate(geo?.latitude, geo?.lat, input.latitude, input.lat, cfg?.latitude, cfg?.lat);
+    const rawLng = evaluate(geo?.longitude, geo?.lng, geo?.lon, geo?.long, input.longitude, input.lng, input.lon, input.long, cfg?.longitude, cfg?.lng, cfg?.lon, cfg?.long);
+    if (rawLat !== null && rawLng !== null && rawLat !== "" && rawLng !== "" && typeof rawLat !== "boolean" && typeof rawLng !== "boolean") {
+      const lat = typeof rawLat === "string" && rawLat.trim() === "" ? NaN : Number(rawLat);
+      const lng = typeof rawLng === "string" && rawLng.trim() === "" ? NaN : Number(rawLng);
+      if (isNumber(lat) && isNumber(lng) && lat >= -90 && lat <= 90 && lng >= -180 && lng <= 180) {
+        return { lat, lng };
+      }
+    }
+  }
+  return void 0;
+};
+var toRadianCoordinates = (from, to) => {
   const c1 = coerceGeo(from);
   const c2 = coerceGeo(to);
-  if (!c1 || !c2 || !isNumber(c1.latitude) || !isNumber(c1.longitude) || !isNumber(c2.latitude) || !isNumber(c2.longitude)) {
-    return NaN;
-  }
+  if (!c1 || !c2 || !isNumber(c1.latitude) || !isNumber(c1.longitude) || !isNumber(c2.latitude) || !isNumber(c2.longitude))
+    return void 0;
   const toRad = Math.PI / 180;
   const lat1 = c1.latitude * toRad;
   const lng1 = c1.longitude * toRad;
   const lat2 = c2.latitude * toRad;
   const lng2 = c2.longitude * toRad;
-  const dLat = lat2 - lat1;
-  const dLng = lng2 - lng1;
+  return {
+    lat1,
+    lat2,
+    lng1,
+    lng2,
+    dLat: lat2 - lat1,
+    dLng: lng2 - lng1
+  };
+};
+function haversineDistance(from, to, unit = "km") {
+  const coords = toRadianCoordinates(from, to);
+  if (!coords)
+    return NaN;
+  const { lat1, lat2, dLat, dLng } = coords;
   const a = Math.sin(dLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLng / 2) ** 2;
   const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-  let radius;
-  if (unit === "miles") {
-    radius = 3958.7613;
-  } else if (unit === "m") {
-    radius = 63710088e-1;
-  } else {
-    radius = 6371.0088;
-  }
+  const radius = unit === "miles" ? 3958.7613 : unit === "m" ? 63710088e-1 : 6371.0088;
   const dist = radius * c;
   return unit === "m" ? Math.round(dist) : Math.round(dist * 1e3) / 1e3;
 }
 var resolveCivilTimezoneOffset = (tz, epochMs) => {
   try {
-    if (typeof Temporal !== "undefined" && typeof Temporal.Instant?.fromEpochMilliseconds === "function") {
+    if (isDefined(globalThis.Temporal) && isFunction(globalThis.Temporal.Instant?.fromEpochMilliseconds)) {
       const zdt = Temporal.Instant.fromEpochMilliseconds(epochMs).toZonedDateTimeISO(tz);
       return zdt.offsetNanoseconds / 6e10;
     }
@@ -3106,14 +3203,14 @@ var resolveCivilTimezoneOffset = (tz, epochMs) => {
 };
 function solarOffset(coords, options) {
   const geo = coerceGeo(coords);
-  if (!geo || !isNumber(geo.latitude) || !isNumber(geo.longitude) || isNaN(geo.latitude) || isNaN(geo.longitude)) {
+  if (!geo || !isNumber(geo.latitude) || !isNumber(geo.longitude)) {
     return NaN;
   }
   const lng = geo.longitude;
   const tz = options?.timeZone ?? (isReference(coords) ? coords.timezone ?? coords.tz : void 0) ?? geo.timezone;
-  const dateVal = options?.date ?? (isReference(coords) && isNumber(coords.epoch?.ms) ? coords.epoch.ms : Date.now());
-  const epochMs = typeof dateVal === "number" ? dateVal : isString(dateVal) ? Date.parse(dateVal) : isDate(dateVal) ? dateVal.getTime() : isReference(dateVal) && isNumber(dateVal?.epoch?.ms) ? dateVal.epoch.ms : Date.now();
-  if (!Number.isFinite(epochMs))
+  const dateVal = options?.date ?? (isReference(coords) ? extractEpochMs(coords) : void 0);
+  const epochMs = isDefined(dateVal) ? extractEpochMs(dateVal) : Date.now();
+  if (!isNumber(epochMs))
     return NaN;
   const offsetMinutes = isText(tz) ? resolveCivilTimezoneOffset(tz, epochMs) : void 0;
   const refMeridian = offsetMinutes !== void 0 ? offsetMinutes / 60 * 15 : Math.round(lng / 15) * 15;
@@ -3127,11 +3224,11 @@ function solarOffset(coords, options) {
     const eqTime = 229.18 * (75e-6 + 1868e-6 * Math.cos(gamma) - 0.032077 * Math.sin(gamma) - 0.014615 * Math.cos(2 * gamma) - 0.040849 * Math.sin(2 * gamma));
     offsetMin += eqTime;
   }
-  const unit = options?.unit ?? "minutes";
+  const unit = options?.unit ?? "mi";
   let res;
-  if (unit === "seconds") {
+  if (unit === "ss" || unit === "seconds") {
     res = offsetMin * 60;
-  } else if (unit === "hours") {
+  } else if (unit === "hh" || unit === "hours") {
     res = offsetMin / 60;
   } else {
     res = offsetMin;
@@ -3140,23 +3237,308 @@ function solarOffset(coords, options) {
   const factor = Math.pow(10, precision);
   return Math.round(res * factor) / factor;
 }
+function extractEpochMs(input) {
+  if (isNullish(input))
+    return void 0;
+  if (isNumber(input))
+    return input;
+  if (isDate(input))
+    return input.getTime();
+  if (isReference(input)) {
+    if (isNumber(input.epoch?.ms))
+      return input.epoch.ms;
+    if (isNumber(input.epochMilliseconds))
+      return input.epochMilliseconds;
+    if (isNumber(input.timestamp))
+      return input.timestamp;
+    if (isDate(input.date))
+      return input.date.getTime();
+    if (isFunction(input.toInstant)) {
+      try {
+        return input.toInstant().epochMilliseconds;
+      } catch {
+      }
+    }
+    if (isFunction(input.getTime))
+      try {
+        return input.getTime();
+      } catch {
+      }
+  }
+  if (isString(input)) {
+    const parsed = Date.parse(input);
+    if (isNumber(parsed))
+      return parsed;
+  }
+  return void 0;
+}
+function calculateBearing(from, to, options) {
+  const coords = toRadianCoordinates(from, to);
+  if (!coords)
+    return NaN;
+  const { lat1, lat2, dLng } = coords;
+  const y = Math.sin(dLng) * Math.cos(lat2);
+  const x = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLng);
+  const bearing = (Math.atan2(y, x) * 180 / Math.PI + 360) % 360;
+  const precision = options?.precision ?? 1;
+  const factor = Math.pow(10, precision);
+  return Math.round(bearing * factor) / factor;
+}
+function calculateMidpoint(from, to) {
+  const coords = toRadianCoordinates(from, to);
+  if (!coords)
+    return void 0;
+  const { lat1, lat2, lng1, dLng } = coords;
+  const Bx = Math.cos(lat2) * Math.cos(dLng);
+  const By = Math.cos(lat2) * Math.sin(dLng);
+  const latMidRad = Math.atan2(Math.sin(lat1) + Math.sin(lat2), Math.sqrt((Math.cos(lat1) + Bx) ** 2 + By ** 2));
+  const lngMidRad = lng1 + Math.atan2(By, Math.cos(lat1) + Bx);
+  const midLat = Math.round(latMidRad * 180 / Math.PI * 1e3) / 1e3;
+  const midLng = Math.round(((lngMidRad * 180 / Math.PI + 540) % 360 - 180) * 1e3) / 1e3;
+  const sphere = midLat > 1e-3 ? "north" : midLat < -1e-3 ? "south" : "equator";
+  return {
+    latitude: midLat,
+    longitude: midLng,
+    sphere
+  };
+}
+function calculateVelocity(from, to, options) {
+  const opts = isString(options) ? { unit: options } : options ?? {};
+  const unit = opts.unit ?? "km";
+  const timeUnit = opts.timeUnit ?? "hh";
+  const dist = haversineDistance(from, to, unit);
+  if (isNaN(dist))
+    return NaN;
+  const t1 = extractEpochMs(from);
+  const t2 = extractEpochMs(to);
+  if (!isNumber(t1) || !isNumber(t2))
+    return NaN;
+  const deltaMs = Math.abs(t2 - t1);
+  if (deltaMs === 0) {
+    return dist === 0 ? 0 : Infinity;
+  }
+  let deltaUnits;
+  if (timeUnit === "ss" || timeUnit === "s" || timeUnit === "seconds" || timeUnit === "second") {
+    deltaUnits = deltaMs / 1e3;
+  } else if (timeUnit === "mi" || timeUnit === "m" || timeUnit === "minutes" || timeUnit === "minute") {
+    deltaUnits = deltaMs / 6e4;
+  } else {
+    deltaUnits = deltaMs / 36e5;
+  }
+  const velocity = dist / deltaUnits;
+  const precision = opts.precision ?? 2;
+  const factor = Math.pow(10, precision);
+  return Math.round(velocity * factor) / factor;
+}
+function isImpossibleTravel(from, to, options) {
+  const unit = options?.unit ?? "km";
+  const defaultMax = unit === "miles" ? 560 : unit === "m" ? 250 : 900;
+  const threshold = options?.maxSpeed ?? options?.maxCommercialSpeedKmH ?? defaultMax;
+  const velocity = calculateVelocity(from, to, { unit, timeUnit: unit === "m" ? "ss" : "hh" });
+  return velocity > threshold;
+}
+function isWithin(from, to, maxDistance, unit = "km") {
+  if (!isNumber(maxDistance) || maxDistance < 0)
+    return false;
+  const c1 = extractRawCoords(from);
+  const c2 = extractRawCoords(to);
+  if (!c1 || !c2 || !isNumber(c1.lat) || !isNumber(c1.lng) || !isNumber(c2.lat) || !isNumber(c2.lng))
+    return false;
+  const toRad = Math.PI / 180;
+  const lat1 = c1.lat * toRad;
+  const lng1 = c1.lng * toRad;
+  const lat2 = c2.lat * toRad;
+  const lng2 = c2.lng * toRad;
+  const dLat = lat2 - lat1;
+  const dLng = lng2 - lng1;
+  const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  const radius = unit === "miles" ? 3958.7613 : unit === "m" ? 63710088e-1 : 6371.0088;
+  const dist = radius * c;
+  return dist <= maxDistance;
+}
+function inBoundingBox(coords, bbox) {
+  const geo = extractRawCoords(coords);
+  if (!geo || !isNumber(geo.lat) || !isNumber(geo.lng))
+    return false;
+  if (isNullish(bbox))
+    return false;
+  let minLat;
+  let maxLat;
+  let minLng;
+  let maxLng;
+  if (Array.isArray(bbox) && bbox.length >= 4) {
+    minLat = bbox[0];
+    minLng = bbox[1];
+    maxLat = bbox[2];
+    maxLng = bbox[3];
+  } else if (isReference(bbox)) {
+    const b = bbox;
+    minLat = b.minLat ?? b.minLatitude;
+    maxLat = b.maxLat ?? b.maxLatitude;
+    minLng = b.minLng ?? b.minLongitude;
+    maxLng = b.maxLng ?? b.maxLongitude;
+  }
+  if (!isNumber(minLat) || !isNumber(maxLat) || !isNumber(minLng) || !isNumber(maxLng))
+    return false;
+  const lat = geo.lat;
+  const lng = geo.lng;
+  if (lat < minLat || lat > maxLat)
+    return false;
+  return minLng <= maxLng ? lng >= minLng && lng <= maxLng : lng >= minLng || lng <= maxLng;
+}
+var COMMON_COUNTRY_NAMES = {
+  australia: "AU",
+  "united states": "US",
+  "united kingdom": "GB",
+  "great britain": "GB",
+  france: "FR",
+  germany: "DE",
+  italy: "IT",
+  spain: "ES",
+  japan: "JP",
+  china: "CN",
+  canada: "CA",
+  brazil: "BR",
+  egypt: "EG",
+  "saudi arabia": "SA",
+  russia: "RU",
+  india: "IN",
+  mexico: "MX",
+  "new zealand": "NZ",
+  netherlands: "NL",
+  switzerland: "CH",
+  austria: "AT",
+  belgium: "BE",
+  sweden: "SE",
+  norway: "NO",
+  denmark: "DK",
+  finland: "FI",
+  poland: "PL",
+  turkey: "TR",
+  greece: "GR",
+  israel: "IL",
+  thailand: "TH",
+  vietnam: "VN",
+  indonesia: "ID",
+  malaysia: "MY",
+  philippines: "PH",
+  "south africa": "ZA",
+  "south korea": "KR",
+  korea: "KR",
+  ireland: "IE",
+  portugal: "PT",
+  argentina: "AR"
+};
+var COUNTRY_PRIMARY_LOCALES = {
+  AU: "en-AU",
+  US: "en-US",
+  GB: "en-GB",
+  CA: "en-CA",
+  NZ: "en-NZ",
+  IE: "en-IE",
+  SA: "ar-SA",
+  AE: "ar-AE",
+  EG: "ar-EG",
+  JP: "ja-JP",
+  CN: "zh-CN",
+  TW: "zh-TW",
+  HK: "zh-HK",
+  KR: "ko-KR",
+  FR: "fr-FR",
+  DE: "de-DE",
+  IT: "it-IT",
+  ES: "es-ES",
+  MX: "es-MX",
+  AR: "es-AR",
+  BR: "pt-BR",
+  PT: "pt-PT",
+  RU: "ru-RU",
+  IN: "hi-IN",
+  NL: "nl-NL",
+  SE: "sv-SE",
+  NO: "nb-NO",
+  DK: "da-DK",
+  FI: "fi-FI",
+  PL: "pl-PL",
+  TR: "tr-TR",
+  GR: "el-GR",
+  IL: "he-IL",
+  TH: "th-TH",
+  VN: "vi-VN",
+  ID: "id-ID",
+  MY: "ms-MY",
+  PH: "fil-PH",
+  ZA: "en-ZA",
+  CH: "de-CH",
+  AT: "de-AT",
+  BE: "nl-BE"
+};
+function resolveCulturalLocale(currentLocale, countryCode, mode = true) {
+  if (mode === false || mode === "none" || mode === "off")
+    return void 0;
+  const toCode = (val) => {
+    const trimmed = val.trim();
+    if (trimmed.length === 2)
+      return trimmed.toUpperCase();
+    return COMMON_COUNTRY_NAMES[trimmed.toLowerCase()];
+  };
+  let country;
+  if (Array.isArray(countryCode)) {
+    for (const c of countryCode) {
+      if (isString(c)) {
+        const mapped = toCode(c);
+        if (mapped) {
+          country = mapped;
+          break;
+        }
+      }
+    }
+  } else if (isString(countryCode)) {
+    country = toCode(countryCode);
+  }
+  if (isString(mode) && mode !== "regional" && mode !== "region" && mode !== "native" && mode !== "full") {
+    const loc2 = getLC(mode);
+    return loc2?.baseName ?? cleanLocaleTag(mode);
+  }
+  if (!country)
+    return void 0;
+  if (mode === "native" || mode === "full") {
+    const nativeTag = COUNTRY_PRIMARY_LOCALES[country] ?? `en-${country}`;
+    const loc2 = getLC(nativeTag);
+    return loc2?.baseName ?? nativeTag;
+  }
+  let baseLang = "en";
+  let script;
+  if (isString(currentLocale) && currentLocale.length > 0) {
+    const loc2 = getLC(currentLocale);
+    baseLang = loc2?.language ?? cleanLocaleTag(currentLocale)?.split("-")[0] ?? "en";
+    if (loc2?.script)
+      script = loc2.script;
+  }
+  const targetTag = script ? `${baseLang}-${script}-${country}` : `${baseLang}-${country}`;
+  const loc = getLC(targetTag);
+  return loc?.baseName ?? targetTag;
+}
 
 // src/index.ts
 init_mapper_library2();
 init_mapper_library();
-init_assertion_library();
+import { isString as isString2, isNumber as isNumber2, isObject as isObject2, isEmpty as isEmpty2, isSafeKey as isSafeKey2 } from "@magmacomputing/tempo/library";
 var GeoPlugin = definePlugin({
   name: "geo",
   install(TempoClass, options) {
     const installedClass = TempoClass || this;
+    if (options?.provider)
+      setGeoProvider(options.provider);
     const getEffectiveOptions = (callSiteOpts, instance) => {
       const classOpts = installedClass.config?.pluginOptions?.geo;
       const instanceOpts = instance?.config?.pluginOptions?.geo;
       return {
-        ...isObject(options) ? options : {},
-        ...isObject(classOpts) ? classOpts : {},
-        ...isObject(instanceOpts) ? instanceOpts : {},
-        ...isObject(callSiteOpts) ? callSiteOpts : {}
+        ...isObject2(options) ? options : {},
+        ...isObject2(classOpts) ? classOpts : {},
+        ...isObject2(instanceOpts) ? instanceOpts : {},
+        ...isObject2(callSiteOpts) ? callSiteOpts : {}
       };
     };
     if (!Object.hasOwn(installedClass, "geo")) {
@@ -3165,10 +3547,20 @@ var GeoPlugin = definePlugin({
         resolve: (target, opts) => resolveGeoCoordinates(target, getEffectiveOptions(opts, target)),
         coerce: coerceGeo,
         distance: haversineDistance,
+        bearing: calculateBearing,
+        midpoint: calculateMidpoint,
+        velocity: calculateVelocity,
+        isImpossibleTravel,
+        isWithin,
+        inBoundingBox,
         solarOffset,
         stash: stashGeo,
         clear: clearStashedGeo,
         get: getStashedGeo,
+        setProvider: setGeoProvider,
+        getProvider: getGeoProvider,
+        reverse: (coords, opts) => reverseGeocode(coords, getEffectiveOptions(opts)),
+        forward: (query, opts) => forwardGeocode(query, getEffectiveOptions(opts)),
         server: serverGeoLocation,
         browser: geoLocation,
         get current() {
@@ -3185,41 +3577,44 @@ var GeoPlugin = definePlugin({
     TempoClass.prototype.geoLocate = async function(opts) {
       const effectiveOpts = getEffectiveOptions(opts, this);
       const setTimezone = effectiveOpts?.setTimezone !== false;
+      const setLocale = effectiveOpts?.setLocale ?? true;
       const coords = await resolveGeoCoordinates(this, effectiveOpts);
       if (coords) {
-        const existingGeo = isObject(this.config.geo) ? this.config.geo : {};
+        const existingGeo = isObject2(this.config.geo) ? this.config.geo : {};
         const customKeys = {};
         for (const key of Object.keys(existingGeo)) {
-          if (isSafeKey(key) && !GEO_PROPERTIES.includes(key))
+          if (isSafeKey2(key) && !GEO_PROPERTIES.includes(key))
             customKeys[key] = existingGeo[key];
         }
         const callSiteGeo = coerceGeo(opts) ?? {};
-        if (isObject(opts)) {
+        if (isObject2(opts)) {
           for (const key of Object.keys(opts)) {
-            if (isSafeKey(key) && !["setTimezone", "refresh", "ttl", "endpoint", "timeout", "catch", "debug", "geo"].includes(key)) {
+            if (isSafeKey2(key) && !["setTimezone", "setLocale", "refresh", "ttl", "endpoint", "timeout", "catch", "debug", "geo", "provider", "fallback"].includes(key)) {
               if (!GEO_PROPERTIES.includes(key))
                 customKeys[key] = opts[key];
             }
           }
         }
-        const preservedElevation = isNumber(coords?.elevation) ? coords.elevation : isNumber(existingGeo.elevation) ? existingGeo.elevation : void 0;
+        const preservedElevation = isNumber2(coords?.elevation) ? coords.elevation : isNumber2(existingGeo.elevation) ? existingGeo.elevation : void 0;
         const mergedGeo = {
           ...customKeys,
           ...coords,
-          ...isNumber(preservedElevation) ? { elevation: preservedElevation } : {},
+          ...isNumber2(preservedElevation) ? { elevation: preservedElevation } : {},
           ...callSiteGeo
         };
-        if (isNumber(mergedGeo.latitude)) mergedGeo.latitude = Math.round(mergedGeo.latitude * 1e3) / 1e3;
-        if (isNumber(mergedGeo.longitude)) mergedGeo.longitude = Math.round(mergedGeo.longitude * 1e3) / 1e3;
-        if (!mergedGeo.sphere && isNumber(mergedGeo.latitude)) {
+        if (isNumber2(mergedGeo.latitude)) mergedGeo.latitude = Math.round(mergedGeo.latitude * 1e3) / 1e3;
+        if (isNumber2(mergedGeo.longitude)) mergedGeo.longitude = Math.round(mergedGeo.longitude * 1e3) / 1e3;
+        if (!mergedGeo.sphere && isNumber2(mergedGeo.latitude)) {
           mergedGeo.sphere = mergedGeo.latitude > 1e-3 ? "north" : mergedGeo.latitude < -1e-3 ? "south" : "equator";
         }
         let instance = this;
         const targetTz = mergedGeo.timezone;
-        if (setTimezone && isString(targetTz) && !isEmpty(targetTz))
+        if (setTimezone && isString2(targetTz) && !isEmpty2(targetTz))
           instance = this.set({ timeZone: targetTz });
+        const targetLocale = mergedGeo.country || isString2(setLocale) ? resolveCulturalLocale(this.locale ?? this.config.locale, mergedGeo.country, setLocale) : void 0;
         return new TempoClass(instance, {
           ...instance.config,
+          ...targetLocale ? { locale: targetLocale } : {},
           geo: (0, sdk_exports.deepFreeze)(mergedGeo),
           ...mergedGeo.sphere ? { sphere: mergedGeo.sphere } : {}
         });
@@ -3245,18 +3640,29 @@ var index_default = GeoPlugin;
 export {
   GEO_PROPERTIES,
   GeoPlugin,
+  calculateBearing,
+  calculateMidpoint,
+  calculateVelocity,
   clearStashedGeo,
   coerceGeo,
   index_default as default,
+  forwardGeocode,
   geoLocation,
   geoLookup,
   geoPlugin,
+  getGeoProvider,
   getStashedGeo,
   haversineDistance,
+  inBoundingBox,
+  isImpossibleTravel,
+  isWithin,
+  resolveCulturalLocale,
   resolveGeoCoordinates,
+  reverseGeocode,
   serverGeoCoords,
   serverGeoLocation,
   serverMapHemisphere,
+  setGeoProvider,
   solarOffset,
   stashGeo
 };