@magmacomputing/tempo-plugin-geo 0.1.0

package/dist/index.js

@@ -0,0 +1,2163 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// ../../library/dist/common/primitives/symbol.library.js
+var $Target, $Discover, $Extensible, $Inspect, $LogConfig, $Registry, $Register, $SerializerRegistry, $Mutable, $Identity, $Unwrapped, sym;
+var init_symbol_library = __esm({
+  "../../library/dist/common/primitives/symbol.library.js"() {
+    "use strict";
+    $Target = /* @__PURE__ */ Symbol.for("$LibraryTarget");
+    $Discover = /* @__PURE__ */ Symbol.for("$LibraryDiscover");
+    $Extensible = /* @__PURE__ */ Symbol.for("$LibraryExtensible");
+    $Inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+    $LogConfig = /* @__PURE__ */ Symbol.for("$LibraryLogConfig");
+    $Registry = /* @__PURE__ */ Symbol.for("$LibraryRegistry");
+    $Register = /* @__PURE__ */ Symbol.for("$LibraryRegister");
+    $SerializerRegistry = /* @__PURE__ */ Symbol.for("$LibrarySerializerRegistry");
+    $Mutable = /* @__PURE__ */ Symbol.for("$LibraryMutable");
+    $Identity = /* @__PURE__ */ Symbol.for("$LibraryIdentity");
+    $Unwrapped = /* @__PURE__ */ Symbol.for("$LibraryUnwrapped");
+    sym = {
+      $Target,
+      $Discover,
+      $Extensible,
+      $Inspect,
+      $LogConfig,
+      $Registry,
+      $Register,
+      $SerializerRegistry,
+      $Identity,
+      $Mutable,
+      $Unwrapped
+    };
+  }
+});
+
+// ../../library/dist/common/primitives/primitive.library.js
+function unwrap(obj) {
+  let curr = obj;
+  let depth = 0;
+  const maxDepth = 50;
+  while (curr) {
+    const next = curr[sym.$Target];
+    if (!next || depth >= maxDepth)
+      break;
+    curr = next;
+    depth++;
+  }
+  return curr;
+}
+function ownEntries(json, all = false) {
+  if (!json || typeof json !== "object")
+    return [];
+  const tgt = unwrap(json);
+  if (!all) {
+    const keys = Reflect.ownKeys(tgt);
+    const entries2 = [];
+    for (const k of keys) {
+      const desc = Object.getOwnPropertyDescriptor(tgt, k);
+      if (desc && desc.enumerable)
+        entries2.push([k, tgt[k]]);
+    }
+    return entries2;
+  }
+  const levels = [];
+  const limit = 50;
+  let depth = 0;
+  let curr = tgt;
+  while (curr && curr !== Object.prototype && depth++ < limit) {
+    levels.push(unwrap(curr));
+    curr = Object.getPrototypeOf(curr);
+  }
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const level of levels.reverse()) {
+    const keys = Reflect.ownKeys(level);
+    for (const k of keys) {
+      if (seen.has(k))
+        continue;
+      const desc = Object.getOwnPropertyDescriptor(level, k);
+      if (!desc || !desc.enumerable)
+        continue;
+      seen.add(k);
+      entries.push([k, tgt[k]]);
+    }
+  }
+  return entries;
+}
+function ownKeys(json, all = false) {
+  return ownEntries(json, all).map(([key]) => key);
+}
+function ownValues(json, all = false) {
+  return ownEntries(json, all).map(([_, value2]) => value2);
+}
+function distinct(arr, mapfn, thisArg) {
+  return mapfn ? distinct(arr.map(mapfn, thisArg)) : Array.from(new Set(arr));
+}
+var init_primitive_library = __esm({
+  "../../library/dist/common/primitives/primitive.library.js"() {
+    "use strict";
+    init_symbol_library();
+  }
+});
+
+// ../../library/dist/common/primitives/type.library.js
+var registry, protoType, getSafeTag, getType, asType, classRegex, isClassConstructor, registerType;
+var init_type_library = __esm({
+  "../../library/dist/common/primitives/type.library.js"() {
+    "use strict";
+    init_symbol_library();
+    init_primitive_library();
+    registry = [];
+    protoType = (obj) => {
+      if (obj === null)
+        return "Null";
+      if (obj === void 0)
+        return "Undefined";
+      const t = typeof obj;
+      if (t === "string")
+        return "String";
+      if (t === "number")
+        return "Number";
+      if (t === "boolean")
+        return "Boolean";
+      if (t === "bigint")
+        return "BigInt";
+      if (t === "symbol")
+        return "Symbol";
+      try {
+        const raw = t === "object" ? unwrap(obj) : obj;
+        return Object.prototype.toString.call(raw).slice(8, -1);
+      } catch {
+        return t === "function" ? "Function" : "Object";
+      }
+    };
+    getSafeTag = (obj) => {
+      try {
+        const tag2 = obj?.[Symbol.toStringTag] ?? obj?.prototype?.[Symbol.toStringTag];
+        if (typeof tag2 === "string")
+          return tag2;
+      } catch {
+      }
+      return void 0;
+    };
+    getType = (obj, ...instances) => {
+      let raw = obj;
+      try {
+        raw = obj?.[sym.$Target] ?? obj;
+      } catch {
+        raw = obj;
+      }
+      const type = protoType(raw);
+      switch (type) {
+        case "Function":
+          try {
+            return isClassConstructor(raw) ? "Class" : "Function";
+          } catch {
+            return "Function";
+          }
+        case "Object": {
+          try {
+            if ("length" in raw && Object.keys(raw).every((key) => key === "length" || Number.isFinite(Number(key))))
+              return "ArrayLike";
+            for (const inst of instances) {
+              const instRaw = inst.class?.[sym.$Target] ?? inst.class;
+              if (raw === instRaw || instRaw && raw instanceof instRaw)
+                return inst.type;
+            }
+            const globalRegistry = globalThis[sym.$Registry] ?? [];
+            for (const inst of [...registry, ...globalRegistry]) {
+              const instRaw = inst.class?.[sym.$Target] ?? inst.class;
+              if (raw === instRaw || instRaw && raw instanceof instRaw)
+                return inst.type;
+            }
+          } catch {
+            return "Object";
+          }
+          return "Object";
+        }
+        default:
+          return type;
+      }
+    };
+    asType = (value2, ...instances) => ({ type: getType(value2, ...instances), value: value2 });
+    classRegex = /^\s*(class\s|\[native code\])/;
+    isClassConstructor = (obj) => {
+      if (typeof obj !== "function")
+        return false;
+      const raw = obj?.[sym.$Target] ?? obj;
+      if (!("prototype" in raw))
+        return false;
+      const name = raw?.name;
+      const tag2 = getSafeTag(raw);
+      if (raw?.[sym.$Identity] || raw?.prototype?.[sym.$Identity]) {
+        return true;
+      }
+      if (typeof tag2 === "string" && tag2.startsWith("Temporal.")) {
+        return true;
+      }
+      if (typeof tag2 === "string" && tag2.endsWith("Function"))
+        return false;
+      const globalRegistry = globalThis[sym.$Registry] ?? [];
+      if (globalRegistry.some((inst) => (inst.class?.[sym.$Target] ?? inst.class) === raw || name && inst.type === name || tag2 && inst.type === tag2)) {
+        return true;
+      }
+      try {
+        const str = Function.prototype.toString.call(raw);
+        if (classRegex.test(str)) {
+          return true;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(raw, "prototype");
+        if (descriptor && descriptor.writable === false && !Object.isFrozen(raw)) {
+          return true;
+        }
+        const proto = raw.prototype;
+        if (proto && Object.getOwnPropertyNames(proto).length > 2) {
+          return true;
+        }
+      } catch {
+        return false;
+      }
+      return false;
+    };
+    registerType = (cls, type) => {
+      if (typeof cls !== "function")
+        return;
+      const tag2 = getSafeTag(cls);
+      const name = type ?? tag2 ?? cls.name;
+      if (name && !["Object", "Function", ""].includes(name)) {
+        if (!registry.some((inst) => inst.class === cls))
+          registry.push({ class: cls, type: name });
+      }
+    };
+  }
+});
+
+// ../../library/dist/common/primitives/assertion.library.js
+var isType, isPrimitive, isReference, isString, isNumber, isInteger, isArray, isObject, isDate, isSymbol, isSymbolFor, isSafeKey, isNullish, isUndefined, isDefined, isFunction, isMap, isSet, isError, 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");
+    isReference = (obj) => !isPrimitive(obj);
+    isString = (obj) => isType(obj, "String");
+    isNumber = (obj) => Number.isFinite(obj);
+    isInteger = (obj) => isType(obj, "BigInt");
+    isArray = (obj) => isType(obj, "Array");
+    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;
+    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);
+    isFunction = (obj) => isType(obj, "Function", "AsyncFunction", "GeneratorFunction", "AsyncGeneratorFunction");
+    isMap = (obj) => isType(obj, "Map");
+    isSet = (obj) => isType(obj, "Set");
+    isError = (err, constructor) => isType(err, "Error") && (constructor ? err instanceof constructor : true);
+    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());
+  }
+});
+
+// ../../library/dist/common/runtime/utility.library.js
+function deepFreeze(obj, options, seen = /* @__PURE__ */ new WeakSet()) {
+  const skip = options instanceof WeakSet ? options : options?.skip ?? EMPTY_SKIP;
+  if (isPrimitive(obj) || seen.has(obj) || skip.has(obj))
+    return obj;
+  if (obj instanceof Date || obj instanceof RegExp || obj instanceof Error || obj instanceof Map || obj instanceof Set || obj instanceof Promise)
+    return obj;
+  if (obj?.[Symbol.toStringTag] === "Enumify")
+    return obj;
+  if (obj[sym.$Extensible])
+    return obj;
+  seen.add(obj);
+  ownEntries(obj).forEach(([key, val]) => {
+    if (isSafeKey(key))
+      deepFreeze(val, { skip }, seen);
+  });
+  return Object.freeze(obj);
+}
+var CONTEXT, getContext, EMPTY_SKIP;
+var init_utility_library = __esm({
+  "../../library/dist/common/runtime/utility.library.js"() {
+    "use strict";
+    init_primitive_library();
+    init_assertion_library();
+    init_symbol_library();
+    CONTEXT = {
+      "Unknown": "unknown",
+      "Browser": "browser",
+      "WebWorker": "web-worker",
+      "NodeJS": "nodejs",
+      "Deno": "deno",
+      "GoogleAppsScript": "google-apps-script"
+    };
+    getContext = () => {
+      const global = globalThis;
+      try {
+        if (isDefined(global.SpreadsheetApp))
+          return { global, type: CONTEXT.GoogleAppsScript };
+        if (isDefined(global.window?.document))
+          return { global, type: CONTEXT.Browser };
+        if (isFunction(global.importScripts) || isDefined(global.WorkerGlobalScope) && global instanceof global.WorkerGlobalScope)
+          return { global, type: CONTEXT.WebWorker };
+        if (isDefined(global.Deno))
+          return { global, type: CONTEXT.Deno };
+        if (isDefined(global.process?.versions?.node) && global.process?.release?.name === "node")
+          return { global, type: CONTEXT.NodeJS };
+      } catch {
+      }
+      return { global, type: CONTEXT.Unknown };
+    };
+    EMPTY_SKIP = /* @__PURE__ */ new WeakSet();
+  }
+});
+
+// ../../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/runtime/reflection.library.js
+function allObject(json) {
+  return Object.fromEntries(ownEntries(json, true));
+}
+var init_reflection_library = __esm({
+  "../../library/dist/common/runtime/reflection.library.js"() {
+    "use strict";
+    init_primitive_library();
+    init_type_library();
+    init_assertion_library();
+  }
+});
+
+// ../../library/dist/common/runtime/proxy.library.js
+function factory(target, options = {}, isRevocable = false) {
+  const { frozen, lock, appendOnly, onGet, keys, bind, skip } = options;
+  const pending = /* @__PURE__ */ new Set();
+  let cachedJSON;
+  let result;
+  const tgt = unwrap(target);
+  if (lock)
+    deepFreeze(tgt, skip ? { skip } : void 0);
+  registerType(tgt);
+  const handler = {
+    isExtensible: (t) => Reflect.isExtensible(t),
+    getPrototypeOf: (t) => Reflect.getPrototypeOf(t),
+    setPrototypeOf: (t, proto) => {
+      if (frozen)
+        throw new TypeError("Security: Prototype mutation attempt on protected object");
+      return Reflect.setPrototypeOf(t, proto);
+    },
+    getOwnPropertyDescriptor: (t, k) => {
+      if (keys && !keys.includes(k))
+        return void 0;
+      if (keys) {
+        if (onGet && !isSymbol(k) && !pending.has(k)) {
+          pending.add(k);
+          try {
+            const value2 = onGet(k, t);
+            if (isDefined(value2))
+              return { enumerable: true, configurable: true, value: value2 };
+          } finally {
+            pending.delete(k);
+          }
+        }
+        return { enumerable: true, configurable: true };
+      }
+      return Reflect.getOwnPropertyDescriptor(t, k);
+    },
+    ownKeys: (t) => {
+      if (keys)
+        return keys;
+      if (onGet && !pending.has(sym.$Discover)) {
+        pending.add(sym.$Discover);
+        try {
+          onGet(sym.$Discover, t);
+        } finally {
+          pending.delete(sym.$Discover);
+        }
+      }
+      return Reflect.ownKeys(t);
+    },
+    has: (t, k) => keys ? keys.includes(k) : Reflect.has(t, k),
+    deleteProperty: (t, k) => {
+      if (frozen)
+        throw new TypeError(`Cannot delete property '${String(k)}' from a protected object.`);
+      if (appendOnly && Reflect.has(t, k))
+        throw new Error(`Security: Deletion attempt on protected key '${String(k)}'`);
+      return Reflect.deleteProperty(t, k);
+    },
+    defineProperty: (t, k, d) => {
+      if (frozen && !Object.isFrozen(t))
+        throw new TypeError(`Cannot define property '${String(k)}' on a frozen object.`);
+      if (appendOnly && Reflect.has(t, k))
+        throw new Error(`Security: Mutation attempt on protected key '${String(k)}'`);
+      return Reflect.defineProperty(t, k, d);
+    },
+    set: (t, k, v, r) => {
+      if (frozen && r === result)
+        throw new TypeError(`Cannot set property '${String(k)}' on a frozen object.`);
+      if (appendOnly) {
+        const isTruncating = Array.isArray(t) && k === "length" && v < t.length;
+        if (isTruncating)
+          throw new Error("Security: Truncation attempt on protected array.");
+        if (!(Array.isArray(t) && k === "length") && Reflect.has(t, k))
+          throw new Error(`Security: Mutation attempt on protected key '${String(k)}'`);
+      }
+      return Reflect.set(t, k, v, r);
+    },
+    get: (t, k, r) => {
+      if (k === sym.$Target)
+        return r === result ? t : void 0;
+      if (frozen && (k === sym.$Inspect || k === "toJSON")) {
+        const own = Object.getOwnPropertyDescriptor(t, k);
+        if (own && isFunction(own.value))
+          return own.value;
+        if (!cachedJSON)
+          cachedJSON = () => allObject(t);
+        return cachedJSON;
+      }
+      if (keys && !keys.includes(k))
+        return void 0;
+      if (onGet && !isSymbol(k) && !Reflect.has(t, k) && !pending.has(k)) {
+        pending.add(k);
+        try {
+          const val2 = onGet(k, t);
+          if (isDefined(val2))
+            return val2;
+        } finally {
+          pending.delete(k);
+        }
+      }
+      const val = Reflect.get(t, k, r);
+      if (bind && k !== "constructor" && isFunction(val)) {
+        const desc = Object.getOwnPropertyDescriptor(t, k);
+        if (desc && !desc.configurable && !desc.writable)
+          return val;
+        let perTargetCache = boundMethodCache.get(val);
+        if (!perTargetCache) {
+          perTargetCache = /* @__PURE__ */ new WeakMap();
+          boundMethodCache.set(val, perTargetCache);
+        }
+        const cachedBound = perTargetCache.get(t);
+        if (cachedBound)
+          return cachedBound;
+        const bound = val.bind(t);
+        perTargetCache.set(t, bound);
+        return bound;
+      }
+      return val;
+    }
+  };
+  if (isRevocable) {
+    const revocableResult = Proxy.revocable(tgt, handler);
+    result = revocableResult.proxy;
+    return { proxy: revocableResult.proxy, revoke: revocableResult.revoke };
+  }
+  result = new Proxy(tgt, handler);
+  return result;
+}
+function proxify(target, frozen = true, lock = frozen, skip = /* @__PURE__ */ new WeakSet()) {
+  return factory(target, { frozen, lock, skip, bind: frozen });
+}
+function secure(obj, skip = /* @__PURE__ */ new WeakSet()) {
+  return factory(obj, { frozen: true, lock: true, skip, bind: true });
+}
+var boundMethodCache;
+var init_proxy_library = __esm({
+  "../../library/dist/common/runtime/proxy.library.js"() {
+    "use strict";
+    init_symbol_library();
+    init_reflection_library();
+    init_utility_library();
+    init_primitive_library();
+    init_assertion_library();
+    init_type_library();
+    boundMethodCache = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// ../../library/dist/common/runtime/function.library.js
+function serialize(val, seen = /* @__PURE__ */ new WeakSet()) {
+  return JSON.stringify(val, function(key, value2) {
+    if (value2 === void 0)
+      return "\0__undefined__\0";
+    if (isInteger(value2))
+      return `\0__bigint:${value2}__\0`;
+    if (isFunction(value2))
+      return `function:${value2.name || "anonymous"}`;
+    if (isReference(value2)) {
+      if (seen.has(value2))
+        return "<Circular>";
+      seen.add(value2);
+      if (isMap(value2))
+        return `map:[${Array.from(value2.entries()).map((e) => serialize(e, seen)).sort().join(",")}]`;
+      if (isSet(value2))
+        return `set:[${Array.from(value2).map((v) => serialize(v, seen)).sort().join(",")}]`;
+    }
+    return value2;
+  });
+}
+function curry(fn) {
+  return function curried(...args) {
+    return args.length >= fn.length ? fn(...args) : (...nextArgs) => curried(...args, ...nextArgs);
+  };
+}
+function memoizeFunction(fn) {
+  const cache = /* @__PURE__ */ new Map();
+  return function(...args) {
+    const key = this !== void 0 && this !== globalThis ? serialize([this, ...args]) : serialize(args);
+    if (!cache.has(key)) {
+      const result = fn.apply(this, args);
+      cache.set(key, result);
+    }
+    return cache.get(key);
+  };
+}
+function memoizeMethod(name, fn) {
+  return {
+    enumerable: false,
+    configurable: false,
+    writable: false,
+    value: function(...args) {
+      const key = `${String(name)},${serialize(args)}`;
+      let cache = wm.get(this);
+      if (!cache) {
+        cache = /* @__PURE__ */ new Map();
+        wm.set(this, cache);
+      }
+      if (!cache.has(key)) {
+        const result = fn.apply(this, args);
+        secure(result);
+        cache.set(key, result);
+      }
+      return cache.get(key);
+    }
+  };
+}
+var wm;
+var init_function_library = __esm({
+  "../../library/dist/common/runtime/function.library.js"() {
+    "use strict";
+    init_proxy_library();
+    init_assertion_library();
+    wm = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// ../../library/dist/common/runtime/json.library.js
+var init_json_library = __esm({
+  "../../library/dist/common/runtime/json.library.js"() {
+    "use strict";
+  }
+});
+
+// ../../library/dist/common/runtime/serialize.library.js
+function replacer(key, obj) {
+  return isEmpty(key) ? obj : stringize(obj);
+}
+function reviver(_key, val) {
+  return decode(val);
+}
+function encode(val) {
+  let enc = encodeURI(val);
+  if (enc.includes("%"))
+    enc = enc.replace(RE_SAFE_URI_CODES, (match) => SAFE_URI_MAP[match.toUpperCase()] ?? decodeURI(match));
+  return enc;
+}
+function decode(val) {
+  if (isString(val)) {
+    try {
+      return decodeURI(val);
+    } catch (error) {
+    }
+  }
+  return val;
+}
+function isStringable(val) {
+  return !isType(val, "Function", "AsyncFunction", "WeakMap", "WeakSet", "WeakRef");
+}
+function oneKey(type, value2) {
+  return `{"$${type}":${value2}}`;
+}
+function fromSymbol(key) {
+  return stringize(isSymbol(key) ? `${isSymbolFor(key) ? "@" : ""}@(${key.description ?? ""})` : key);
+}
+function toSymbol(value2) {
+  const [pat, keyFor, desc] = value2.toString().match(symKey) || [null, void 0, void 0];
+  switch (true) {
+    case isSymbol(value2):
+    // already a Symbol
+    case isNullish(pat):
+    // incorrectly encoded Symbol
+    case (isDefined(keyFor) && isUndefined(desc)):
+      return value2;
+    case isDefined(keyFor):
+      return Symbol.for(desc);
+    case isUndefined(keyFor):
+    // local Symbol
+    default:
+      return Symbol(desc);
+  }
+}
+function stringify(obj) {
+  return stringize(obj, false);
+}
+function stringize(obj, recurse = true) {
+  const arg = asType(obj);
+  const one = curry(oneKey)(arg.type);
+  switch (arg.type) {
+    case "String":
+      if (!recurse) {
+        recurse = arg.value === "true" || arg.value === "false" || arg.value === "null" || parseFloat(arg.value).toString() === arg.value;
+      }
+      return recurse ? JSON.stringify(encode(arg.value)) : encode(arg.value);
+    // dont JSON.stringify a top-level string
+    case "Boolean":
+    case "Null":
+    case "Number":
+      return JSON.stringify(arg.value);
+    // JSON.stringify will correctly handle these
+    case "Void":
+    case "Undefined":
+      return one(JSON.stringify("void"));
+    // preserve 'undefined' values		
+    case "BigInt":
+      return one(arg.value.toString());
+    // even though BigInt has a toString method, it is not supported in JSON.stringify
+    case "Object": {
+      const obj2 = ownEntries(arg.value).filter(([, val]) => isStringable(val)).map(([key, val]) => `${fromSymbol(key)}: ${stringize(val)}`).join(",");
+      return `{${obj2}}`;
+    }
+    case "Array": {
+      const arr = arg.value.filter((val) => isStringable(val)).map((val) => stringize(val)).join(",");
+      return `[${arr}]`;
+    }
+    case "Map": {
+      const map = Array.from(arg.value.entries()).filter(([, val]) => isStringable(val)).map(([key, val]) => `[${stringize(key)}, ${stringize(val)}]`).join(",");
+      return one(`[${map}]`);
+    }
+    case "Set": {
+      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 "RegExp":
+      return one(stringize({ source: arg.value.source, flags: arg.value.flags }));
+    case "Class":
+    default: {
+      const value2 = arg.value;
+      switch (true) {
+        case !isStringable(value2):
+          return void 0;
+        case isFunction(value2.toJSON):
+          return one(stringize(value2.toJSON()));
+        case isFunction(value2.toString): {
+          const str = value2.toString();
+          return one(str.includes('"') ? str : JSON.stringify(str));
+        }
+        case isFunction(value2.valueOf):
+          return one(JSON.stringify(value2.valueOf()));
+        default:
+          return one(JSON.stringify(value2, replacer));
+      }
+    }
+  }
+}
+function objectify(str, sentinel) {
+  if (!isString(str))
+    return str;
+  let parse;
+  try {
+    parse = JSON.parse(str, reviver);
+  } catch (error) {
+    if (str.startsWith('"') && str.endsWith('"')) {
+      console.warn(`objectify.parse: -> ${str}, ${error.message}`);
+      return str;
+    } else
+      return objectify(`"${str}"`, sentinel);
+  }
+  switch (true) {
+    case (str.startsWith("{") && str.endsWith("}")):
+    // looks like Object
+    case (str.startsWith("[") && str.endsWith("]")):
+      return traverse(parse, sentinel);
+    // recurse into object
+    default:
+      return parse;
+  }
+}
+function traverse(obj, sentinel) {
+  if (isObject(obj)) {
+    return typeify(ownEntries(obj).reduce((acc, [key, val]) => Object.assign(acc, { [toSymbol(key)]: typeify(traverse(val, sentinel)) }), {}), sentinel);
+  }
+  if (isArray(obj)) {
+    return ownValues(obj).map((val) => typeify(traverse(val, sentinel)));
+  }
+  return obj;
+}
+function typeify(json, sentinel) {
+  if (!isObject(json) || ownKeys(json).length !== 1)
+    return json;
+  const [$type, value2] = ownEntries(json)[0];
+  if (!String($type).startsWith("$"))
+    return json;
+  const type = $type.substring(1);
+  try {
+    switch (type) {
+      case "String":
+      case "Boolean":
+      case "Object":
+      case "Array":
+        return value2;
+      // these types are already handled by traverse()
+      case "Number":
+        return Number(value2);
+      case "BigInt":
+        return BigInt(value2);
+      case "Null":
+        return null;
+      case "Undefined":
+      case "Empty":
+      case "Void":
+        return sentinel?.();
+      // run Sentinel function to handle undefined values
+      case "Date":
+        return new Date(value2);
+      case "RegExp":
+        if (!isObject(value2) || !isString(value2.source))
+          return json;
+        return new RegExp(value2.source, value2.flags);
+      case "Symbol":
+        return toSymbol(value2);
+      case "Map":
+        if (!isArray(value2))
+          return json;
+        return new Map(value2);
+      case "Set":
+        if (!isArray(value2))
+          return json;
+        return new Set(value2);
+      default:
+        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 init_serialize_library = __esm({
+  "../../library/dist/common/runtime/serialize.library.js"() {
+    "use strict";
+    init_function_library();
+    init_primitive_library();
+    init_json_library();
+    init_type_library();
+    init_assertion_library();
+    init_symbol_library();
+    Registry = globalThis[sym.$SerializerRegistry] ??= /* @__PURE__ */ new Map();
+    getSafeTag2 = (c) => {
+      try {
+        const tag2 = c?.prototype?.[Symbol.toStringTag] ?? c?.[Symbol.toStringTag];
+        return isString(tag2) ? tag2 : void 0;
+      } catch {
+        return void 0;
+      }
+    };
+    registerSerializable = (name, cls) => {
+      const key = name.startsWith("$") ? name : `$${name}`;
+      if (Registry.has(key)) {
+        const existingCls = Registry.get(key);
+        const existingTag = getSafeTag2(existingCls);
+        const clsTag = getSafeTag2(cls);
+        const existingName = existingCls.name || existingTag;
+        const currentName = cls.name || clsTag || (name.startsWith("$") ? name.slice(1) : name);
+        const isSameConstructor = existingCls === cls || existingCls.toString() === cls.toString() || Boolean(cls[sym.$Identity]) && existingCls[sym.$Identity] === cls[sym.$Identity] || Boolean(cls[sym.$Target]) && existingCls[sym.$Target] === cls[sym.$Target] || Boolean(existingName) && Boolean(currentName) && existingName === currentName;
+        if (isSameConstructor)
+          return;
+        throw new Error(`[registerSerializable] Collision: '${key}' is already registered with ${existingCls.name || "anonymous constructor"}`);
+      }
+      Registry.set(key, cls);
+    };
+    SAFE_URI_MAP = {
+      "%20": " ",
+      "%22": '"',
+      "%3B": ";",
+      "%3C": "<",
+      "%3E": ">",
+      "%5B": "[",
+      "%5D": "]",
+      "%5E": "^",
+      "%7B": "{",
+      "%7C": "|",
+      "%7D": "}"
+    };
+    RE_SAFE_URI_CODES = new RegExp(Object.keys(SAFE_URI_MAP).join("|"), "gi");
+    symKey = /^@(@)?\(([^\)]*)\)$/;
+  }
+});
+
+// ../../library/dist/common/primitives/string.library.js
+var init_string_library = __esm({
+  "../../library/dist/common/primitives/string.library.js"() {
+    "use strict";
+    init_serialize_library();
+    init_assertion_library();
+  }
+});
+
+// ../../library/dist/common/primitives/coercion.library.js
+function asError(err) {
+  if (isError(err))
+    return err;
+  const error = new Error(isObject(err) && isString(err.message) ? err.message : String(err));
+  if (isObject(err)) {
+    error.name = isString(err.name) ? err.name : "Error";
+    if ("code" in err && (isString(err.code) || isNumber(err.code)))
+      error.code = err.code;
+    if ("stack" in err && isString(err.stack))
+      error.stack = err.stack;
+  }
+  return error;
+}
+var MAX_SAFE_INTEGER_BIGINT, MIN_SAFE_INTEGER_BIGINT;
+var init_coercion_library = __esm({
+  "../../library/dist/common/primitives/coercion.library.js"() {
+    "use strict";
+    init_serialize_library();
+    init_type_library();
+    init_assertion_library();
+    init_string_library();
+    MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+    MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+  }
+});
+
+// ../../library/dist/common/temporal/temporal.polyfill.js
+var init_temporal_polyfill = __esm({
+  "../../library/dist/common/temporal/temporal.polyfill.js"() {
+    "use strict";
+    init_coercion_library();
+    if (typeof globalThis.Temporal === "undefined") {
+      throw new Error("Temporal API is not available. Node 20+ with a polyfill (e.g. @js-temporal/polyfill) is highly recommended. Native Temporal is fully reliable only on Node 26+ (while Node 22 may have instabilities).");
+    }
+    try {
+      if (typeof Temporal.Now.zonedDateTimeISO === "function") {
+        const zdt = Temporal.Now.zonedDateTimeISO();
+        if (typeof zdt.add !== "function")
+          throw new Error("Incomplete Temporal implementation");
+      }
+    } catch (err) {
+      const error = asError(err);
+      console.warn("Tempo: Native Temporal implementation appears incomplete. Consider loading a polyfill.", error);
+      if (error.message !== "Incomplete Temporal implementation")
+        throw error;
+    }
+  }
+});
+
+// ../../library/dist/common/temporal/temporal.library.js
+function instant() {
+  return Temporal.Now.instant();
+}
+function getOffsets(timeZone, year = 2024) {
+  const jan = Temporal.ZonedDateTime.from({ year, month: 1, day: 1, hour: 0, minute: 0, second: 0, timeZone }).offsetNanoseconds;
+  const jul = Temporal.ZonedDateTime.from({ year, month: 7, day: 1, hour: 0, minute: 0, second: 0, timeZone }).offsetNanoseconds;
+  return { jan, jul };
+}
+var init_temporal_library = __esm({
+  "../../library/dist/common/temporal/temporal.library.js"() {
+    "use strict";
+    init_temporal_polyfill();
+    init_assertion_library();
+  }
+});
+
+// ../../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) {
+    return void 0;
+  }
+}
+var getRTF, getLF, getDTF, getPR, getNF, getDF;
+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 });
+    });
+    getLF = memoizeFunction((locale, type = "conjunction", style = "long") => {
+      return new Intl.ListFormat(locale, { type, style });
+    });
+    getDTF = memoizeFunction((locale, options) => {
+      return new Intl.DateTimeFormat(locale, options);
+    });
+    getPR = memoizeFunction((locale, options) => {
+      try {
+        return new Intl.PluralRules(locale, options);
+      } catch (e) {
+        return { select: () => "other" };
+      }
+    });
+    getNF = memoizeFunction((locale, options) => {
+      return new Intl.NumberFormat(locale, options);
+    });
+    getDF = memoizeFunction((locale, options) => {
+      try {
+        const df = new Intl.DurationFormat(locale, options);
+        if (isFunction(df.format))
+          return df;
+        throw new Error("No format method");
+      } catch (e) {
+        return { format: (duration) => String(duration) };
+      }
+    });
+  }
+});
+
+// ../../../node_modules/tslib/tslib.es6.mjs
+function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context3 = {};
+    for (var p in contextIn) context3[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access) context3.access[p] = contextIn.access[p];
+    context3.addInitializer = function(f) {
+      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context3);
+    if (kind === "accessor") {
+      if (result === void 0) continue;
+      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+      if (_ = accept(result.get)) descriptor.get = _;
+      if (_ = accept(result.set)) descriptor.set = _;
+      if (_ = accept(result.init)) initializers.unshift(_);
+    } else if (_ = accept(result)) {
+      if (kind === "field") initializers.unshift(_);
+      else descriptor[key] = _;
+    }
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+}
+function __runInitializers(thisArg, initializers, value2) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) {
+    value2 = useValue ? initializers[i].call(thisArg, value2) : initializers[i].call(thisArg);
+  }
+  return useValue ? value2 : void 0;
+}
+var init_tslib_es6 = __esm({
+  "../../../node_modules/tslib/tslib.es6.mjs"() {
+    "use strict";
+  }
+});
+
+// ../../library/dist/common/runtime/decorator.library.js
+function getClassName(value2, contextName) {
+  return getSafeTag(value2) ?? (isUndefined(contextName) ? value2.name || void 0 : String(contextName));
+}
+function Serializable(value2, { kind, name, addInitializer }) {
+  const finalName = getClassName(value2, name);
+  if (finalName)
+    registerType(value2, finalName);
+  switch (kind) {
+    case "class":
+      if (finalName)
+        addInitializer(() => registerSerializable(finalName, value2));
+      return value2;
+    default:
+      throw new Error(`@Serializable decorating unknown 'kind': ${kind} (${name})`);
+  }
+}
+function StringTag(tagOrValue, context3) {
+  const applyTag = (value2, customTag, contextName) => {
+    const proto = value2.prototype;
+    const tagName = customTag ?? getClassName(value2, contextName);
+    if (tagName) {
+      if (proto && !Object.hasOwn(proto, Symbol.toStringTag)) {
+        Object.defineProperty(proto, Symbol.toStringTag, {
+          value: tagName,
+          configurable: true,
+          writable: false,
+          enumerable: false
+        });
+      }
+      if (!value2.name || value2.name !== tagName) {
+        try {
+          Object.defineProperty(value2, "name", {
+            value: tagName,
+            configurable: true,
+            writable: false,
+            enumerable: false
+          });
+        } catch {
+        }
+      }
+    }
+    return value2;
+  };
+  if (typeof tagOrValue === "function" && context3?.kind === "class")
+    return applyTag(tagOrValue, void 0, context3.name);
+  return (value2, ctx) => {
+    return applyTag(value2, isString(tagOrValue) ? tagOrValue : void 0, ctx?.name);
+  };
+}
+var init_decorator_library = __esm({
+  "../../library/dist/common/runtime/decorator.library.js"() {
+    "use strict";
+    init_symbol_library();
+    init_proxy_library();
+    init_assertion_library();
+    init_serialize_library();
+    init_type_library();
+  }
+});
+
+// ../../library/dist/common/runtime/enumerate.library.js
+function value(val) {
+  return { enumerable: false, configurable: false, writable: false, value: val };
+}
+function enumify(list, frozen = true) {
+  const type = getType(this);
+  const proto = type !== "Module" && isFunction(this?.has) ? this : ENUM;
+  const arg = asType(list);
+  const target = Object.create(proto);
+  switch (arg.type) {
+    case "Enumify":
+    case "Object":
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(arg.value));
+      break;
+    case "Array":
+      arg.value.forEach((key, index) => {
+        if (isNumber(key))
+          throw new Error("Enumify: numeric keys are not supported");
+        target[key] = index;
+      });
+      break;
+    default:
+      throw new Error(`Enumify: invalid argument type: ${arg.type}`);
+  }
+  return proxify(target, true, frozen);
+}
+var tag, ENUM, Enumify;
+var init_enumerate_library = __esm({
+  "../../library/dist/common/runtime/enumerate.library.js"() {
+    "use strict";
+    init_tslib_es6();
+    init_type_library();
+    init_assertion_library();
+    init_primitive_library();
+    init_proxy_library();
+    init_decorator_library();
+    init_function_library();
+    tag = "Enumify";
+    ENUM = secure(Object.create(null, {
+      keys: memoizeMethod("keys", function() {
+        return ownEntries(this, true).map(([key]) => key);
+      }),
+      values: memoizeMethod("values", function() {
+        return ownEntries(this, true).map(([_, val]) => val);
+      }),
+      entries: memoizeMethod("entries", function() {
+        return ownEntries(this, true).map(([key, val]) => Object.freeze([key, val]));
+      }),
+      invert: memoizeMethod("invert", function() {
+        return Object.fromEntries(this.entries().map(([key, val]) => [val, key]));
+      }),
+      has: value(function(key) {
+        return this.keys().includes(key);
+      }),
+      count: value(function() {
+        return this.keys().length;
+      }),
+      includes: value(function(search) {
+        return this.values().includes(search);
+      }),
+      keyOf: value(function(search) {
+        return this.invert()[search];
+      }),
+      extend: value(function(list, frozen) {
+        return enumify.call(this, list, frozen);
+      }),
+      forEach: value(function(fn, thisArg) {
+        this.entries().forEach((entry, index) => fn.call(thisArg, entry, index, this));
+      }),
+      filter: value(function(fn, thisArg) {
+        return enumify(this.entries().reduce((acc, entry, index) => fn.call(thisArg, entry, index, this) ? Object.assign(acc, { [entry[0]]: entry[1] }) : acc, {}));
+      }),
+      map: value(function(fn, thisArg) {
+        return enumify(this.entries().reduce((acc, entry, index) => Object.assign(acc, { [entry[0]]: fn.call(thisArg, entry, index, this) }), {}));
+      }),
+      [Symbol.iterator]: value(function* () {
+        for (const entry of this.entries())
+          yield entry;
+      }),
+      [Symbol.toStringTag]: { enumerable: false, configurable: false, writable: false, value: tag }
+    }));
+    Enumify = (() => {
+      let _classDecorators = [Serializable, StringTag("Enumify")];
+      let _classDescriptor;
+      let _classExtraInitializers = [];
+      let _classThis;
+      var Enumify2 = class {
+        static {
+          _classThis = this;
+        }
+        static {
+          const _metadata = typeof Symbol === "function" && Symbol.metadata ? /* @__PURE__ */ Object.create(null) : void 0;
+          __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+          Enumify2 = _classThis = _classDescriptor.value;
+          if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+          __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor(list) {
+          return enumify(list);
+        }
+      };
+      return Enumify2 = _classThis;
+    })();
+  }
+});
+
+// ../../library/dist/common/runtime/logger.class.js
+function parseLogLevel(level, fallback = LOG.Info) {
+  if (isNumber(level))
+    return level >= LOG.Off && level <= LOG.Trace ? level : fallback;
+  if (isString(level))
+    return Level[level.toLowerCase()] ?? fallback;
+  return fallback;
+}
+var LOG, Method, Level, Logger;
+var init_logger_class = __esm({
+  "../../library/dist/common/runtime/logger.class.js"() {
+    "use strict";
+    init_tslib_es6();
+    init_assertion_library();
+    init_enumerate_library();
+    init_symbol_library();
+    init_decorator_library();
+    LOG = enumify(["Off", "Error", "Warn", "Info", "Debug", "Trace"]);
+    Method = {
+      Off: "off",
+      Log: "log",
+      Info: "info",
+      Warn: "warn",
+      Debug: "debug",
+      Trace: "trace",
+      Error: "error"
+    };
+    Level = {
+      [Method.Off]: LOG.Off,
+      [Method.Error]: LOG.Error,
+      [Method.Warn]: LOG.Warn,
+      [Method.Info]: LOG.Info,
+      [Method.Log]: LOG.Info,
+      [Method.Debug]: LOG.Debug,
+      [Method.Trace]: LOG.Trace
+    };
+    Logger = (() => {
+      let _classDecorators = [StringTag("Logger")];
+      let _classDescriptor;
+      let _classExtraInitializers = [];
+      let _classThis;
+      var Logger2 = class {
+        static {
+          _classThis = this;
+        }
+        static {
+          const _metadata = typeof Symbol === "function" && Symbol.metadata ? /* @__PURE__ */ Object.create(null) : void 0;
+          __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+          Logger2 = _classThis = _classDescriptor.value;
+          if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+          __runInitializers(_classThis, _classExtraInitializers);
+        }
+        #namespace;
+        /** The current verbosity level */
+        level;
+        constructor(namespace, level = LOG.Info) {
+          this.#namespace = namespace.startsWith("[") ? namespace : `[${namespace}]`;
+          this.level = level;
+        }
+        #emit(method, ...msg) {
+          let config;
+          if (msg.length > 0 && isObject(msg[0])) {
+            try {
+              if (msg[0][sym.$LogConfig]) {
+                config = msg.shift();
+              }
+            } catch {
+            }
+          }
+          let activeLevel = this.level;
+          if (config) {
+            if (config.silent === true)
+              return;
+            if (config.debug !== void 0) {
+              activeLevel = parseLogLevel(config.debug, activeLevel);
+            }
+          }
+          if (activeLevel === LOG.Off)
+            return;
+          const methodLevel = Level[method] ?? 0;
+          if (methodLevel > activeLevel)
+            return;
+          const output = msg.map((m) => {
+            if (isError(m))
+              return m.message;
+            if (isObject(m)) {
+              try {
+                const name = m.constructor?.name ?? "Object";
+                if (name === "Object") {
+                  const keys = Object.keys(m);
+                  const summary = keys.slice(0, 3).join(", ");
+                  return `{ ${summary}${keys.length > 3 ? `, ... (+${keys.length - 3} more)` : ""} }`;
+                }
+                return `[${name}]`;
+              } catch {
+                return "[Object]";
+              }
+            }
+            return String(m);
+          }).filter((s) => !isEmpty(s)).join(" ");
+          if (!isEmpty(output)) {
+            const consoleMethod = method;
+            console[consoleMethod](`${this.#namespace} ${output}`);
+          }
+        }
+        /** console.log */
+        log = (...msg) => this.#emit(Method.Log, ...msg);
+        /** console.info */
+        info = (...msg) => this.#emit(Method.Info, ...msg);
+        /** console.warn */
+        warn = (...msg) => this.#emit(Method.Warn, ...msg);
+        /** console.debug */
+        debug = (...msg) => this.#emit(Method.Debug, ...msg);
+        /** console.trace */
+        trace = (...msg) => this.#emit(Method.Trace, ...msg);
+        /** console.error */
+        error = (...msg) => this.#emit(Method.Error, ...msg);
+      };
+      return Logger2 = _classThis;
+    })();
+  }
+});
+
+// ../../library/dist/common/runtime/storage.library.js
+var context, createMemoryStorage, memoryStores, getMemoryStorage, getSafeStorage, storage;
+var init_storage_library = __esm({
+  "../../library/dist/common/runtime/storage.library.js"() {
+    "use strict";
+    init_serialize_library();
+    init_utility_library();
+    init_assertion_library();
+    context = getContext();
+    createMemoryStorage = () => {
+      const map = /* @__PURE__ */ new Map();
+      return {
+        get length() {
+          return map.size;
+        },
+        clear: () => map.clear(),
+        getItem: (key) => map.get(key) ?? null,
+        key: (index) => Array.from(map.keys())[index] ?? null,
+        removeItem: (key) => {
+          map.delete(key);
+        },
+        setItem: (key, value2) => {
+          map.set(key, String(value2));
+        }
+      };
+    };
+    memoryStores = /* @__PURE__ */ new Map();
+    getMemoryStorage = (name) => {
+      let store = memoryStores.get(name);
+      if (!store) {
+        store = createMemoryStorage();
+        memoryStores.set(name, store);
+      }
+      return store;
+    };
+    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")
+          return target;
+      } catch {
+      }
+      return getMemoryStorage(name);
+    };
+    storage = context.type === CONTEXT.Browser ? getSafeStorage() : createMemoryStorage();
+  }
+});
+
+// ../../library/dist/browser/webstore.class.js
+var webstore_class_exports = {};
+__export(webstore_class_exports, {
+  WebStore: () => WebStore
+});
+var STORAGE, WebStore;
+var init_webstore_class = __esm({
+  "../../library/dist/browser/webstore.class.js"() {
+    "use strict";
+    init_tslib_es6();
+    init_primitive_library();
+    init_serialize_library();
+    init_type_library();
+    init_assertion_library();
+    init_storage_library();
+    init_decorator_library();
+    STORAGE = {
+      Local: "local",
+      Session: "session"
+    };
+    WebStore = (() => {
+      let _classDecorators = [StringTag("WebStore")];
+      let _classDescriptor;
+      let _classExtraInitializers = [];
+      let _classThis;
+      var WebStore2 = class {
+        static {
+          _classThis = this;
+        }
+        static {
+          const _metadata = typeof Symbol === "function" && Symbol.metadata ? /* @__PURE__ */ Object.create(null) : void 0;
+          __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+          WebStore2 = _classThis = _classDescriptor.value;
+          if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+          __runInitializers(_classThis, _classExtraInitializers);
+        }
+        static _localInstance;
+        static _sessionInstance;
+        /**
+         * Lazy getter for the localStorage wrapper instance.
+         *
+         * @returns The WebStore instance for localStorage
+         */
+        static get local() {
+          return WebStore2._localInstance ??= new WebStore2(STORAGE.Local);
+        }
+        /**
+         * Lazy getter for the sessionStorage wrapper instance.
+         *
+         * @returns The WebStore instance for sessionStorage
+         */
+        static get session() {
+          return WebStore2._sessionInstance ??= new WebStore2(STORAGE.Session);
+        }
+        #type;
+        #resolvedStorage;
+        /** Resolved Storage object (resolved safely on access with memory fallback) */
+        get #storage() {
+          if (this.#resolvedStorage)
+            return this.#resolvedStorage;
+          const name = this.#type === STORAGE.Local ? "localStorage" : "sessionStorage";
+          return this.#resolvedStorage = getSafeStorage(name);
+        }
+        #exec(op) {
+          try {
+            return op(this.#storage);
+          } catch (e) {
+            const name = this.#type === STORAGE.Local ? "localStorage" : "sessionStorage";
+            const fallback = getMemoryStorage(name);
+            this.#resolvedStorage = fallback;
+            return op(fallback);
+          }
+        }
+        constructor(storage2 = STORAGE.Local) {
+          this.#type = storage2;
+        }
+        /**
+         * Retrieve a value from storage, optionally providing a default.
+         *
+         * @param key - The property key to retrieve
+         * @param dflt - An optional default value if the key does not exist
+         * @returns The parsed object from storage, or the default/null if not found
+         */
+        get(key, dflt) {
+          const str = this.#exec((storage2) => storage2.getItem(stringify(key)));
+          return isString(str) ? objectify(str) : dflt ?? null;
+        }
+        /**
+         * Store or merge a value into storage for a given key.
+         *
+         * @param key - The property key to set. If nullish, clears the store.
+         * @param obj - The value to store
+         * @param opt - Options (merge behavior)
+         * @returns The WebStore instance for chaining
+         */
+        set(key, obj, opt = { merge: true }) {
+          if (isNullish(key))
+            return this.clear();
+          let prev = this.get(key);
+          const arg = asType(obj);
+          switch (arg.type) {
+            case "Undefined":
+              return this.del(key);
+            // synonym for 'removeItem'
+            case "Object":
+              prev ??= {};
+              return this.#upd(key, opt.merge ? Object.assign(prev, arg.value) : arg.value);
+            case "Array":
+              prev ??= [];
+              return this.#upd(key, opt.merge ? distinct(prev.concat(arg.value)) : obj);
+            case "Map":
+              prev ??= /* @__PURE__ */ new Map();
+              if (opt.merge) {
+                arg.value.forEach((val, key2) => prev.set(key2, val));
+                return this.#upd(key, prev);
+              }
+              return this.#upd(key, arg.value);
+            // else overwrite new Map
+            case "Set":
+              prev ??= /* @__PURE__ */ new Set();
+              if (opt.merge) {
+                arg.value.forEach((itm) => prev.add(itm));
+                return this.#upd(key, prev);
+              }
+              return this.#upd(key, arg.value);
+            // else overwrite new Set
+            default:
+              return this.#upd(key, arg.value);
+          }
+        }
+        /**
+         * Clear all items from this storage instance.
+         *
+         * @returns The WebStore instance for chaining
+         */
+        clear() {
+          try {
+            this.#exec((storage2) => storage2.clear());
+          } catch (e) {
+            console.warn("[WebStore] Failed to clear storage:", e);
+          }
+          return this;
+        }
+        /**
+         * Delete specific keys from storage.
+         *
+         * @param keys - The keys to remove
+         * @returns The WebStore instance for chaining
+         */
+        del(...keys) {
+          keys.forEach((key) => {
+            try {
+              this.#exec((storage2) => storage2.removeItem(stringify(key)));
+            } catch (e) {
+              console.warn(`[WebStore] Failed to removeItem for key '${String(key)}':`, e);
+            }
+          });
+          return this;
+        }
+        /**
+         * Get an array of keys currently in storage. If specific keys are provided, filters by those.
+         *
+         * @param keys - Optional keys to filter by
+         * @returns An array of string/symbol keys
+         */
+        keys(...keys) {
+          return this.entries(...keys).map(([key]) => key);
+        }
+        /**
+         * Get an array of values currently in storage.
+         *
+         * @param keys - Optional keys to retrieve values for
+         * @returns An array of parsed values
+         */
+        values(...keys) {
+          return this.entries(...keys).map(([, val]) => val);
+        }
+        /**
+         * Get an array of [key, value] entries currently in storage.
+         *
+         * @param keys - Optional keys to filter the entries by
+         * @returns An array of key-value tuples
+         */
+        entries(...keys) {
+          const wanted = new Set(keys.map((key) => stringify(key)));
+          const result = [];
+          this.#exec((storage2) => {
+            for (let i = 0; i < storage2.length; i++) {
+              const rawKey = storage2.key(i);
+              if (rawKey === null)
+                continue;
+              if (isEmpty(keys) || wanted.has(rawKey)) {
+                const rawVal = storage2.getItem(rawKey);
+                result.push([objectify(rawKey), objectify(rawVal)]);
+              }
+            }
+          });
+          return result;
+        }
+        /**
+         * Populate the storage from an existing object map.
+         *
+         * @param store - The object/dictionary to populate from
+         * @returns The WebStore instance for chaining
+         */
+        from(store) {
+          ownEntries(store).forEach(([key, val]) => this.set(key, val));
+          return this;
+        }
+        #upd(key, obj) {
+          try {
+            this.#exec((storage2) => storage2.setItem(stringify(key), stringify(obj)));
+          } catch (e) {
+            console.warn(`[WebStore] Failed to setItem for key '${String(key)}':`, e);
+          }
+          return this;
+        }
+      };
+      return WebStore2 = _classThis;
+    })();
+  }
+});
+
+// ../../library/dist/browser/mapper.library.js
+var mapper_library_exports = {};
+__export(mapper_library_exports, {
+  geoCoords: () => geoCoords,
+  geoLocation: () => geoLocation,
+  mapAddress: () => mapAddress,
+  mapHemisphere: () => mapHemisphere,
+  mapQuery: () => mapQuery
+});
+var defaults, context2, mapStore, MAP_KEY, log, storePromise, getStore, geoLocation, geoCoords, mapQuery, mapHemisphere, mapAddress;
+var init_mapper_library = __esm({
+  "../../library/dist/browser/mapper.library.js"() {
+    "use strict";
+    init_object_library();
+    init_utility_library();
+    init_assertion_library();
+    init_temporal_library();
+    init_international_library();
+    init_logger_class();
+    defaults = { catch: true, debug: 0 };
+    context2 = getContext();
+    mapStore = {};
+    MAP_KEY = "_map_";
+    log = new Logger("[Mapper]");
+    storePromise = null;
+    getStore = () => {
+      if (!storePromise) {
+        storePromise = new Promise((resolve, reject) => {
+          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, {}));
+              resolve(local);
+            }).catch(reject);
+          } else {
+            resolve(void 0);
+          }
+        });
+      }
+      return storePromise;
+    };
+    geoLocation = (opts = {}) => getStore().then(() => new Promise((resolve, reject) => {
+      opts = Object.assign({}, defaults, opts);
+      const fulfil = opts.catch ? resolve : reject;
+      if (typeof navigator !== "undefined" && "geolocation" in navigator) {
+        navigator["geolocation"].getCurrentPosition((value2) => {
+          const coords = mapStore.geolocation?.coords;
+          const prevLat = coords?.latitude?.toFixed(3);
+          const prevLng = coords?.longitude?.toFixed(3);
+          const prevTime = mapStore.geolocation?.timestamp ?? 0;
+          const test1 = value2.coords.latitude.toFixed(3) !== prevLat;
+          const test2 = value2.coords.longitude.toFixed(3) !== prevLng;
+          const test3 = prevTime < instant().epochMilliseconds - 36e5;
+          if (test1 || test2 || test3) {
+            Object.assign(mapStore, { georesponse: null });
+            log.info(opts, "GeoLocation: device update");
+          }
+          Object.assign(mapStore, { geolocation: asObject(value2) });
+          resolve(mapStore.geolocation);
+        }, (error) => {
+          Object.assign(mapStore, { geolocation: { error: error.message }, georesponse: null });
+          fulfil(mapStore.geolocation);
+        });
+      } else {
+        Object.assign(mapStore, { geolocation: { error: "Not Supported" }, georesponse: null });
+        fulfil(mapStore.geolocation);
+      }
+    })).finally(() => {
+      const fn = mapStore.geolocation?.error ? log.error : log.info;
+      fn(opts, "geoLocation: ", mapStore.geolocation);
+      getStore().then((store) => store?.set(MAP_KEY, mapStore));
+    });
+    geoCoords = (coords) => new Promise((resolve, reject) => {
+      if (!isNullish(coords))
+        return resolve(coords);
+      geoLocation().then(
+        (geo) => isNullish(geo.error) ? { location: { lat: geo.coords.latitude, lng: geo.coords.longitude } } : null
+        // unsuccessful geolocation
+      ).then((loc) => resolve(loc)).catch((err) => reject(err));
+    });
+    mapQuery = (coords, opts = {}) => getStore().then(() => new Promise((resolve, reject) => {
+      opts = Object.assign({}, defaults, opts);
+      const fulfil = opts.catch ? resolve : reject;
+      geoCoords(coords).then((loc) => {
+        switch (true) {
+          case !(typeof window !== "undefined" && "google" in window && "maps" in window["google"]):
+            throw new Error("Google Maps API not configured");
+          case isNullish(loc):
+            throw new Error("Cannot determine Coordinates");
+          case isNullish(coords): {
+            const test1 = mapStore.geolocation && mapStore.georesponse;
+            const test2 = isNullish(mapStore.geolocation?.error) && isNullish(mapStore.georesponse?.error);
+            if (test1 && test2) {
+              if (opts.debug)
+                log.debug(opts, "mapQuery: cache");
+              return resolve(mapStore.georesponse);
+            }
+          }
+          // drop through to default:
+          default:
+            new window["google"]["maps"].Geocoder().geocode(loc).then((res) => resolve(mapStore.georesponse = asObject(res)));
+        }
+      }).catch((error) => {
+        Object.assign(mapStore, { georesponse: { error: error.message } });
+        fulfil(mapStore.georesponse);
+      });
+    })).finally(() => {
+      if (opts.debug) {
+        const fn = mapStore.georesponse?.error ? log.error : log.debug;
+        fn(opts, "mapQuery: ", mapStore.georesponse);
+      }
+      getStore().then((store) => store?.set(MAP_KEY, mapStore));
+    });
+    mapHemisphere = (coords, opts = {}) => mapQuery(coords, opts).then((response) => {
+      opts = Object.assign({}, defaults, opts);
+      if (isNullish(response.error)) {
+        if (opts.debug)
+          log.debug(opts, "sphere: ", response);
+        return response.results[0].geometry.location.lat() >= 0 ? "north" : "south";
+      }
+      const sphere = getHemisphere();
+      if (isNullish(sphere) && opts.catch === false)
+        throw new Error("Cannot determine Hemisphere");
+      return sphere;
+    }).catch((error) => {
+      if (opts.debug)
+        log.warn(opts, "mapHemisphere: ", error.message);
+      if (opts.catch === false)
+        throw error;
+      return null;
+    });
+    mapAddress = (coords, opts = {}) => mapQuery(coords, opts).then((response) => {
+      if (!isNullish(response.error))
+        throw new Error(response.error);
+      return response.results[0];
+    }).then(({ formatted_address, address_components }) => address_components.reduce((acc, itm) => {
+      itm.types.filter((type) => type !== "political").forEach((type) => acc[type] = (acc[type] ? acc[type] + "," : "").concat(itm.short_name));
+      return acc;
+    }, { formatted_address })).catch((error) => {
+      opts = Object.assign({}, defaults, opts);
+      if (opts.debug)
+        log.warn(opts, "mapAddress: ", error.message);
+      if (opts.catch === false)
+        throw error;
+      return null;
+    });
+  }
+});
+
+// ../../library/dist/common/runtime/request.library.js
+var request_library_exports = {};
+__export(request_library_exports, {
+  HTTP: () => HTTP,
+  HttpError: () => HttpError,
+  METHOD: () => METHOD,
+  fetchHead: () => fetchHead,
+  fetchRequest: () => fetchRequest
+});
+var TWO_SECONDS, RE_TRAILING_CLOSURE, HTTP, METHOD, HttpError, readBoundedBody, fetchRequest, fetchHead;
+var init_request_library = __esm({
+  "../../library/dist/common/runtime/request.library.js"() {
+    "use strict";
+    init_assertion_library();
+    TWO_SECONDS = 2e3;
+    RE_TRAILING_CLOSURE = /\);?$/;
+    HTTP = {
+      Ok: 200,
+      PermRedirect: 301,
+      TempRedirect: 302,
+      BadRequest: 400,
+      Unauthorised: 401,
+      Forbidden: 403
+    };
+    METHOD = {
+      Head: "HEAD",
+      Get: "GET",
+      Put: "PUT",
+      Delete: "DELETE",
+      Post: "POST"
+    };
+    HttpError = class extends Error {
+      status;
+      statusText;
+      body;
+      constructor(status, statusText, body) {
+        super(`${status}: ${statusText}`);
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+        this.name = "HttpError";
+      }
+    };
+    readBoundedBody = async (res, maxBytes) => {
+      const contentLength = res.headers?.get?.("Content-Length") || res.headers?.get?.("content-length");
+      if (contentLength) {
+        const bytes = parseInt(contentLength, 10);
+        if (isNumber(bytes) && bytes > maxBytes) {
+          try {
+            await res.body?.cancel();
+          } catch {
+          }
+          throw new HttpError(413, `Content-Length (${bytes}) exceeds limit (${maxBytes} bytes)`, null);
+        }
+      }
+      if (!res.body) {
+        let rawText2;
+        if (isFunction(res.text)) {
+          rawText2 = await res.text();
+        } else if (isFunction(res.json)) {
+          const obj = await res.json();
+          rawText2 = JSON.stringify(obj) ?? "";
+        } else {
+          rawText2 = "";
+        }
+        const byteLength = new TextEncoder().encode(rawText2).byteLength;
+        if (byteLength > maxBytes)
+          throw new HttpError(413, `Payload length (${byteLength}) exceeds limit (${maxBytes} bytes)`, null);
+        return rawText2;
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let totalBytes = 0;
+      let rawText = "";
+      try {
+        while (true) {
+          const { done, value: value2 } = await reader.read();
+          if (done)
+            break;
+          if (value2) {
+            totalBytes += value2.byteLength;
+            if (totalBytes > maxBytes) {
+              try {
+                await reader.cancel();
+              } catch {
+              }
+              throw new HttpError(413, `Streamed payload exceeded limit (${maxBytes} bytes)`, null);
+            }
+            rawText += decoder.decode(value2, { stream: true });
+          }
+        }
+        rawText += decoder.decode();
+        return rawText;
+      } finally {
+        try {
+          reader.releaseLock();
+        } catch {
+        }
+      }
+    };
+    fetchRequest = (url, init = {}, config = {}) => {
+      const signallingInit = {
+        ...init,
+        signal: init.signal ? AbortSignal.any([init.signal, AbortSignal.timeout(config.timeout ?? TWO_SECONDS)]) : AbortSignal.timeout(config.timeout ?? TWO_SECONDS)
+      };
+      return fetch(url, signallingInit).then(async (res) => {
+        if (res.ok) {
+          const contentType = res.headers?.get?.("Content-Type") || res.headers?.get?.("content-type") || "";
+          const isJson = contentType.includes("application/json");
+          if (isDefined(config.maxBytes)) {
+            const rawText = await readBoundedBody(res, config.maxBytes);
+            if (config.rawText)
+              return rawText;
+            if (config.prefix) {
+              const json = rawText.startsWith(config.prefix) ? rawText.substring(config.prefix.length).replace(RE_TRAILING_CLOSURE, "") : rawText;
+              return JSON.parse(json);
+            }
+            if (isJson)
+              return JSON.parse(rawText);
+            try {
+              return JSON.parse(rawText);
+            } catch {
+              return rawText;
+            }
+          }
+          if (config.rawText) {
+            const text = isFunction(res.text) ? await res.text() : "";
+            return text;
+          }
+          if (config.prefix) {
+            const rawPrefixText = await res.text();
+            const json = rawPrefixText.startsWith(config.prefix) ? rawPrefixText.substring(config.prefix.length).replace(RE_TRAILING_CLOSURE, "") : rawPrefixText;
+            return JSON.parse(json);
+          }
+          if (isFunction(res.text)) {
+            const text = await res.text();
+            try {
+              return JSON.parse(text);
+            } catch {
+              return text;
+            }
+          }
+          if (isFunction(res.json))
+            return await res.json();
+          return "";
+        }
+        let errorBody = null;
+        try {
+          const errorText = isDefined(config.maxBytes) ? await readBoundedBody(res, config.maxBytes) : isFunction(res.text) ? await res.text() : "";
+          try {
+            errorBody = JSON.parse(errorText);
+          } catch {
+            errorBody = errorText;
+          }
+        } catch (err) {
+          if (err instanceof HttpError && err.status === 413)
+            throw err;
+        }
+        throw new HttpError(res.status, res.statusText, errorBody);
+      });
+    };
+    fetchHead = (url) => {
+      const signal = AbortSignal.timeout(TWO_SECONDS);
+      const init = { method: METHOD.Head, signal };
+      return fetch(url, init).then(({ ok, status, statusText, headers }) => {
+        if (ok || status === HTTP.Forbidden)
+          return { status, headers };
+        throw new HttpError(status, statusText, null);
+      });
+    };
+  }
+});
+
+// ../../library/dist/server/mapper.library.js
+var mapper_library_exports2 = {};
+__export(mapper_library_exports2, {
+  serverGeoCoords: () => serverGeoCoords,
+  serverGeoLocation: () => serverGeoLocation,
+  serverMapHemisphere: () => serverMapHemisphere
+});
+var log2, defaults2, requestModulePromise, getRequestModule, serverGeoLocation, serverGeoCoords, serverMapHemisphere;
+var init_mapper_library2 = __esm({
+  "../../library/dist/server/mapper.library.js"() {
+    "use strict";
+    init_assertion_library();
+    init_international_library();
+    init_logger_class();
+    log2 = new Logger("[ServerMapper]");
+    defaults2 = {
+      endpoint: "https://ipwho.is/",
+      timeout: 3e3,
+      catch: true,
+      debug: 0
+    };
+    requestModulePromise = null;
+    getRequestModule = () => {
+      if (!requestModulePromise)
+        requestModulePromise = Promise.resolve().then(() => (init_request_library(), request_library_exports));
+      return requestModulePromise;
+    };
+    serverGeoLocation = async (opts = {}) => {
+      const options = { ...defaults2, ...opts };
+      const fulfil = options.catch !== false;
+      try {
+        const endpoint = options.endpoint || defaults2.endpoint;
+        const timeout = options.timeout ?? defaults2.timeout;
+        const { fetchRequest: fetchRequest2 } = await getRequestModule();
+        const data = await fetchRequest2(endpoint, {}, { ...isNumber(timeout) ? { timeout } : {}, maxBytes: 64 * 1024 });
+        if (typeof data !== "object" || isNullish(data))
+          throw new Error("Geolocation lookup failed");
+        if (data.status === "fail" || data.success === false)
+          throw new Error(data.message || data.reason || "Geolocation lookup failed");
+        const lat = isNumber(data.lat) ? data.lat : data.latitude;
+        const lng = isNumber(data.lon) ? data.lon : data.lng ?? data.longitude;
+        if (!isNumber(lat) || !isNumber(lng))
+          throw new Error("Geolocation lookup failed");
+        const tz = isString(data.timezone) ? data.timezone : data.timezone?.id ?? data.timeZone;
+        const result = {
+          lat,
+          lng,
+          latitude: lat,
+          longitude: lng,
+          ...isString(data.country || data.countryName || data.country_name) ? { country: data.country || data.countryName || data.country_name } : {},
+          ...isString(data.city || data.cityName || data.city_name) ? { city: data.city || data.cityName || data.city_name } : {},
+          ...isString(tz) ? { timezone: tz } : {},
+          ...isString(data.query || data.ip || data.ip_address) ? { query: data.query || data.ip || data.ip_address } : {},
+          status: "success"
+        };
+        if (options.debug)
+          log2.info(options, "serverGeoLocation success: ", result);
+        return result;
+      } catch (err) {
+        const errorMsg = err?.message || "Server geolocation error";
+        if (options.debug)
+          log2.error(options, "serverGeoLocation error: ", errorMsg);
+        if (!fulfil)
+          throw err;
+        return { error: errorMsg, status: "fail" };
+      }
+    };
+    serverGeoCoords = async (coords, opts) => {
+      if (!isNullish(coords)) {
+        const lat = coords.latitude ?? coords.lat;
+        const lng = coords.longitude ?? coords.lng ?? coords.lon ?? coords.long;
+        if (isNumber(lat) && isNumber(lng))
+          return { lat, lng };
+      }
+      const geo = await serverGeoLocation(opts);
+      if (isNullish(geo.error) && isNumber(geo.lat) && isNumber(geo.lng))
+        return { lat: geo.lat, lng: geo.lng };
+      return null;
+    };
+    serverMapHemisphere = async (coords, opts) => {
+      const resolved = await serverGeoCoords(coords, opts);
+      if (resolved)
+        return resolved.lat >= 0 ? "north" : "south";
+      return getHemisphere() ?? null;
+    };
+  }
+});
+
+// auto-inject-version:@magmacomputing/tempo/plugin/sdk
+var sdk_exports = {};
+__export(sdk_exports, {
+  definePlugin: () => definePlugin,
+  defineTerm: () => defineTerm
+});
+__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: "0.1.0" });
+var defineTerm = (config) => originalTerm({ ...config, version: "0.1.0" });
+
+// ../../library/dist/common/runtime/mapper.library.js
+init_utility_library();
+init_assertion_library();
+var coerceGeo = (input) => {
+  if (isNullish(input) || typeof input !== "object")
+    return void 0;
+  const geoObj = input.geo ?? input;
+  const cfgGeo = input.config?.geo ?? input.config;
+  const lat = geoObj?.latitude ?? geoObj?.lat ?? input.latitude ?? input.lat ?? cfgGeo?.latitude ?? cfgGeo?.lat;
+  const lng = geoObj?.longitude ?? geoObj?.lng ?? geoObj?.lon ?? geoObj?.long ?? input.longitude ?? input.lng ?? input.lon ?? input.long ?? cfgGeo?.longitude ?? cfgGeo?.lng ?? cfgGeo?.lon ?? cfgGeo?.long;
+  const elevation = geoObj?.elevation ?? input.elevation ?? cfgGeo?.elevation;
+  const sphere = geoObj?.sphere ?? input.sphere ?? cfgGeo?.sphere;
+  const country = geoObj?.country ?? input.country ?? cfgGeo?.country;
+  const city = geoObj?.city ?? input.city ?? cfgGeo?.city;
+  const result = {};
+  if (isNumber(lat))
+    result.latitude = lat;
+  if (isNumber(lng))
+    result.longitude = lng;
+  if (isNumber(elevation))
+    result.elevation = elevation;
+  if (sphere === "north" || sphere === "south")
+    result.sphere = sphere;
+  if (isString(country))
+    result.country = country;
+  if (isString(city))
+    result.city = city;
+  if (geoObj && typeof geoObj === "object") {
+    for (const key of Object.keys(geoObj)) {
+      if (isSafeKey(key) && !["latitude", "lat", "longitude", "lng", "lon", "long", "elevation", "sphere", "country", "city"].includes(key))
+        result[key] = geoObj[key];
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+};
+var getStashedGeo = () => {
+  const { type } = getContext();
+  if (type === CONTEXT.Browser || type === CONTEXT.WebWorker) {
+    try {
+      if (typeof localStorage !== "undefined") {
+        const raw = localStorage.getItem("_map_");
+        if (raw) {
+          const parsed = JSON.parse(raw);
+          const coords = parsed?.geolocation?.coords;
+          if (isNumber(coords?.latitude) && isNumber(coords?.longitude)) {
+            return { latitude: coords.latitude, longitude: coords.longitude };
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return void 0;
+};
+var geoLookup = async (opts = {}) => {
+  const { type } = getContext();
+  switch (type) {
+    case CONTEXT.Browser: {
+      const { geoLocation: geoLocation2 } = await Promise.resolve().then(() => (init_mapper_library(), mapper_library_exports));
+      const res = await geoLocation2(opts);
+      if (res.error)
+        return { error: res.error };
+      const lat = res.coords?.latitude;
+      const lng = res.coords?.longitude;
+      return { lat, lng, latitude: lat, longitude: lng, ...res };
+    }
+    case CONTEXT.WebWorker: {
+      const stashed = getStashedGeo();
+      if (stashed && isNumber(stashed.latitude) && isNumber(stashed.longitude))
+        return { lat: stashed.latitude, lng: stashed.longitude, latitude: stashed.latitude, longitude: stashed.longitude };
+      const { serverGeoLocation: serverGeoLocation2 } = await Promise.resolve().then(() => (init_mapper_library2(), mapper_library_exports2));
+      return serverGeoLocation2(opts);
+    }
+    case CONTEXT.NodeJS:
+    case CONTEXT.Deno:
+    default: {
+      const { serverGeoLocation: serverGeoLocation2 } = await Promise.resolve().then(() => (init_mapper_library2(), mapper_library_exports2));
+      return serverGeoLocation2(opts);
+    }
+  }
+};
+var resolveGeoCoordinates = async (input, opts = {}) => {
+  const coerced = coerceGeo(input);
+  if (coerced && isNumber(coerced.latitude) && isNumber(coerced.longitude))
+    return { lat: coerced.latitude, lng: coerced.longitude };
+  const stashed = getStashedGeo();
+  if (stashed && isNumber(stashed.latitude) && isNumber(stashed.longitude))
+    return { lat: stashed.latitude, lng: stashed.longitude };
+  const lookup = await geoLookup(opts);
+  if (isNullish(lookup.error) && isNumber(lookup.lat) && isNumber(lookup.lng))
+    return { lat: lookup.lat, lng: lookup.lng };
+  return null;
+};
+
+// src/index.ts
+init_mapper_library2();
+init_mapper_library();
+var GeoPlugin = definePlugin({
+  name: "geo",
+  install(TempoClass) {
+    TempoClass.geoLookup = geoLookup;
+    TempoClass.resolveGeoCoordinates = resolveGeoCoordinates;
+    TempoClass.serverGeoLocation = serverGeoLocation;
+    TempoClass.geoLocation = geoLocation;
+    TempoClass.prototype.geoLocate = async function(opts) {
+      const coords = await resolveGeoCoordinates(this, opts);
+      if (coords) {
+        const existingGeo = typeof this.config.geo === "object" && this.config.geo !== null ? this.config.geo : {};
+        return new TempoClass(this, {
+          ...this.config,
+          geo: {
+            ...existingGeo,
+            latitude: coords.lat,
+            longitude: coords.lng
+          }
+        });
+      }
+      return this;
+    };
+    TempoClass.prototype.geoLookup = async function(opts) {
+      return resolveGeoCoordinates(this, opts);
+    };
+  }
+});
+var geoPlugin = GeoPlugin;
+var index_default = GeoPlugin;
+export {
+  GeoPlugin,
+  coerceGeo,
+  index_default as default,
+  geoLocation,
+  geoLookup,
+  geoPlugin,
+  getStashedGeo,
+  resolveGeoCoordinates,
+  serverGeoCoords,
+  serverGeoLocation,
+  serverMapHemisphere
+};