@magmacomputing/tempo-plugin-geo 1.0.0 → 1.2.0

package/dist/index.js

@@ -257,32 +257,55 @@ var init_type_library = __esm({
 });
 
 // ../../library/dist/common/primitives/assertion.library.js
-var isType, isPrimitive, isReference, isString, isText, isNumber, isInteger, isArray, isObject, isDate, isSymbol, isSymbolFor, isSafeKey, isNullish, isUndefined, isDefined, isFunction, isMap, isSet, isError, isEmpty;
+function isNumeric(str) {
+  const type = typeof str;
+  switch (type) {
+    case "number":
+      return Number.isFinite(str);
+    case "bigint":
+      return true;
+    case "string": {
+      const val = str.trim();
+      if (val.length === 0)
+        return false;
+      return RE_BIGINT_LITERAL.test(val) || isNumber(Number(val));
+    }
+    default:
+      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 init_assertion_library = __esm({
   "../../library/dist/common/primitives/assertion.library.js"() {
     "use strict";
     init_symbol_library();
     init_type_library();
     isType = (obj, ...types) => types.includes(getType(obj));
-    isPrimitive = (obj) => isType(obj, "String", "Number", "BigInt", "Boolean", "Symbol", "Undefined", "Void", "Null", "Empty");
+    isPrimitive = (obj) => obj === null || typeof obj !== "object" && typeof obj !== "function";
     isReference = (obj) => !isPrimitive(obj);
-    isString = (obj) => isType(obj, "String");
-    isText = (obj) => isString(obj) && obj.trim().length > 0;
+    isIterable = (obj) => Symbol.iterator in Object(obj) && !isString(obj);
+    isString = (obj) => typeof obj === "string";
+    isText = (obj) => typeof obj === "string" && obj.trim().length > 0;
     isNumber = (obj) => Number.isFinite(obj);
-    isInteger = (obj) => isType(obj, "BigInt");
-    isArray = (obj) => isType(obj, "Array");
+    RE_BIGINT_LITERAL = /^[+-]?[0-9]+n$/;
+    isInteger = (obj) => typeof obj === "bigint";
+    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");
     isDate = (obj) => isType(obj, "Date");
-    isSymbol = (obj) => isType(obj, "Symbol");
-    isSymbolFor = (obj) => isType(obj, "Symbol") && Symbol.keyFor(obj) !== void 0;
+    isRegExp = (obj) => isType(obj, "RegExp");
+    isSymbol = (obj) => typeof obj === "symbol";
+    isSymbolFor = (obj) => typeof obj === "symbol" && Symbol.keyFor(obj) !== void 0;
     isSafeKey = (key) => key !== "__proto__" && key !== "constructor" && key !== "prototype";
-    isNullish = (obj) => isType(obj, "Null", "Undefined", "Void", "Empty");
-    isUndefined = (obj) => isType(obj, "Undefined", "Void", "Empty");
-    isDefined = (obj) => !isNullish(obj);
+    isNullish = (obj) => obj === null || obj === void 0 || isType(obj, "Void", "Empty");
+    isUndefined = (obj) => obj === void 0 || isType(obj, "Void", "Empty");
+    isDefined = (obj) => obj !== null && obj !== void 0 && !isNullish(obj);
     isFunction = (obj) => isType(obj, "Function", "AsyncFunction", "GeneratorFunction", "AsyncGeneratorFunction");
+    isCallable = (obj) => typeof obj === "function";
     isMap = (obj) => isType(obj, "Map");
     isSet = (obj) => isType(obj, "Set");
     isError = (err, constructor) => isType(err, "Error") && (constructor ? err instanceof constructor : true);
+    isLocale = (obj) => typeof Intl !== "undefined" && typeof Intl.Locale === "function" && obj instanceof Intl.Locale;
     isEmpty = (obj) => isNullish(obj) || isObject(obj) && Reflect.ownKeys(obj).length === 0 || isString(obj) && obj.trim().length === 0 || typeof obj === "number" && Number.isNaN(obj) || isArray(obj) && obj.length === 0 || isSet(obj) && obj.size === 0 || isMap(obj) && obj.size === 0 || ArrayBuffer.isView(obj) && obj.byteLength === 0 || isDate(obj) && Number.isNaN(obj.getTime());
   }
 });
@@ -514,6 +537,8 @@ function serialize(val, seen = /* @__PURE__ */ new WeakSet()) {
       if (seen.has(value2))
         return "<Circular>";
       seen.add(value2);
+      if (isLocale(value2))
+        return value2.toString();
       if (isMap(value2))
         return `map:[${Array.from(value2.entries()).map((e) => serialize(e, seen)).sort().join(",")}]`;
       if (isSet(value2))
@@ -570,15 +595,86 @@ var init_function_library = __esm({
 });
 
 // ../../library/dist/common/runtime/json.library.js
+function cleanify(obj) {
+  try {
+    return JSON.parse(JSON.stringify(obj));
+  } catch (error) {
+    console.warn("Could not clean object:", error?.message ?? error);
+    throw error;
+  }
+}
 var init_json_library = __esm({
   "../../library/dist/common/runtime/json.library.js"() {
     "use strict";
+    init_assertion_library();
+  }
+});
+
+// ../../library/dist/common/primitives/object.library.js
+function looseIndex(arg) {
+  if (isDefined(arg))
+    return isFunction(arg) ? arg() : arg;
+  return (obj) => isFunction(obj) ? obj() : obj;
+}
+var getObjectKeys, asObject;
+var init_object_library = __esm({
+  "../../library/dist/common/primitives/object.library.js"() {
+    "use strict";
+    init_primitive_library();
+    init_assertion_library();
+    init_type_library();
+    getObjectKeys = (obj) => {
+      const keys = /* @__PURE__ */ new Set();
+      let curr = obj;
+      let depth = 0;
+      while (curr && curr !== Object.prototype && depth++ < 10) {
+        const descs = Object.getOwnPropertyDescriptors(curr);
+        for (const [key, desc] of Object.entries(descs)) {
+          if (!isSafeKey(key))
+            continue;
+          if (desc.enumerable || isFunction(desc.get)) {
+            keys.add(key);
+          }
+        }
+        curr = Object.getPrototypeOf(curr);
+      }
+      return Array.from(keys);
+    };
+    asObject = (obj) => {
+      if (isPrimitive(obj) || isFunction(obj))
+        return obj;
+      if (isArray(obj))
+        return obj.map((item) => asObject(item));
+      if (isDate(obj) || isRegExp(obj) || isMap(obj) || isSet(obj))
+        return obj;
+      try {
+        if (isFunction(obj.toJSON))
+          return asObject(obj.toJSON());
+      } catch {
+      }
+      const temp = {};
+      for (const key of getObjectKeys(obj)) {
+        try {
+          temp[key] = asObject(obj[key]);
+        } catch {
+        }
+      }
+      return temp;
+    };
+    looseIndex.stringSymbol = looseIndex();
+    looseIndex.symbolRegExp = looseIndex();
+    looseIndex.symbolString = looseIndex();
+    looseIndex.stringString = looseIndex();
   }
 });
 
 // ../../library/dist/common/runtime/serialize.library.js
-function replacer(key, obj) {
-  return isEmpty(key) ? obj : stringize(obj);
+function clone(obj, opts) {
+  try {
+    return globalThis.structuredClone(obj, opts);
+  } catch {
+    return cleanify(obj);
+  }
 }
 function reviver(_key, val) {
   return decode(val);
@@ -624,19 +720,34 @@ function toSymbol(value2) {
       return Symbol(desc);
   }
 }
-function stringify(obj) {
-  return stringize(obj, false);
+function stringify(obj, options) {
+  const prevCompact = activeCompact;
+  activeCompact = options?.compact !== false;
+  try {
+    const str = stringize(obj, false);
+    if (options?.signed) {
+      if (!isString(options.secret) || !options.secret)
+        throw new TypeError("stringify: signed serialization requires an explicit secret string");
+      return `$sig:${fastDigest(str, options.secret)}:${str}`;
+    }
+    return str;
+  } finally {
+    activeCompact = prevCompact;
+  }
 }
 function stringize(obj, recurse = true) {
   const arg = asType(obj);
   const one = curry(oneKey)(arg.type);
   switch (arg.type) {
-    case "String":
+    case "String": {
+      let strVal = arg.value;
+      if (strVal.startsWith("~"))
+        strVal = `~${strVal}`;
       if (!recurse) {
-        recurse = arg.value === "true" || arg.value === "false" || arg.value === "null" || parseFloat(arg.value).toString() === arg.value;
+        recurse = strVal === "true" || strVal === "false" || strVal === "null" || parseFloat(strVal).toString() === strVal || strVal.startsWith("~");
       }
-      return recurse ? JSON.stringify(encode(arg.value)) : encode(arg.value);
-    // dont JSON.stringify a top-level string
+      return recurse ? JSON.stringify(encode(strVal)) : encode(strVal);
+    }
     case "Boolean":
     case "Null":
     case "Number":
@@ -644,11 +755,13 @@ function stringize(obj, recurse = true) {
     // JSON.stringify will correctly handle these
     case "Void":
     case "Undefined":
-      return one(JSON.stringify("void"));
+      return activeCompact ? JSON.stringify("~u") : one(JSON.stringify("void"));
     // preserve 'undefined' values		
     case "BigInt":
-      return one(arg.value.toString());
+      return activeCompact ? JSON.stringify(`~n${arg.value.toString()}`) : one(arg.value.toString());
     // even though BigInt has a toString method, it is not supported in JSON.stringify
+    case "Date":
+      return activeCompact ? JSON.stringify(`~t${arg.value.getTime()}`) : one(stringize(arg.value.toJSON()));
     case "Object": {
       const obj2 = ownEntries(arg.value).filter(([, val]) => isStringable(val)).map(([key, val]) => `${fromSymbol(key)}: ${stringize(val)}`).join(",");
       return `{${obj2}}`;
@@ -665,8 +778,10 @@ function stringize(obj, recurse = true) {
       const set = Array.from(arg.value.values()).filter((val) => isStringable(val)).map((val) => stringize(val)).join(",");
       return one(`[${set}]`);
     }
-    case "Symbol":
-      return one(fromSymbol(arg.value));
+    case "Symbol": {
+      const symStr = `${isSymbolFor(arg.value) ? "@" : ""}@(${arg.value.description ?? ""})`;
+      return activeCompact ? JSON.stringify(`~y${symStr}`) : one(JSON.stringify(symStr));
+    }
     case "RegExp":
       return one(stringize({ source: arg.value.source, flags: arg.value.flags }));
     case "Class":
@@ -677,21 +792,55 @@ function stringize(obj, recurse = true) {
           return void 0;
         case isFunction(value2.toJSON):
           return one(stringize(value2.toJSON()));
-        case isFunction(value2.toString): {
+        case (isFunction(value2.toString) && value2.toString !== Object.prototype.toString): {
           const str = value2.toString();
           return one(str.includes('"') ? str : JSON.stringify(str));
         }
-        case isFunction(value2.valueOf):
+        case (isFunction(value2.valueOf) && value2.valueOf !== Object.prototype.valueOf):
           return one(JSON.stringify(value2.valueOf()));
-        default:
-          return one(JSON.stringify(value2, replacer));
+        default: {
+          const plain = asObject(value2);
+          return isReference(plain) && Object.keys(plain).length > 0 ? stringize(plain) : one(JSON.stringify(value2, (key, o) => isEmpty(key) ? o : stringize(o)));
+        }
       }
     }
   }
 }
-function objectify(str, sentinel) {
+function objectify(str, optionsOrSentinel) {
   if (!isString(str))
     return str;
+  const options = isFunction(optionsOrSentinel) ? { sentinel: optionsOrSentinel } : optionsOrSentinel ?? {};
+  if (str.startsWith("$sig:")) {
+    const secondColon = str.indexOf(":", 5);
+    if (secondColon !== -1) {
+      const sig = str.substring(5, secondColon);
+      const payload = str.substring(secondColon + 1);
+      if (!isString(options.secret) || !options.secret) {
+        console.warn("objectify: signature verification requires an explicit secret string");
+        if (options.throwOnError)
+          throw new TypeError("objectify: signature verification requires an explicit secret string");
+        return str;
+      }
+      const expectedSig = fastDigest(payload, options.secret);
+      if (!constantTimeEqual(sig, expectedSig)) {
+        console.warn("objectify: signature verification failed");
+        if (options.throwOnError)
+          throw new Error("objectify: signature verification failed");
+        return str;
+      }
+      str = payload;
+    } else if (options.requireSigned) {
+      console.warn("objectify: malformed signed payload");
+      if (options.throwOnError)
+        throw new Error("objectify: malformed signed payload");
+      return str;
+    }
+  } else if (options.requireSigned) {
+    console.warn("objectify: unsigned string rejected by requireSigned policy");
+    if (options.throwOnError)
+      throw new Error("objectify: unsigned string rejected by requireSigned policy");
+    return str;
+  }
   let parse;
   try {
     parse = JSON.parse(str, reviver);
@@ -700,28 +849,50 @@ function objectify(str, sentinel) {
       console.warn(`objectify.parse: -> ${str}, ${error.message}`);
       return str;
     } else
-      return objectify(`"${str}"`, sentinel);
+      return objectify(`"${str}"`, options.requireSigned ? { ...options, requireSigned: false } : options);
   }
   switch (true) {
     case (str.startsWith("{") && str.endsWith("}")):
     // looks like Object
     case (str.startsWith("[") && str.endsWith("]")):
-      return traverse(parse, sentinel);
+      return traverse(parse, options, 0);
     // recurse into object
     default:
-      return parse;
+      return typeify(parse, options);
   }
 }
-function traverse(obj, sentinel) {
+function traverse(obj, options, depth = 0) {
+  const maxDepth = options.maxDepth ?? MAX_TRAVERSE_DEPTH;
+  if (depth >= maxDepth)
+    return obj;
   if (isObject(obj)) {
-    return typeify(ownEntries(obj).reduce((acc, [key, val]) => Object.assign(acc, { [toSymbol(key)]: typeify(traverse(val, sentinel)) }), {}), sentinel);
+    return typeify(ownEntries(obj).filter(([key]) => isSafeKey(key)).reduce((acc, [key, val]) => Object.assign(acc, { [toSymbol(key)]: typeify(traverse(val, options, depth + 1), options) }), {}), options);
   }
   if (isArray(obj)) {
-    return ownValues(obj).map((val) => typeify(traverse(val, sentinel)));
+    return ownValues(obj).map((val) => typeify(traverse(val, options, depth + 1), options));
   }
-  return obj;
+  return typeify(obj, options);
 }
-function typeify(json, sentinel) {
+function typeify(json, options) {
+  if (isString(json) && json.startsWith("~")) {
+    try {
+      if (json.startsWith("~~"))
+        return json.substring(1);
+      if (json.startsWith("~n"))
+        return BigInt(json.substring(2));
+      if (json.startsWith("~t")) {
+        const timeVal = json.substring(2);
+        const d = new Date(isNumeric(timeVal) ? Number(timeVal) : timeVal);
+        return isNaN(d.getTime()) ? json : d;
+      }
+      if (json === "~u")
+        return options.sentinel?.();
+      if (json.startsWith("~y"))
+        return toSymbol(json.substring(2));
+    } catch {
+      return json;
+    }
+  }
   if (!isObject(json) || ownKeys(json).length !== 1)
     return json;
   const [$type, value2] = ownEntries(json)[0];
@@ -745,12 +916,14 @@ function typeify(json, sentinel) {
       case "Undefined":
       case "Empty":
       case "Void":
-        return sentinel?.();
+        return options.sentinel?.();
       // run Sentinel function to handle undefined values
       case "Date":
         return new Date(value2);
       case "RegExp":
-        if (!isObject(value2) || !isString(value2.source))
+        if (options.allowRegExp === false)
+          return json;
+        if (!isObject(value2) || !isString(value2.source) || value2.source.length > MAX_REGEXP_SOURCE_LENGTH)
           return json;
         return new RegExp(value2.source, value2.flags);
       case "Symbol":
@@ -763,25 +936,34 @@ function typeify(json, sentinel) {
         if (!isArray(value2))
           return json;
         return new Set(value2);
-      default:
+      default: {
+        if (options.allowClasses === false)
+          return json;
+        if (options.allowedClasses) {
+          const allowed = options.allowedClasses instanceof Set ? options.allowedClasses.has($type) || options.allowedClasses.has(type) : options.allowedClasses.includes($type) || options.allowedClasses.includes(type);
+          if (!allowed)
+            return json;
+        }
         const cls = Registry.get($type);
         if (!cls) {
           console.warn(`objectify: dont know how to deserialize '${type}'`);
           return json;
         }
         return Reflect.construct(cls, [value2]);
+      }
     }
   } catch {
     return json;
   }
 }
-var Registry, getSafeTag2, registerSerializable, SAFE_URI_MAP, RE_SAFE_URI_CODES, symKey;
+var Registry, getSafeTag2, registerSerializable, SAFE_URI_MAP, RE_SAFE_URI_CODES, symKey, RUNTIME_SALT, fastDigest, constantTimeEqual, activeCompact, MAX_TRAVERSE_DEPTH, MAX_REGEXP_SOURCE_LENGTH;
 var init_serialize_library = __esm({
   "../../library/dist/common/runtime/serialize.library.js"() {
     "use strict";
     init_function_library();
     init_primitive_library();
     init_json_library();
+    init_object_library();
     init_type_library();
     init_assertion_library();
     init_symbol_library();
@@ -824,6 +1006,31 @@ var init_serialize_library = __esm({
     };
     RE_SAFE_URI_CODES = new RegExp(Object.keys(SAFE_URI_MAP).join("|"), "gi");
     symKey = /^@(@)?\(([^\)]*)\)$/;
+    RUNTIME_SALT = globalThis.crypto?.randomUUID ? globalThis.crypto.randomUUID().split("-")[0] : Math.random().toString(36).slice(2, 10);
+    fastDigest = (str, secret = RUNTIME_SALT) => {
+      let h1 = 2166136261;
+      let h2 = 2654435769;
+      const input = `${secret}:${str}`;
+      for (let i = 0; i < input.length; i++) {
+        const c = input.charCodeAt(i);
+        h1 = Math.imul(h1 ^ c, 16777619);
+        h2 = Math.imul(h2 ^ c, 2246822507);
+      }
+      return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
+    };
+    constantTimeEqual = (a, b) => {
+      if (!isString(a) || !isString(b))
+        return false;
+      if (a.length !== b.length)
+        return false;
+      let result = 0;
+      for (let i = 0; i < a.length; i++)
+        result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+      return result === 0;
+    };
+    activeCompact = true;
+    MAX_TRAVERSE_DEPTH = 64;
+    MAX_REGEXP_SOURCE_LENGTH = 512;
   }
 });
 
@@ -917,7 +1124,7 @@ function StringTag(tagOrValue, context3) {
     }
     return value2;
   };
-  if (typeof tagOrValue === "function" && context3?.kind === "class")
+  if (isCallable(tagOrValue) && context3?.kind === "class")
     return applyTag(tagOrValue, void 0, context3.name);
   return (value2, ctx) => {
     return applyTag(value2, isString(tagOrValue) ? tagOrValue : void 0, ctx?.name);
@@ -1230,7 +1437,7 @@ var init_cache_class = __esm({
           this.evictExpired();
           const stringEntries = [];
           for (const [k, v] of super.entries()) {
-            if (typeof k === "string")
+            if (isString(k))
               stringEntries.push([k, v]);
           }
           return Object.fromEntries(stringEntries);
@@ -1354,7 +1561,7 @@ var init_storage_library = __esm({
     getSafeStorage = (name = "localStorage") => {
       try {
         const target = globalThis?.[name];
-        if (target && typeof target.getItem === "function" && typeof target.setItem === "function" && typeof target.removeItem === "function" && typeof target.clear === "function" && typeof target.key === "function" && typeof target.length === "number")
+        if (target && isCallable(target.getItem) && isCallable(target.setItem) && isCallable(target.removeItem) && isCallable(target.clear) && isCallable(target.key) && isNumber(target.length))
           return target;
       } catch {
       }
@@ -1378,37 +1585,6 @@ var init_storage_library = __esm({
   }
 });
 
-// ../../library/dist/common/primitives/object.library.js
-function looseIndex(arg) {
-  if (isDefined(arg))
-    return isFunction(arg) ? arg() : arg;
-  return (obj) => isFunction(obj) ? obj() : obj;
-}
-var asObject;
-var init_object_library = __esm({
-  "../../library/dist/common/primitives/object.library.js"() {
-    "use strict";
-    init_primitive_library();
-    init_assertion_library();
-    init_type_library();
-    asObject = (obj) => {
-      if (isNullish(obj) || !isObject(obj))
-        return obj;
-      const temp = isArray(obj) ? [] : {};
-      ownKeys(obj).forEach((key) => {
-        if (!isSafeKey(key))
-          return;
-        temp[key] = asObject(obj[key]);
-      });
-      return temp;
-    };
-    looseIndex.stringSymbol = looseIndex();
-    looseIndex.symbolRegExp = looseIndex();
-    looseIndex.symbolString = looseIndex();
-    looseIndex.stringString = looseIndex();
-  }
-});
-
 // ../../library/dist/common/primitives/string.library.js
 var init_string_library = __esm({
   "../../library/dist/common/primitives/string.library.js"() {
@@ -1419,6 +1595,10 @@ var init_string_library = __esm({
 });
 
 // ../../library/dist/common/primitives/coercion.library.js
+function asArray(arr = [], fill) {
+  const mapFn = (val) => isUndefined(fill) || isDefined(val) ? val : clone(fill);
+  return isArrayLike(arr) || isIterable(arr) && !isString(arr) ? Array.from(arr, mapFn) : [arr];
+}
 function asError(err) {
   if (isError(err))
     return err;
@@ -1486,55 +1666,87 @@ var init_temporal_library = __esm({
 });
 
 // ../../library/dist/common/runtime/international.library.js
-function getDateTimeFormat() {
-  return getDTF().resolvedOptions();
-}
-function getHemisphere(timeZone = getDateTimeFormat().timeZone) {
-  try {
-    const { jan, jul } = getOffsets(timeZone);
-    const southPrefixes = ["Australia", "Antarctica", "Africa/Johannesburg", "America/Argentina/Buenos_Aires", "America/Sao_Paulo"];
-    const isSouthZone = southPrefixes.some((p) => timeZone.startsWith(p));
-    switch (true) {
-      case jul > jan:
-        return "north";
-      case jul < jan:
-        return "south";
-      default:
-        return isSouthZone ? "south" : void 0;
-    }
-  } catch (e) {
+function getPropOrCall(obj, method, fallbackProp) {
+  if (!obj)
     return void 0;
-  }
+  if (isCallable(obj[method]))
+    return obj[method]();
+  if (fallbackProp && fallbackProp in obj)
+    return obj[fallbackProp];
+  return void 0;
+}
+function getFallbackFirstDay(region) {
+  if (!region)
+    return 1;
+  if (FRIDAY_START_REGIONS.has(region))
+    return 5;
+  if (SATURDAY_START_REGIONS.has(region))
+    return 6;
+  if (SUNDAY_START_REGIONS.has(region))
+    return 7;
+  return 1;
+}
+function getFallbackWeekend(region) {
+  if (!region)
+    return WEEKEND_SAT_SUN;
+  if (region === "IR")
+    return WEEKEND_FRI;
+  if (region === "AF")
+    return WEEKEND_THU_FRI;
+  if (FRI_SAT_WEEKEND_REGIONS.has(region))
+    return WEEKEND_FRI_SAT;
+  return WEEKEND_SAT_SUN;
 }
-var getRTF, getLF, getDTF, getPR, getNF, getDF;
+function getFallbackDirection(loc, language) {
+  const script = loc?.script ?? (isCallable(loc?.maximize) ? loc.maximize().script : void 0);
+  return script && RTL_SCRIPTS.has(script) || language && RTL_LANGUAGES.has(language) ? "rtl" : "ltr";
+}
+var RE_UNDERSCORE, RE_LOCALE_CLEANSE, hasIntl, cleanLocaleTag, getRTF, getLF, getDTF, getPR, getNF, getDF, SUNDAY_START_REGIONS, SATURDAY_START_REGIONS, FRIDAY_START_REGIONS, FRI_SAT_WEEKEND_REGIONS, RTL_LANGUAGES, RTL_SCRIPTS, WEEKEND_SAT_SUN, WEEKEND_FRI_SAT, WEEKEND_FRI, WEEKEND_THU_FRI, getLC, getLI, getDigitsMap, FALLBACK_DTF_OPTIONS, getDateTimeFormat, canonicalLocale, canonicalLocales, getHemisphere, probeMDY;
 var init_international_library = __esm({
   "../../library/dist/common/runtime/international.library.js"() {
     "use strict";
     init_temporal_library();
     init_function_library();
     init_assertion_library();
-    getRTF = memoizeFunction((locale, style = "narrow", numeric = "always") => {
-      return new Intl.RelativeTimeFormat(locale, { style, numeric });
+    init_coercion_library();
+    RE_UNDERSCORE = /_/g;
+    RE_LOCALE_CLEANSE = /[.@]/;
+    hasIntl = (feature) => typeof Intl !== "undefined" && (!feature || Object.hasOwn(Intl, feature) && isCallable(Intl[feature]));
+    cleanLocaleTag = (tag2) => {
+      if (isLocale(tag2))
+        tag2 = tag2.toString();
+      if (!isString(tag2))
+        return void 0;
+      const trimmed = tag2.trim();
+      if (isEmpty(trimmed))
+        return void 0;
+      const stripped = trimmed.split(RE_LOCALE_CLEANSE)[0];
+      if (isEmpty(stripped))
+        return void 0;
+      return stripped.replace(RE_UNDERSCORE, "-");
+    };
+    getRTF = memoizeFunction((locale, options) => {
+      return new Intl.RelativeTimeFormat(cleanLocaleTag(locale), options);
     });
-    getLF = memoizeFunction((locale, type = "conjunction", style = "long") => {
-      return new Intl.ListFormat(locale, { type, style });
+    getLF = memoizeFunction((locale, options) => {
+      return new Intl.ListFormat(cleanLocaleTag(locale), options);
     });
     getDTF = memoizeFunction((locale, options) => {
-      return new Intl.DateTimeFormat(locale, options);
+      return new Intl.DateTimeFormat(cleanLocaleTag(locale), options);
     });
     getPR = memoizeFunction((locale, options) => {
       try {
-        return new Intl.PluralRules(locale, options);
+        return new Intl.PluralRules(cleanLocaleTag(locale), options);
       } catch (e) {
         return { select: () => "other" };
       }
     });
     getNF = memoizeFunction((locale, options) => {
-      return new Intl.NumberFormat(locale, options);
+      return new Intl.NumberFormat(cleanLocaleTag(locale), options);
     });
     getDF = memoizeFunction((locale, options) => {
       try {
-        const df = new Intl.DurationFormat(locale, options);
+        const df = new Intl.DurationFormat(cleanLocaleTag(locale), options);
         if (isFunction(df.format))
           return df;
         throw new Error("No format method");
@@ -1542,6 +1754,135 @@ var init_international_library = __esm({
         return { format: (duration) => String(duration) };
       }
     });
+    SUNDAY_START_REGIONS = /* @__PURE__ */ new Set(["US", "CA", "MX", "BR", "IL", "JP", "TW", "HK", "MO", "PH", "SG", "TH", "IN", "KR", "CO", "PE", "VE", "ZA"]);
+    SATURDAY_START_REGIONS = /* @__PURE__ */ new Set(["SA", "AF", "BH", "DJ", "DZ", "EG", "IQ", "IR", "JO", "KW", "LY", "OM", "QA", "SD", "SY", "YE"]);
+    FRIDAY_START_REGIONS = /* @__PURE__ */ new Set(["MV"]);
+    FRI_SAT_WEEKEND_REGIONS = /* @__PURE__ */ new Set(["SA", "BH", "DJ", "DZ", "EG", "IQ", "JO", "KW", "LY", "OM", "QA", "SD", "SY", "YE"]);
+    RTL_LANGUAGES = /* @__PURE__ */ new Set(["ar", "he", "fa", "ur", "yi", "ps", "sd", "ug", "ckb"]);
+    RTL_SCRIPTS = /* @__PURE__ */ new Set(["Arab", "Hebr", "Thaa", "Syrc", "Mand", "Samr", "Nkoo"]);
+    WEEKEND_SAT_SUN = Object.freeze([6, 7]);
+    WEEKEND_FRI_SAT = Object.freeze([5, 6]);
+    WEEKEND_FRI = Object.freeze([5]);
+    WEEKEND_THU_FRI = Object.freeze([4, 5]);
+    getLC = memoizeFunction((localeTag) => {
+      if (isLocale(localeTag))
+        return localeTag;
+      if (!hasIntl("Locale"))
+        return void 0;
+      try {
+        const cleaned = cleanLocaleTag(localeTag);
+        return new Intl.Locale(cleaned || "en-US");
+      } catch {
+        return void 0;
+      }
+    });
+    getLI = memoizeFunction((localeTag) => {
+      const loc = getLC(localeTag) ?? getLC("en-US");
+      const baseName = loc?.baseName ?? canonicalLocale(localeTag) ?? "en-US";
+      const language = loc?.language ?? baseName.split("-")[0]?.toLowerCase();
+      const regionSubtags = [];
+      for (const sub of baseName.split("-").slice(1)) {
+        if (sub.length === 1)
+          break;
+        regionSubtags.push(sub);
+      }
+      const region = loc?.region ?? (isCallable(loc?.maximize) ? loc.maximize().region : void 0) ?? regionSubtags.find((subtag) => /^[a-zA-Z]{2}$|^\d{3}$/.test(subtag))?.toUpperCase();
+      const script = loc?.script ?? (isCallable(loc?.maximize) ? loc.maximize().script : void 0);
+      const rawWeek = getPropOrCall(loc, "getWeekInfo", "weekInfo");
+      const firstDay = rawWeek?.firstDay ?? getFallbackFirstDay(region);
+      const weekend = Array.isArray(rawWeek?.weekend) ? Object.freeze([...rawWeek.weekend]) : getFallbackWeekend(region);
+      const rawCycles = getPropOrCall(loc, "getHourCycles", "hourCycles") ?? loc?.hourCycle;
+      const resolvedHc = rawCycles ?? (hasIntl("DateTimeFormat") ? getDTF(baseName, { hour: "numeric" }).resolvedOptions().hourCycle : void 0);
+      const hourCycles = Array.isArray(resolvedHc) && resolvedHc.length > 0 ? Object.freeze([...resolvedHc]) : isString(resolvedHc) ? Object.freeze([resolvedHc]) : Object.freeze(["h23"]);
+      const rawText = getPropOrCall(loc, "getTextInfo", "textInfo");
+      const direction = rawText?.direction === "rtl" || rawText?.direction === "ltr" ? rawText.direction : getFallbackDirection(loc, language);
+      const rawSystems = getPropOrCall(loc, "getNumberingSystems", "numberingSystems") ?? loc?.numberingSystem;
+      const resolvedNs = rawSystems ?? (hasIntl("NumberFormat") ? getNF(baseName).resolvedOptions().numberingSystem : void 0);
+      const numberingSystems = Array.isArray(resolvedNs) && resolvedNs.length > 0 ? Object.freeze([...resolvedNs]) : isString(resolvedNs) ? Object.freeze([resolvedNs]) : Object.freeze(["latn"]);
+      const rawTimeZones = getPropOrCall(loc, "getTimeZones", "timeZones");
+      const timeZones = Array.isArray(rawTimeZones) && rawTimeZones.length > 0 ? Object.freeze([...rawTimeZones]) : Object.freeze([]);
+      const weekInfo = Object.freeze({ firstDay, weekend });
+      return Object.freeze({
+        locale: loc,
+        baseName,
+        language,
+        region,
+        script,
+        weekInfo,
+        firstDay,
+        weekend,
+        hourCycle: hourCycles[0],
+        hourCycles,
+        direction,
+        numberingSystem: numberingSystems[0],
+        numberingSystems,
+        timeZones
+      });
+    });
+    getDigitsMap = memoizeFunction((numberingSystem = "latn") => {
+      if (!numberingSystem || numberingSystem === "latn" || !hasIntl("NumberFormat"))
+        return void 0;
+      try {
+        const nf = new Intl.NumberFormat(`en-u-nu-${numberingSystem}`, { useGrouping: false });
+        const digits = Array.from({ length: 10 }, (_, i) => nf.format(i));
+        if (digits[0] === "0" && digits[9] === "9")
+          return void 0;
+        return Object.freeze(digits);
+      } catch {
+        return void 0;
+      }
+    });
+    FALLBACK_DTF_OPTIONS = Object.freeze({
+      locale: "en-US",
+      calendar: "iso8601",
+      numberingSystem: "latn",
+      timeZone: "UTC"
+    });
+    getDateTimeFormat = memoizeFunction(() => {
+      return hasIntl("DateTimeFormat") ? Object.freeze(getDTF().resolvedOptions()) : FALLBACK_DTF_OPTIONS;
+    });
+    canonicalLocale = memoizeFunction((locale) => {
+      const cleaned = cleanLocaleTag(locale);
+      if (!cleaned)
+        return void 0;
+      if (hasIntl("getCanonicalLocales")) {
+        try {
+          return Intl.getCanonicalLocales(cleaned)[0];
+        } catch {
+          return void 0;
+        }
+      }
+      return getLC(cleaned)?.baseName ?? cleaned;
+    });
+    canonicalLocales = memoizeFunction((locales) => {
+      return Object.freeze(asArray(locales).map((l) => canonicalLocale(l)).filter(Boolean));
+    });
+    getHemisphere = memoizeFunction((timeZone = getDateTimeFormat().timeZone) => {
+      try {
+        const { jan, jul } = getOffsets(timeZone);
+        const southPrefixes = ["Australia", "Antarctica", "Africa/Johannesburg", "America/Argentina/Buenos_Aires", "America/Sao_Paulo"];
+        const isSouthZone = southPrefixes.some((p) => timeZone.startsWith(p));
+        switch (true) {
+          case jul > jan:
+            return "north";
+          case jul < jan:
+            return "south";
+          default:
+            return isSouthZone ? "south" : void 0;
+        }
+      } catch (e) {
+        return void 0;
+      }
+    });
+    probeMDY = memoizeFunction((locale) => {
+      try {
+        const date = new Date(2024, 11, 24);
+        const parts = getDTF(locale).formatToParts(date);
+        return parts[0].type === "month" && parts[0].value === "12";
+      } catch {
+        return false;
+      }
+    });
   }
 });
 
@@ -2028,7 +2369,12 @@ var init_mapper_library = __esm({
           if (context2.type === CONTEXT.Browser) {
             Promise.resolve().then(() => (init_webstore_class(), webstore_class_exports)).then(({ WebStore: WebStore2 }) => {
               const local = new WebStore2("local");
-              Object.assign(mapStore, local.get(MAP_KEY, {}));
+              const stashed = local.get(MAP_KEY, {});
+              if (isReference(stashed)) {
+                if (stashed.geolocation && (!stashed.geolocation.coords || stashed.geolocation.$GeolocationPosition))
+                  delete stashed.geolocation;
+                Object.assign(mapStore, stashed);
+              }
               resolve(local);
             }).catch(reject);
           } else {
@@ -2428,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.0.0" });
-var defineTerm = (config) => originalTerm({ ...config, version: "1.0.0" });
+var definePlugin = (config) => originalPlugin({ ...config, version: "1.2.0" });
+var defineTerm = (config) => originalTerm({ ...config, version: "1.2.0" });
 
 // ../../library/dist/common/runtime/mapper.library.js
 init_utility_library();
@@ -2801,40 +3147,54 @@ init_mapper_library();
 init_assertion_library();
 var GeoPlugin = definePlugin({
   name: "geo",
-  install(TempoClass) {
-    const geoNamespace = {
-      lookup: geoLookup,
-      resolve: resolveGeoCoordinates,
-      coerce: coerceGeo,
-      distance: haversineDistance,
-      solarOffset,
-      stash: stashGeo,
-      clear: clearStashedGeo,
-      get: getStashedGeo,
-      server: serverGeoLocation,
-      browser: geoLocation,
-      get current() {
-        return getStashedGeo() ?? TempoClass.config?.geo;
-      }
+  install(TempoClass, options) {
+    const installedClass = TempoClass || this;
+    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 : {}
+      };
     };
-    Object.defineProperty(TempoClass, "geo", {
-      value: (0, sdk_exports.deepFreeze)(geoNamespace),
-      writable: false,
-      configurable: false,
-      enumerable: false
-    });
+    if (!Object.hasOwn(installedClass, "geo")) {
+      const geoNamespace = {
+        lookup: (opts) => geoLookup(getEffectiveOptions(opts)),
+        resolve: (target, opts) => resolveGeoCoordinates(target, getEffectiveOptions(opts, target)),
+        coerce: coerceGeo,
+        distance: haversineDistance,
+        solarOffset,
+        stash: stashGeo,
+        clear: clearStashedGeo,
+        get: getStashedGeo,
+        server: serverGeoLocation,
+        browser: geoLocation,
+        get current() {
+          return getStashedGeo() ?? installedClass.config?.geo;
+        }
+      };
+      Object.defineProperty(installedClass, "geo", {
+        value: (0, sdk_exports.deepFreeze)(geoNamespace),
+        writable: false,
+        configurable: false,
+        enumerable: false
+      });
+    }
     TempoClass.prototype.geoLocate = async function(opts) {
-      const setTimezone = opts?.setTimezone !== false;
-      const coords = await resolveGeoCoordinates(this, opts);
+      const effectiveOpts = getEffectiveOptions(opts, this);
+      const setTimezone = effectiveOpts?.setTimezone !== false;
+      const coords = await resolveGeoCoordinates(this, effectiveOpts);
       if (coords) {
-        const existingGeo = typeof this.config.geo === "object" && this.config.geo !== null ? this.config.geo : {};
+        const existingGeo = isObject(this.config.geo) ? this.config.geo : {};
         const customKeys = {};
         for (const key of Object.keys(existingGeo)) {
           if (isSafeKey(key) && !GEO_PROPERTIES.includes(key))
             customKeys[key] = existingGeo[key];
         }
         const callSiteGeo = coerceGeo(opts) ?? {};
-        if (opts && typeof opts === "object") {
+        if (isObject(opts)) {
           for (const key of Object.keys(opts)) {
             if (isSafeKey(key) && !["setTimezone", "refresh", "ttl", "endpoint", "timeout", "catch", "debug", "geo"].includes(key)) {
               if (!GEO_PROPERTIES.includes(key))
@@ -2867,13 +3227,13 @@ var GeoPlugin = definePlugin({
       return this;
     };
     TempoClass.prototype.geoLookup = async function(opts) {
-      return resolveGeoCoordinates(this, opts);
+      return resolveGeoCoordinates(this, getEffectiveOptions(opts, this));
     };
     TempoClass.prototype.geoDistance = function(other, unit) {
       return haversineDistance(this, other, unit);
     };
-    TempoClass.prototype.geoSolarOffset = function(options) {
-      return solarOffset(this, options);
+    TempoClass.prototype.geoSolarOffset = function(options2) {
+      return solarOffset(this, options2);
     };
   }
 });