@magmacomputing/tempo-plugin-geo 1.3.0 → 1.4.1

package/dist/index.js

@@ -274,7 +274,7 @@ function isNumeric(str) {
       return false;
   }
 }
-var isType, isPrimitive, isReference, isIterable, isString, isText, isNumber, RE_BIGINT_LITERAL, isInteger, isArray, isArrayLike, isObject, isDate, isRegExp, isSymbol, isSymbolFor, isSafeKey, isNullish, isUndefined, isDefined, isFunction, isCallable, isMap, isSet, isError, isLocale, isEmpty;
+var isType, isPrimitive, isReference, isIterable, isString, isText, isNumber, RE_BIGINT_LITERAL, isInteger, isBoolean, isArray, isArrayLike, isObject, isDate, isRegExp, isSymbol, isSymbolFor, isSafeKey, isNullish, isUndefined, isDefined, isFunction, isCallable, isMap, isSet, isError, isLocale, isEmpty;
 var init_assertion_library = __esm({
   "../../library/dist/common/primitives/assertion.library.js"() {
     "use strict";
@@ -289,6 +289,7 @@ var init_assertion_library = __esm({
     isNumber = (obj) => Number.isFinite(obj);
     RE_BIGINT_LITERAL = /^[+-]?[0-9]+n$/;
     isInteger = (obj) => typeof obj === "bigint";
+    isBoolean = (obj) => typeof obj === "boolean";
     isArray = (obj) => Array.isArray(obj);
     isArrayLike = (obj) => protoType(obj) === "Object" && "length" in obj && Object.keys(obj).every((key) => key === "length" || isNumber(Number(key)));
     isObject = (obj) => isType(obj, "Object");
@@ -2774,8 +2775,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.3.0" });
-var defineTerm = (config) => originalTerm({ ...config, version: "1.3.0" });
+var definePlugin = (config) => originalPlugin({ ...config, version: "1.4.1" });
+var defineTerm = (config) => originalTerm({ ...config, version: "1.4.1" });
 
 // ../../library/dist/common/runtime/mapper.library.js
 init_utility_library();
@@ -2794,9 +2795,13 @@ function evaluate(...values) {
 }
 
 // ../../library/dist/common/runtime/mapper.library.js
-init_international_library();
+init_cache_class();
 var MAP_KEY2 = "_magma_geo_";
 var DEFAULT_GEO_TTL = 24 * 60 * 60 * 1e3;
+var DEFAULT_REVERSE_GEO_ENDPOINT = "https://api.bigdatacloud.net/data/reverse-geocode-client";
+var DEFAULT_REVERSE_GEO_TIMEOUT = 3e3;
+var DEFAULT_REVERSE_GEO_MAX_BYTES = 64 * 1024;
+var DEFAULT_SPATIAL_CACHE_SIZE = 1e3;
 var GEO_PROPERTIES = [
   "latitude",
   "lat",
@@ -2811,13 +2816,33 @@ var GEO_PROPERTIES = [
   "timezone",
   "tz"
 ];
-var normalizeLat = (lat) => isNumber(lat) && lat >= -90 && lat <= 90 ? Math.round(lat * 1e3) / 1e3 : void 0;
-var normalizeLng = (lng) => isNumber(lng) && lng >= -180 && lng <= 180 ? Math.round(lng * 1e3) / 1e3 : void 0;
-var normalizeCoords = (lat, lng) => {
-  const nLat = normalizeLat(lat);
-  const nLng = normalizeLng(lng);
-  return nLat !== void 0 && nLng !== void 0 ? { lat: nLat, lng: nLng } : void 0;
+var parseCoordNumber = (val) => {
+  if (!isDefined(val) || isBoolean(val))
+    return NaN;
+  if (isString(val)) {
+    const trimmed = val.trim();
+    return trimmed.length > 0 ? Number(trimmed) : NaN;
+  }
+  return isNumber(val) ? val : NaN;
 };
+var normalizeLat = (lat, round = true) => {
+  const n = parseCoordNumber(lat);
+  if (!isNumber(n) || n < -90 || n > 90)
+    return void 0;
+  return round ? Math.round(n * 1e3) / 1e3 : n;
+};
+var normalizeLng = (lng, round = true) => {
+  const n = parseCoordNumber(lng);
+  if (!isNumber(n) || n < -180 || n > 180)
+    return void 0;
+  return round ? Math.round(n * 1e3) / 1e3 : n;
+};
+var normalizeCoords = (lat, lng, round = true) => {
+  const nLat = normalizeLat(lat, round);
+  const nLng = normalizeLng(lng, round);
+  return isDefined(nLat) && isDefined(nLng) ? { lat: nLat, lng: nLng } : void 0;
+};
+var normalizeElevation = (elevation) => isNumber(elevation) ? Math.round(elevation * 1e3) / 1e3 : void 0;
 var resolveSphere = (sphere, lat) => {
   if (sphere === "north" || sphere === "south" || sphere === "equator")
     return sphere;
@@ -2825,35 +2850,47 @@ var resolveSphere = (sphere, lat) => {
     return lat > 1e-3 ? "north" : lat < -1e-3 ? "south" : "equator";
   return void 0;
 };
-var coerceGeo = (input) => {
+var parseCoordinatePair = (input, normalize = true) => {
   if (isString(input) && input.includes(",")) {
-    const segments = input.split(",").map((s) => s.trim());
-    const parts = segments.map((s) => s === "" ? NaN : Number(s));
-    if (parts.length >= 2 && !isNaN(parts[0]) && !isNaN(parts[1])) {
-      const coords = normalizeCoords(parts[0], parts[1]);
-      if (coords) {
-        const result2 = { latitude: coords.lat, longitude: coords.lng };
-        const sphere2 = resolveSphere(void 0, coords.lat);
-        if (sphere2)
-          result2.sphere = sphere2;
-        return result2;
+    const parts = input.split(",").map((s) => s.trim());
+    return parts.length >= 2 ? normalizeCoords(parts[0], parts[1], normalize) : void 0;
+  }
+  return Array.isArray(input) && input.length >= 2 ? normalizeCoords(input[0], input[1], normalize) : void 0;
+};
+var assembleGeoConfig = (coords, meta) => {
+  const lat = "lat" in coords ? coords.lat : coords.latitude;
+  const lng = "lng" in coords ? coords.lng : coords.longitude;
+  const nLat = normalizeLat(lat);
+  const nLng = normalizeLng(lng);
+  const sphere = resolveSphere(meta?.sphere, nLat ?? lat);
+  const elevation = normalizeElevation(meta?.elevation);
+  return {
+    latitude: nLat ?? lat,
+    longitude: nLng ?? lng,
+    ...sphere ? { sphere } : {},
+    ...isString(meta?.city) && !isEmpty(meta.city) ? { city: meta.city.trim() } : {},
+    ...isString(meta?.country) && !isEmpty(meta.country) ? { country: meta.country.trim() } : {},
+    ...elevation !== void 0 ? { elevation } : {},
+    ...isString(meta?.timezone) && !isEmpty(meta.timezone) ? { timezone: meta.timezone.trim() } : {}
+  };
+};
+var extractCustomProperties = (source, excludedKeys = GEO_PROPERTIES) => {
+  const custom = {};
+  if (isReference(source)) {
+    for (const key of Object.keys(source)) {
+      if (isSafeKey(key) && !excludedKeys.includes(key)) {
+        custom[key] = source[key];
       }
     }
-    return void 0;
   }
+  return custom;
+};
+var coerceGeo = (input) => {
+  const pair = parseCoordinatePair(input);
+  if (pair)
+    return assembleGeoConfig(pair);
   if (isPrimitive(input))
     return void 0;
-  if (Array.isArray(input) && input.length >= 2) {
-    const coords = normalizeCoords(input[0], input[1]);
-    if (coords) {
-      const result2 = { latitude: coords.lat, longitude: coords.lng };
-      const sphere2 = resolveSphere(void 0, coords.lat);
-      if (sphere2)
-        result2.sphere = sphere2;
-      return result2;
-    }
-    return void 0;
-  }
   const geo = input.geo ?? input;
   const cfg = input.config?.geo ?? input.config;
   const lat = evaluate(geo?.latitude, geo?.lat, input.latitude, input.lat, cfg?.latitude, cfg?.lat);
@@ -2870,8 +2907,9 @@ var coerceGeo = (input) => {
     result.latitude = nLat;
   if (nLng !== void 0)
     result.longitude = nLng;
-  if (isNumber(elevation))
-    result.elevation = Math.round(elevation * 1e3) / 1e3;
+  const nElevation = normalizeElevation(elevation);
+  if (nElevation !== void 0)
+    result.elevation = nElevation;
   const resolvedSphere = resolveSphere(sphere, result.latitude);
   if (resolvedSphere)
     result.sphere = resolvedSphere;
@@ -2882,12 +2920,8 @@ var coerceGeo = (input) => {
   if (isString(timezone))
     result.timezone = timezone;
   const explicitGeo = isReference(input.geo) ? input.geo : isReference(input.config?.geo) ? input.config.geo : void 0;
-  if (isReference(explicitGeo)) {
-    for (const key of Object.keys(explicitGeo)) {
-      if (isSafeKey(key) && !GEO_PROPERTIES.includes(key))
-        result[key] = explicitGeo[key];
-    }
-  }
+  const customKeys = extractCustomProperties(explicitGeo);
+  Object.assign(result, customKeys);
   return Object.keys(result).length > 0 ? result : void 0;
 };
 var resolveCacheKey = (keyOrOpts) => {
@@ -2924,35 +2958,23 @@ var getStashedGeo = (keyOrOpts) => {
         return void 0;
       }
     }
-    if (isString(parsed) && parsed.includes(",")) {
-      const parts = parsed.split(",").map((s) => parseFloat(s.trim()));
-      const coords = normalizeCoords(parts[0], parts[1]);
-      if (coords) {
-        return {
-          latitude: coords.lat,
-          longitude: coords.lng,
-          sphere: resolveSphere(void 0, coords.lat)
-        };
-      }
-    }
+    const pair = parseCoordinatePair(parsed);
+    if (pair)
+      return assembleGeoConfig(pair);
     if (isObject(parsed)) {
       const rawCoords = parsed.geolocation?.coords ?? parsed.coords ?? parsed;
       const lat = rawCoords?.latitude ?? rawCoords?.lat;
       const lng = rawCoords?.longitude ?? rawCoords?.lng ?? rawCoords?.lon ?? rawCoords?.long;
       const coords = normalizeCoords(lat, lng);
       if (coords) {
-        const result = { latitude: coords.lat, longitude: coords.lng };
         const elevation = parsed.elevation ?? rawCoords.elevation;
-        if (isNumber(elevation))
-          result.elevation = Math.round(elevation * 1e3) / 1e3;
-        result.sphere = resolveSphere(parsed.sphere, coords.lat);
-        if (isString(parsed.country))
-          result.country = parsed.country;
-        if (isString(parsed.city))
-          result.city = parsed.city;
-        if (isString(parsed.timezone))
-          result.timezone = parsed.timezone;
-        return result;
+        return assembleGeoConfig(coords, {
+          elevation,
+          sphere: parsed.sphere,
+          country: parsed.country,
+          city: parsed.city,
+          timezone: parsed.timezone
+        });
       }
     }
   } catch {
@@ -2982,7 +3004,7 @@ var geoLookup = async (opts = {}) => {
     const stashed = getStashedGeo(opts);
     if (stashed && isNumber(stashed.latitude) && isNumber(stashed.longitude)) {
       const { latitude, longitude, ...rest } = stashed;
-      return {
+      const cachedRes = {
         ...rest,
         status: "cached",
         lat: latitude,
@@ -2990,6 +3012,17 @@ var geoLookup = async (opts = {}) => {
         latitude,
         longitude
       };
+      const shouldReverse = opts.reverse === true || opts.autoReverse === true;
+      if (shouldReverse && (!cachedRes.city || !cachedRes.country)) {
+        const reversed = await reverseGeocode(cachedRes, opts);
+        if (reversed) {
+          if (!cachedRes.city && isText(reversed.city))
+            cachedRes.city = reversed.city;
+          if (!cachedRes.country && isText(reversed.country))
+            cachedRes.country = reversed.country;
+        }
+      }
+      return cachedRes;
     }
   }
   let res;
@@ -3043,15 +3076,17 @@ var geoLookup = async (opts = {}) => {
     res.latitude = coords.lat;
     res.longitude = coords.lng;
     res.sphere = sphere;
-    const stashPayload = {
-      latitude: coords.lat,
-      longitude: coords.lng,
-      sphere,
-      ...isString(res.city) ? { city: res.city } : {},
-      ...isString(res.country) ? { country: res.country } : {},
-      ...isNumber(res.elevation) ? { elevation: Math.round(res.elevation * 1e3) / 1e3 } : {},
-      ...isString(res.timezone) ? { timezone: res.timezone } : {}
-    };
+    const shouldReverse = opts.reverse === true || opts.autoReverse === true;
+    if (shouldReverse && (!res.city || !res.country)) {
+      const reversed = await reverseGeocode(res, opts);
+      if (reversed) {
+        if (!res.city && isText(reversed.city))
+          res.city = reversed.city;
+        if (!res.country && isText(reversed.country))
+          res.country = reversed.country;
+      }
+    }
+    const stashPayload = assembleGeoConfig(coords, res);
     try {
       const ttl = isNumber(opts.ttl) ? opts.ttl : DEFAULT_GEO_TTL;
       stashGeo(stashPayload, ttl, opts);
@@ -3060,471 +3095,266 @@ var geoLookup = async (opts = {}) => {
   }
   return res;
 };
+var requestModulePromise2 = null;
+var getRequestModule2 = () => {
+  if (!requestModulePromise2)
+    requestModulePromise2 = Promise.resolve().then(() => (init_request_library(), request_library_exports));
+  return requestModulePromise2;
+};
+var reverseGeoCache = new BoundedCache(DEFAULT_SPATIAL_CACHE_SIZE, DEFAULT_GEO_TTL);
+var isValidGeoEndpoint = (urlStr) => {
+  try {
+    const parsed = new URL(urlStr);
+    return parsed.protocol === "https:" || parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+  } catch {
+    return false;
+  }
+};
+var getSpatialCacheKey = (lat, lng, sourceOrOpts) => {
+  const bucket = `${lat.toFixed(2)},${lng.toFixed(2)}`;
+  if (isString(sourceOrOpts) && !isEmpty(sourceOrOpts)) {
+    return `${bucket}:${sourceOrOpts.trim()}`;
+  }
+  if (isObject(sourceOrOpts)) {
+    const hasExplicitProvider = Object.hasOwn(sourceOrOpts, "provider");
+    const provider = hasExplicitProvider ? sourceOrOpts.provider : activeGeoProvider;
+    const providerName = provider && isString(provider.name) && !isEmpty(provider.name) ? provider.name.trim() : void 0;
+    const rawEndpoint = isString(sourceOrOpts.reverseEndpoint ?? sourceOrOpts.reverseGeoEndpoint) && !isEmpty(sourceOrOpts.reverseEndpoint ?? sourceOrOpts.reverseGeoEndpoint) ? (sourceOrOpts.reverseEndpoint ?? sourceOrOpts.reverseGeoEndpoint).trim() : void 0;
+    const endpoint = rawEndpoint && isValidGeoEndpoint(rawEndpoint) ? rawEndpoint : void 0;
+    if (providerName && endpoint)
+      return `${bucket}:${providerName}:${endpoint}`;
+    if (providerName)
+      return `${bucket}:${providerName}`;
+    if (endpoint)
+      return `${bucket}:${endpoint}`;
+  } else if (activeGeoProvider && isString(activeGeoProvider.name) && !isEmpty(activeGeoProvider.name)) {
+    return `${bucket}:${activeGeoProvider.name.trim()}`;
+  }
+  return bucket;
+};
 async function reverseGeocode(coords, opts) {
-  const provider = opts?.provider ?? activeGeoProvider;
+  const coerced = coerceGeo(coords);
+  if (!coerced || !isNumber(coerced.latitude) || !isNumber(coerced.longitude))
+    return null;
+  const lat = coerced.latitude;
+  const lng = coerced.longitude;
+  const key = getSpatialCacheKey(lat, lng, opts);
+  const useCache = opts?.refresh !== true;
+  if (useCache) {
+    const cached = reverseGeoCache.get(key);
+    if (cached) {
+      return {
+        ...cached,
+        latitude: lat,
+        longitude: lng,
+        sphere: resolveSphere(cached.sphere, lat),
+        elevation: isNumber(cached.elevation) ? cached.elevation : coerced.elevation,
+        timezone: isString(cached.timezone) ? cached.timezone : coerced.timezone
+      };
+    }
+  }
+  const hasExplicitProvider = isObject(opts) && Object.hasOwn(opts, "provider");
+  const provider = hasExplicitProvider ? opts.provider : activeGeoProvider;
   if (provider && isFunction(provider.reverseGeocode)) {
-    return provider.reverseGeocode(coords, opts);
+    try {
+      const res = await provider.reverseGeocode(coerced, opts);
+      if (res && isObject(res)) {
+        const result = assembleGeoConfig({ lat, lng }, {
+          sphere: res.sphere,
+          city: res.city,
+          country: res.country,
+          elevation: isNumber(res.elevation) ? res.elevation : coerced.elevation,
+          timezone: isString(res.timezone) ? res.timezone : coerced.timezone
+        });
+        const cachePayload = assembleGeoConfig({ lat, lng }, {
+          sphere: res.sphere,
+          city: res.city,
+          country: res.country,
+          timezone: res.timezone
+        });
+        reverseGeoCache.set(key, cachePayload);
+        return result;
+      }
+      if (opts?.fallback === false)
+        return null;
+    } catch (err) {
+      if (opts?.fallback === false)
+        throw err;
+    }
+  } else if (opts?.fallback === false && (provider || hasExplicitProvider)) {
+    return null;
   }
-  const resolved = coerceGeo(coords);
-  return resolved ?? null;
+  const rawReverseEndpoint = opts?.reverseEndpoint ?? opts?.reverseGeoEndpoint;
+  if (isText(rawReverseEndpoint)) {
+    const rawEndpoint = rawReverseEndpoint.trim();
+    if (!isValidGeoEndpoint(rawEndpoint))
+      return opts?.fallback === false ? null : coerced;
+  }
+  const customEndpoint = isText(rawReverseEndpoint) ? rawReverseEndpoint.trim() : void 0;
+  const fallbackKey = getSpatialCacheKey(lat, lng, customEndpoint ?? "default");
+  if (useCache) {
+    const cachedFallback = reverseGeoCache.get(fallbackKey);
+    if (cachedFallback) {
+      return {
+        ...cachedFallback,
+        latitude: lat,
+        longitude: lng,
+        sphere: resolveSphere(cachedFallback.sphere, lat),
+        elevation: isNumber(cachedFallback.elevation) ? cachedFallback.elevation : coerced.elevation,
+        timezone: isString(cachedFallback.timezone) ? cachedFallback.timezone : coerced.timezone
+      };
+    }
+  }
+  let endpoint;
+  if (customEndpoint) {
+    if (/\{(?:latitude|lat|longitude|lng|lon)\}/i.test(customEndpoint)) {
+      endpoint = customEndpoint.replace(/\{latitude\}/gi, encodeURIComponent(lat)).replace(/\{lat\}/gi, encodeURIComponent(lat)).replace(/\{longitude\}/gi, encodeURIComponent(lng)).replace(/\{lng\}/gi, encodeURIComponent(lng)).replace(/\{lon\}/gi, encodeURIComponent(lng));
+    } else {
+      const sep = customEndpoint.includes("?") ? "&" : "?";
+      endpoint = `${customEndpoint}${sep}latitude=${encodeURIComponent(lat)}&longitude=${encodeURIComponent(lng)}`;
+    }
+  } else {
+    endpoint = `${DEFAULT_REVERSE_GEO_ENDPOINT}?latitude=${lat}&longitude=${lng}&localityLanguage=en`;
+  }
+  try {
+    const timeout = isNumber(opts?.timeout) && opts.timeout > 0 ? opts.timeout : DEFAULT_REVERSE_GEO_TIMEOUT;
+    const maxBytes = isNumber(opts?.maxBytes) && opts.maxBytes > 0 ? opts.maxBytes : DEFAULT_REVERSE_GEO_MAX_BYTES;
+    const { fetchRequest: fetchRequest2 } = await getRequestModule2();
+    const data = await fetchRequest2(endpoint, {}, { timeout, maxBytes });
+    if (isObject(data)) {
+      const city = isText(data.city) ? data.city.trim() : isText(data.locality) ? data.locality.trim() : isText(data.principalSubdivision) ? data.principalSubdivision.trim() : void 0;
+      const country = isText(data.countryCode) ? data.countryCode.trim() : isText(data.countryName) ? data.countryName.trim() : void 0;
+      const result = assembleGeoConfig({ lat, lng }, {
+        city,
+        country,
+        elevation: coerced.elevation,
+        timezone: coerced.timezone
+      });
+      if (isText(city) || isText(country)) {
+        const cachePayload = assembleGeoConfig({ lat, lng }, {
+          city,
+          country
+        });
+        reverseGeoCache.set(fallbackKey, cachePayload);
+      }
+      return result;
+    }
+  } catch {
+  }
+  return coerced;
 }
 async function forwardGeocode(query, opts) {
   const provider = opts?.provider ?? activeGeoProvider;
-  if (provider && isFunction(provider.forwardGeocode)) {
-    return provider.forwardGeocode(query, opts);
-  }
-  return null;
+  return provider && isFunction(provider.forwardGeocode) ? provider.forwardGeocode(query, opts) : null;
 }
 var resolveGeoCoordinates = async (input, opts = {}) => {
+  const effectiveOpts = isObject(input) ? { ...input, ...opts } : opts;
   const coerced = coerceGeo(input);
-  if (coerced && isNumber(coerced.latitude) && isNumber(coerced.longitude))
+  if (coerced && isNumber(coerced.latitude) && isNumber(coerced.longitude)) {
+    const shouldReverse = effectiveOpts.reverse === true || effectiveOpts.autoReverse === true;
+    if (shouldReverse && (!coerced.city || !coerced.country)) {
+      const reversed = await reverseGeocode(coerced, effectiveOpts);
+      if (reversed) {
+        return {
+          ...reversed,
+          ...coerced,
+          city: isText(coerced.city) ? coerced.city : reversed.city,
+          country: isText(coerced.country) ? coerced.country : reversed.country,
+          lat: coerced.latitude,
+          lng: coerced.longitude,
+          latitude: coerced.latitude,
+          longitude: coerced.longitude
+        };
+      }
+    }
     return {
       ...coerced,
       lat: coerced.latitude,
       lng: coerced.longitude
     };
-  const stashed = opts.refresh === true ? void 0 : getStashedGeo(opts);
-  if (stashed && isNumber(stashed.latitude) && isNumber(stashed.longitude))
+  }
+  const stashed = effectiveOpts.refresh === true ? void 0 : getStashedGeo(effectiveOpts);
+  if (stashed && isNumber(stashed.latitude) && isNumber(stashed.longitude)) {
+    const shouldReverse = effectiveOpts.reverse === true || effectiveOpts.autoReverse === true;
+    if (shouldReverse && (!stashed.city || !stashed.country)) {
+      const reversed = await reverseGeocode(stashed, effectiveOpts);
+      if (reversed) {
+        return {
+          ...reversed,
+          ...stashed,
+          city: isText(stashed.city) ? stashed.city : reversed.city,
+          country: isText(stashed.country) ? stashed.country : reversed.country,
+          lat: stashed.latitude,
+          lng: stashed.longitude,
+          latitude: stashed.latitude,
+          longitude: stashed.longitude
+        };
+      }
+    }
     return {
       ...stashed,
       lat: stashed.latitude,
       lng: stashed.longitude
     };
-  const lookup = await geoLookup(opts);
+  }
+  const lookup = await geoLookup(effectiveOpts);
   const coords = normalizeCoords(lookup.lat, lookup.lng);
   if (isNullish(lookup.error) && coords) {
     const sphere = resolveSphere(lookup.sphere, coords.lat);
-    return {
-      ...lookup,
+    const base = {
+      ...assembleGeoConfig(coords, { ...lookup, sphere }),
       lat: coords.lat,
       lng: coords.lng,
       latitude: coords.lat,
       longitude: coords.lng,
       sphere
     };
-  }
-  return null;
-};
-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 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;
-  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));
-  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 (isDefined(globalThis.Temporal) && isFunction(globalThis.Temporal.Instant?.fromEpochMilliseconds)) {
-      const zdt = Temporal.Instant.fromEpochMilliseconds(epochMs).toZonedDateTimeISO(tz);
-      return zdt.offsetNanoseconds / 6e10;
-    }
-    const parts = new Intl.DateTimeFormat("en-US", {
-      timeZone: tz,
-      timeZoneName: "longOffset",
-      year: "numeric"
-    }).formatToParts(new Date(epochMs));
-    const tzPart = parts.find((p) => p.type === "timeZoneName")?.value;
-    if (tzPart) {
-      if (tzPart === "GMT" || tzPart === "UTC")
-        return 0;
-      const match = tzPart.match(/GMT([+-])(\d{2}):(\d{2})/);
-      if (match) {
-        const sign = match[1] === "-" ? -1 : 1;
-        return sign * (parseInt(match[2], 10) * 60 + parseInt(match[3], 10));
-      }
-    }
-  } catch {
-  }
-  return void 0;
-};
-function solarOffset(coords, options) {
-  const geo = coerceGeo(coords);
-  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) ? 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;
-  const deltaLng = lng - refMeridian;
-  let offsetMin = deltaLng * 4;
-  if (options?.apparent) {
-    const d = new Date(epochMs);
-    const startOfYear = Date.UTC(d.getUTCFullYear(), 0, 1);
-    const dayOfYear = Math.floor((epochMs - startOfYear) / 864e5) + 1;
-    const gamma = 2 * Math.PI / 365 * (dayOfYear - 1);
-    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 ?? "mi";
-  let res;
-  if (unit === "ss" || unit === "seconds") {
-    res = offsetMin * 60;
-  } else if (unit === "hh" || unit === "hours") {
-    res = offsetMin / 60;
-  } else {
-    res = offsetMin;
-  }
-  const precision = options?.precision ?? 2;
-  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 {
+    const shouldReverse = effectiveOpts.reverse === true || effectiveOpts.autoReverse === true;
+    if (shouldReverse && (!base.city || !base.country)) {
+      const reversed = await reverseGeocode(base, effectiveOpts);
+      if (reversed) {
+        return {
+          ...reversed,
+          ...base,
+          city: isText(base.city) ? base.city : reversed.city,
+          country: isText(base.country) ? base.country : reversed.country,
+          lat: coords.lat,
+          lng: coords.lng,
+          latitude: coords.lat,
+          longitude: coords.lng,
+          sphere
+        };
       }
     }
-    if (isFunction(input.getTime))
-      try {
-        return input.getTime();
-      } catch {
-      }
-  }
-  if (isString(input)) {
-    const parsed = Date.parse(input);
-    if (isNumber(parsed))
-      return parsed;
+    return base;
   }
-  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"
+  return null;
 };
-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();
-import { isString as isString2, isNumber as isNumber2, isObject as isObject2, isEmpty as isEmpty2, isSafeKey as isSafeKey2 } from "@magmacomputing/tempo/library";
+init_assertion_library();
+import {
+  resolveCulturalLocale
+} from "@magmacomputing/tempo-fns";
+var NON_GEO_CONTROL_KEYS = [
+  "setTimezone",
+  "setLocale",
+  "refresh",
+  "ttl",
+  "endpoint",
+  "timeout",
+  "maxBytes",
+  "highAccuracy",
+  "catch",
+  "debug",
+  "geo",
+  "provider",
+  "fallback",
+  "reverse",
+  "autoReverse"
+];
 var GeoPlugin = definePlugin({
   name: "geo",
   install(TempoClass, options) {
@@ -3535,10 +3365,10 @@ var GeoPlugin = definePlugin({
       const classOpts = installedClass.config?.pluginOptions?.geo;
       const instanceOpts = instance?.config?.pluginOptions?.geo;
       return {
-        ...isObject2(options) ? options : {},
-        ...isObject2(classOpts) ? classOpts : {},
-        ...isObject2(instanceOpts) ? instanceOpts : {},
-        ...isObject2(callSiteOpts) ? callSiteOpts : {}
+        ...isObject(options) ? options : {},
+        ...isObject(classOpts) ? classOpts : {},
+        ...isObject(instanceOpts) ? instanceOpts : {},
+        ...isObject(callSiteOpts) ? callSiteOpts : {}
       };
     };
     if (!Object.hasOwn(installedClass, "geo")) {
@@ -3546,14 +3376,6 @@ var GeoPlugin = definePlugin({
         lookup: (opts) => geoLookup(getEffectiveOptions(opts)),
         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,
@@ -3580,38 +3402,39 @@ var GeoPlugin = definePlugin({
       const setLocale = effectiveOpts?.setLocale ?? true;
       const coords = await resolveGeoCoordinates(this, effectiveOpts);
       if (coords) {
-        const existingGeo = isObject2(this.config.geo) ? this.config.geo : {};
+        const existingGeo = isObject(this.config.geo) ? this.config.geo : {};
         const customKeys = {};
         for (const key of Object.keys(existingGeo)) {
-          if (isSafeKey2(key) && !GEO_PROPERTIES.includes(key))
+          if (isSafeKey(key) && !GEO_PROPERTIES.includes(key))
             customKeys[key] = existingGeo[key];
         }
         const callSiteGeo = coerceGeo(opts) ?? {};
-        if (isObject2(opts)) {
+        if (isObject(opts)) {
           for (const key of Object.keys(opts)) {
-            if (isSafeKey2(key) && !["setTimezone", "setLocale", "refresh", "ttl", "endpoint", "timeout", "catch", "debug", "geo", "provider", "fallback"].includes(key)) {
+            if (isSafeKey(key) && !NON_GEO_CONTROL_KEYS.includes(key)) {
               if (!GEO_PROPERTIES.includes(key))
                 customKeys[key] = opts[key];
             }
           }
         }
-        const preservedElevation = isNumber2(coords?.elevation) ? coords.elevation : isNumber2(existingGeo.elevation) ? existingGeo.elevation : void 0;
+        const preservedElevation = isNumber(coords?.elevation) ? coords.elevation : isNumber(existingGeo.elevation) ? existingGeo.elevation : void 0;
         const mergedGeo = {
           ...customKeys,
           ...coords,
-          ...isNumber2(preservedElevation) ? { elevation: preservedElevation } : {},
+          ...isNumber(preservedElevation) ? { elevation: preservedElevation } : {},
           ...callSiteGeo
         };
-        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";
-        }
+        const lat = mergedGeo.latitude;
+        const lng = mergedGeo.longitude;
+        if (isNumber(lat)) mergedGeo.latitude = Math.round(lat * 1e3) / 1e3;
+        if (isNumber(lng)) mergedGeo.longitude = Math.round(lng * 1e3) / 1e3;
+        if (!mergedGeo.sphere && isNumber(lat))
+          mergedGeo.sphere = lat > 1e-3 ? "north" : lat < -1e-3 ? "south" : "equator";
         let instance = this;
         const targetTz = mergedGeo.timezone;
-        if (setTimezone && isString2(targetTz) && !isEmpty2(targetTz))
+        if (setTimezone && isString(targetTz) && !isEmpty(targetTz))
           instance = this.set({ timeZone: targetTz });
-        const targetLocale = mergedGeo.country || isString2(setLocale) ? resolveCulturalLocale(this.locale ?? this.config.locale, mergedGeo.country, setLocale) : void 0;
+        const targetLocale = mergedGeo.country || isString(setLocale) ? resolveCulturalLocale(this.locale ?? this.config.locale, mergedGeo.country, setLocale) : void 0;
         return new TempoClass(instance, {
           ...instance.config,
           ...targetLocale ? { locale: targetLocale } : {},
@@ -3624,12 +3447,6 @@ var GeoPlugin = definePlugin({
     TempoClass.prototype.geoLookup = async function(opts) {
       return resolveGeoCoordinates(this, getEffectiveOptions(opts, this));
     };
-    TempoClass.prototype.geoDistance = function(other, unit) {
-      return haversineDistance(this, other, unit);
-    };
-    TempoClass.prototype.geoSolarOffset = function(options2) {
-      return solarOffset(this, options2);
-    };
   }
 });
 var geoPlugin = GeoPlugin;
@@ -3637,9 +3454,7 @@ var index_default = GeoPlugin;
 export {
   GEO_PROPERTIES,
   GeoPlugin,
-  calculateBearing,
-  calculateMidpoint,
-  calculateVelocity,
+  NON_GEO_CONTROL_KEYS,
   clearStashedGeo,
   coerceGeo,
   index_default as default,
@@ -3649,10 +3464,6 @@ export {
   geoPlugin,
   getGeoProvider,
   getStashedGeo,
-  haversineDistance,
-  inBoundingBox,
-  isImpossibleTravel,
-  isWithin,
   resolveCulturalLocale,
   resolveGeoCoordinates,
   reverseGeocode,
@@ -3660,6 +3471,5 @@ export {
   serverGeoLocation,
   serverMapHemisphere,
   setGeoProvider,
-  solarOffset,
   stashGeo
 };