@lightsparkdev/core 1.4.2 → 1.4.4

package/dist/react-native/index.cjs

@@ -0,0 +1,3111 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react-native/index.ts
+var react_native_exports = {};
+__export(react_native_exports, {
+  ConfigKeys: () => ConfigKeys,
+  CurrencyUnit: () => CurrencyUnit,
+  DefaultCrypto: () => DefaultCrypto,
+  KeyOrAlias: () => KeyOrAlias,
+  LightsparkAuthException: () => LightsparkAuthException_default,
+  LightsparkException: () => LightsparkException_default,
+  LightsparkSigningException: () => LightsparkSigningException_default,
+  Logger: () => Logger,
+  LoggingLevel: () => LoggingLevel,
+  NodeKeyCache: () => NodeKeyCache_default,
+  RSASigningKey: () => RSASigningKey,
+  Requester: () => Requester_default,
+  Secp256k1SigningKey: () => Secp256k1SigningKey,
+  ServerEnvironment: () => ServerEnvironment_default,
+  SigningKey: () => SigningKey,
+  SigningKeyType: () => SigningKeyType,
+  StubAuthProvider: () => StubAuthProvider,
+  abbrCurrencyUnit: () => abbrCurrencyUnit,
+  apiDomainForEnvironment: () => apiDomainForEnvironment,
+  b64decode: () => b64decode,
+  b64encode: () => b64encode,
+  bytesToHex: () => bytesToHex,
+  clamp: () => clamp,
+  convertCurrencyAmount: () => convertCurrencyAmount,
+  convertCurrencyAmountValue: () => convertCurrencyAmountValue,
+  countryCodesToCurrencyCodes: () => countryCodesToCurrencyCodes,
+  createSha256Hash: () => createSha256Hash,
+  defaultCurrencyCode: () => defaultCurrencyCode,
+  deleteLocalStorageItem: () => deleteLocalStorageItem,
+  ensureArray: () => ensureArray,
+  errorToJSON: () => errorToJSON,
+  formatCurrencyStr: () => formatCurrencyStr,
+  formatInviteAmount: () => formatInviteAmount,
+  getCurrencyAmount: () => getCurrencyAmount,
+  getCurrentLocale: () => getCurrentLocale,
+  getErrorMsg: () => getErrorMsg,
+  getLocalStorageBoolean: () => getLocalStorageBoolean,
+  getLocalStorageConfigItem: () => getLocalStorageConfigItem,
+  hexToBytes: () => hexToBytes,
+  isBare: () => isBare,
+  isBrowser: () => isBrowser,
+  isCurrencyAmountInputObj: () => isCurrencyAmountInputObj,
+  isCurrencyAmountObj: () => isCurrencyAmountObj,
+  isCurrencyAmountPreferenceObj: () => isCurrencyAmountPreferenceObj,
+  isCurrencyMap: () => isCurrencyMap,
+  isDeprecatedCurrencyAmountObj: () => isDeprecatedCurrencyAmountObj,
+  isError: () => isError,
+  isErrorMsg: () => isErrorMsg,
+  isErrorWithMessage: () => isErrorWithMessage,
+  isNode: () => isNode,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isReactNative: () => isReactNative,
+  isRecord: () => isRecord,
+  isSDKCurrencyAmount: () => isSDKCurrencyAmount,
+  isTest: () => isTest,
+  isType: () => isType,
+  isUint8Array: () => isUint8Array,
+  isUmaCurrencyAmount: () => isUmaCurrencyAmount,
+  linearInterpolate: () => linearInterpolate,
+  localeToCurrencyCode: () => localeToCurrencyCode,
+  localeToCurrencySymbol: () => localeToCurrencySymbol,
+  logger: () => logger,
+  lsidToUUID: () => lsidToUUID,
+  mapCurrencyAmount: () => mapCurrencyAmount,
+  notNullUndefined: () => notNullUndefined,
+  pollUntil: () => pollUntil,
+  round: () => round,
+  separateCurrencyStrParts: () => separateCurrencyStrParts,
+  setLocalStorageBoolean: () => setLocalStorageBoolean,
+  sleep: () => sleep,
+  urlsafe_b64decode: () => urlsafe_b64decode,
+  zipcodeToState: () => zipcodeToState,
+  zipcodeToStateCode: () => zipcodeToStateCode
+});
+module.exports = __toCommonJS(react_native_exports);
+
+// ../../node_modules/auto-bind/index.js
+var getAllProperties = (object) => {
+  const properties = /* @__PURE__ */ new Set();
+  do {
+    for (const key of Reflect.ownKeys(object)) {
+      properties.add([object, key]);
+    }
+  } while ((object = Reflect.getPrototypeOf(object)) && object !== Object.prototype);
+  return properties;
+};
+function autoBind(self2, { include, exclude } = {}) {
+  const filter = (key) => {
+    const match = (pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key);
+    if (include) {
+      return include.some(match);
+    }
+    if (exclude) {
+      return !exclude.some(match);
+    }
+    return true;
+  };
+  for (const [object, key] of getAllProperties(self2.constructor.prototype)) {
+    if (key === "constructor" || !filter(key)) {
+      continue;
+    }
+    const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
+    if (descriptor && typeof descriptor.value === "function") {
+      self2[key] = self2[key].bind(self2);
+    }
+  }
+  return self2;
+}
+
+// src/requester/Requester.ts
+var import_dayjs = __toESM(require("dayjs"), 1);
+var import_utc = __toESM(require("dayjs/plugin/utc.js"), 1);
+var import_zen_observable_ts = require("zen-observable-ts");
+
+// src/auth/StubAuthProvider.ts
+var StubAuthProvider = class {
+  addAuthHeaders(headers) {
+    return Promise.resolve(headers);
+  }
+  isAuthorized() {
+    return Promise.resolve(false);
+  }
+  addWsConnectionParams(params) {
+    return Promise.resolve(params);
+  }
+};
+
+// src/LightsparkException.ts
+var LightsparkException = class extends Error {
+  code;
+  message;
+  extraInfo;
+  constructor(code, message, extraInfo) {
+    super(message);
+    this.code = code;
+    this.message = message;
+    this.extraInfo = extraInfo;
+  }
+};
+var LightsparkException_default = LightsparkException;
+
+// src/utils/base64.ts
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+var Base64 = {
+  btoa: (input = "") => {
+    const str = input;
+    let output = "";
+    for (let block = 0, charCode, i = 0, map = chars; str.charAt(i | 0) || (map = "=", i % 1); output += map.charAt(63 & block >> 8 - i % 1 * 8)) {
+      charCode = str.charCodeAt(i += 3 / 4);
+      if (charCode > 255) {
+        throw new Error(
+          "'btoa' failed: The string to be encoded contains characters outside of the Latin1 range."
+        );
+      }
+      block = block << 8 | charCode;
+    }
+    return output;
+  },
+  atob: (input = "") => {
+    const str = input.replace(/=+$/, "");
+    let output = "";
+    if (str.length % 4 == 1) {
+      throw new Error(
+        "'atob' failed: The string to be decoded is not correctly encoded."
+      );
+    }
+    for (let bc = 0, bs = 0, buffer, i = 0; buffer = str.charAt(i++); ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer, bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0) {
+      buffer = chars.indexOf(buffer);
+    }
+    return output;
+  }
+};
+var b64decode = (encoded) => {
+  return Uint8Array.from(Base64.atob(encoded), (c) => c.charCodeAt(0));
+};
+var urlsafe_b64decode = (encoded) => {
+  return b64decode(encoded.replace(/_/g, "/").replace(/-/g, "+"));
+};
+var b64encode = (data) => {
+  return Base64.btoa(
+    String.fromCharCode.apply(null, Array.from(new Uint8Array(data)))
+  );
+};
+
+// src/crypto/LightsparkSigningException.ts
+var LightsparkSigningException = class extends LightsparkException_default {
+  constructor(message, extraInfo) {
+    super("SigningException", message, extraInfo);
+  }
+};
+var LightsparkSigningException_default = LightsparkSigningException;
+
+// src/crypto/crypto.ts
+var getCrypto = () => {
+  let cryptoImplPromise;
+  if (typeof crypto !== "undefined") {
+    cryptoImplPromise = Promise.resolve(crypto);
+  } else {
+    cryptoImplPromise = import("crypto").then((nodeCrypto) => {
+      let cryptoModule = nodeCrypto;
+      if (!nodeCrypto.subtle) {
+        cryptoModule = Object.assign({}, cryptoModule, {
+          subtle: nodeCrypto.webcrypto.subtle
+        });
+      }
+      if (!nodeCrypto.getRandomValues) {
+        cryptoModule = Object.assign({}, cryptoModule, {
+          getRandomValues: (array) => {
+            if (!array) {
+              return array;
+            }
+            const buffer = Buffer.from(array.buffer);
+            const view = new Uint8Array(buffer);
+            nodeCrypto.randomFillSync(view);
+            return array;
+          }
+        });
+      }
+      return cryptoModule;
+    });
+  }
+  return cryptoImplPromise;
+};
+var getRandomValues32 = async (arr) => {
+  if (typeof crypto !== "undefined") {
+    return crypto.getRandomValues(arr);
+  } else {
+    const cryptoImpl = await getCrypto();
+    return cryptoImpl.getRandomValues(arr);
+  }
+};
+var deriveKey = async (password, salt, iterations, algorithm, bit_len) => {
+  const enc = new TextEncoder();
+  const cryptoImpl = await getCrypto();
+  const password_key = await cryptoImpl.subtle.importKey(
+    "raw",
+    enc.encode(password),
+    "PBKDF2",
+    false,
+    ["deriveBits", "deriveKey"]
+  );
+  const derived = await cryptoImpl.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt,
+      iterations,
+      hash: "SHA-256"
+    },
+    password_key,
+    bit_len
+  );
+  const key = await cryptoImpl.subtle.importKey(
+    "raw",
+    derived.slice(0, 32),
+    { name: algorithm, length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+  const iv = derived.slice(32);
+  return [key, iv];
+};
+var decrypt = async (header_json, ciphertext, password) => {
+  let decoded = b64decode(ciphertext);
+  let header;
+  if (header_json === "AES_256_CBC_PBKDF2_5000_SHA256") {
+    header = {
+      v: 0,
+      i: 5e3
+    };
+    decoded = decoded.slice(8);
+  } else {
+    header = JSON.parse(header_json);
+  }
+  if (header.v < 0 || header.v > 4) {
+    throw new LightsparkException_default(
+      "DecryptionError",
+      `Unknown version ${header.v}`
+    );
+  }
+  const cryptoImpl = await getCrypto();
+  const algorithm = header.v < 2 ? "AES-CBC" : "AES-GCM";
+  const bit_len = header.v < 4 ? 384 : 352;
+  const salt_len = header.v < 4 ? 8 : 16;
+  if (header.lsv === 2 || header.v === 3) {
+    const salt = decoded.slice(decoded.length - 8, decoded.length);
+    const nonce = decoded.slice(0, 12);
+    const cipherText = decoded.slice(12, decoded.length - 8);
+    const [
+      key
+      /* , _iv */
+    ] = await deriveKey(
+      password,
+      salt,
+      header.i,
+      algorithm,
+      256
+    );
+    return await cryptoImpl.subtle.decrypt(
+      { name: algorithm, iv: nonce.buffer },
+      key,
+      cipherText
+    );
+  } else {
+    const salt = decoded.slice(0, salt_len);
+    const encrypted = decoded.slice(salt_len);
+    const [key, iv] = await deriveKey(
+      password,
+      salt,
+      header.i,
+      algorithm,
+      bit_len
+    );
+    return await cryptoImpl.subtle.decrypt(
+      { name: algorithm, iv },
+      key,
+      encrypted
+    );
+  }
+};
+async function decryptSecretWithNodePassword(cipher, encryptedSecret, nodePassword) {
+  let decryptedValue = null;
+  try {
+    decryptedValue = await decrypt(cipher, encryptedSecret, nodePassword);
+  } catch (ex) {
+    console.error(ex);
+  }
+  return decryptedValue;
+}
+var generateSigningKeyPair = async () => {
+  const cryptoImpl = await getCrypto();
+  return await cryptoImpl.subtle.generateKey(
+    /*algorithm:*/
+    {
+      name: "RSA-PSS",
+      modulusLength: 4096,
+      publicExponent: new Uint8Array([1, 0, 1]),
+      hash: "SHA-256"
+    },
+    /*extractable*/
+    true,
+    /*keyUsages*/
+    ["sign", "verify"]
+  );
+};
+var serializeSigningKey = async (key, format) => {
+  const cryptoImpl = await getCrypto();
+  return await cryptoImpl.subtle.exportKey(
+    /*format*/
+    format,
+    /*key*/
+    key
+  );
+};
+var getNonce = async () => {
+  const nonceSt = await getRandomValues32(new Uint32Array(2));
+  const [upper, lower] = nonceSt;
+  const nonce = BigInt(upper) << 32n | BigInt(lower);
+  return Number(nonce);
+};
+var sign = async (keyOrAlias, data) => {
+  if (typeof keyOrAlias === "string") {
+    throw new LightsparkSigningException_default(
+      "Key alias not supported for default crypto."
+    );
+  }
+  const cryptoImpl = await getCrypto();
+  return await cryptoImpl.subtle.sign(
+    {
+      name: "RSA-PSS",
+      saltLength: 32
+    },
+    keyOrAlias,
+    data
+  );
+};
+var importPrivateSigningKey = async (keyData) => {
+  const cryptoImpl = await getCrypto();
+  return await cryptoImpl.subtle.importKey(
+    /*format*/
+    "pkcs8",
+    /*keyData*/
+    keyData,
+    /*algorithm*/
+    {
+      name: "RSA-PSS",
+      hash: "SHA-256"
+    },
+    /*extractable*/
+    true,
+    /*keyUsages*/
+    ["sign"]
+  );
+};
+var DefaultCrypto = {
+  decryptSecretWithNodePassword,
+  generateSigningKeyPair,
+  serializeSigningKey,
+  getNonce,
+  sign,
+  importPrivateSigningKey
+};
+
+// src/constants/index.ts
+var ConfigKeys = {
+  LoggingEnabled: "lightspark-logging-enabled",
+  ConsoleToolsEnabled: "lightspark-console-tools-enabled"
+};
+
+// src/utils/environment.ts
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var isTest = isNode && process.env.NODE_ENV === "test";
+var isBare = typeof Bare !== "undefined";
+var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+
+// src/utils/localStorage.ts
+function getLocalStorageConfigItem(key) {
+  const localStorageBoolean = getLocalStorageBoolean(key);
+  if (localStorageBoolean == null) {
+    return false;
+  }
+  return localStorageBoolean;
+}
+function getLocalStorageBoolean(key) {
+  try {
+    if (localStorage.getItem(key) === "1") {
+      return true;
+    } else if (localStorage.getItem(key) == null) {
+      return null;
+    } else {
+      return false;
+    }
+  } catch (e) {
+    return null;
+  }
+}
+function setLocalStorageBoolean(key, value) {
+  try {
+    localStorage.setItem(key, value ? "1" : "0");
+  } catch (e) {
+  }
+}
+var deleteLocalStorageItem = (key) => {
+  try {
+    localStorage.removeItem(key);
+  } catch (e) {
+  }
+};
+
+// src/Logger.ts
+var LoggingLevel = /* @__PURE__ */ ((LoggingLevel2) => {
+  LoggingLevel2[LoggingLevel2["Trace"] = 0] = "Trace";
+  LoggingLevel2[LoggingLevel2["Info"] = 1] = "Info";
+  return LoggingLevel2;
+})(LoggingLevel || {});
+var Logger = class {
+  context;
+  loggingEnabled = false;
+  loggingLevel = 1 /* Info */;
+  constructor(loggerContext, getLoggingEnabled) {
+    this.context = loggerContext;
+    void this.updateLoggingEnabled(getLoggingEnabled);
+  }
+  setLevel(level) {
+    this.loggingLevel = level;
+  }
+  setEnabled(enabled, level = 1 /* Info */) {
+    this.loggingEnabled = enabled;
+    this.loggingLevel = level;
+  }
+  async updateLoggingEnabled(getLoggingEnabled) {
+    if (getLoggingEnabled) {
+      this.loggingEnabled = await getLoggingEnabled();
+    } else if (isTest) {
+      this.loggingEnabled = true;
+    } else if (isBrowser) {
+      try {
+        this.loggingEnabled = getLocalStorageConfigItem(
+          ConfigKeys.LoggingEnabled
+        );
+      } catch (e) {
+      }
+    }
+    if (this.loggingEnabled) {
+      console.log(`[${this.context}] Logging enabled`);
+    }
+  }
+  trace(message, ...rest) {
+    if (this.loggingEnabled && this.loggingLevel === 0 /* Trace */) {
+      console.log(`[${this.context}] ${message}`, ...rest);
+    }
+  }
+  info(message, ...rest) {
+    if (this.loggingEnabled && this.loggingLevel <= 1 /* Info */) {
+      console.log(`[${this.context}] ${message}`, ...rest);
+    }
+  }
+};
+var logger = new Logger("@lightsparkdev/core");
+
+// src/requester/Requester.ts
+var DEFAULT_BASE_URL = "api.lightspark.com";
+import_dayjs.default.extend(import_utc.default);
+var Requester = class {
+  constructor(nodeKeyCache, schemaEndpoint, sdkUserAgent, authProvider = new StubAuthProvider(), baseUrl = DEFAULT_BASE_URL, cryptoImpl = DefaultCrypto, signingKey, fetchImpl = fetch) {
+    this.nodeKeyCache = nodeKeyCache;
+    this.schemaEndpoint = schemaEndpoint;
+    this.sdkUserAgent = sdkUserAgent;
+    this.authProvider = authProvider;
+    this.baseUrl = baseUrl;
+    this.cryptoImpl = cryptoImpl;
+    this.signingKey = signingKey;
+    this.fetchImpl = fetchImpl;
+    this.wsClient = new Promise((resolve) => {
+      this.resolveWsClient = resolve;
+    });
+    void this.initWsClient(baseUrl, authProvider);
+    autoBind(this);
+  }
+  wsClient;
+  resolveWsClient = null;
+  initWsClient(baseUrl, authProvider) {
+    return Promise.resolve(null);
+  }
+  async executeQuery(query) {
+    const data = await this.makeRawRequest(
+      query.queryPayload,
+      query.variables || {},
+      query.signingNodeId,
+      !!query.skipAuth
+    );
+    return query.constructObject(data);
+  }
+  subscribe(queryPayload, variables = {}) {
+    logger.trace(`Requester.subscribe variables`, variables);
+    const operationNameRegex = /^\s*(query|mutation|subscription)\s+(\w+)/i;
+    const operationMatch = queryPayload.match(operationNameRegex);
+    if (!operationMatch || operationMatch.length < 3) {
+      throw new LightsparkException_default("InvalidQuery", "Invalid query payload");
+    }
+    const operationType = operationMatch[1];
+    logger.trace(`Requester.subscribe operationType`, operationType);
+    if (operationType == "mutation") {
+      throw new LightsparkException_default(
+        "InvalidQuery",
+        "Mutation queries should call makeRawRequest instead"
+      );
+    }
+    for (const key in variables) {
+      if (variables[key] === void 0) {
+        variables[key] = null;
+      }
+    }
+    const operation = operationMatch[2];
+    const bodyData = {
+      query: queryPayload,
+      variables,
+      operationName: operation
+    };
+    return new import_zen_observable_ts.Observable((observer) => {
+      logger.trace(`Requester.subscribe observer`, observer);
+      let cleanup = null;
+      let canceled = false;
+      void (async () => {
+        try {
+          const wsClient = await this.wsClient;
+          if (!wsClient) {
+            throw new LightsparkException_default(
+              "WebSocketNotInitialized",
+              "WebSocket client is not initialized or is not available in the current environment."
+            );
+          }
+          if (!canceled) {
+            cleanup = wsClient.subscribe(bodyData, {
+              next: (data) => observer.next(data),
+              error: (err) => observer.error(err),
+              complete: () => observer.complete()
+            });
+          }
+        } catch (err) {
+          observer.error(err);
+        }
+      })();
+      return () => {
+        canceled = true;
+        if (cleanup) {
+          cleanup();
+        }
+      };
+    });
+  }
+  async makeRawRequest(queryPayload, variables = {}, signingNodeId = void 0, skipAuth = false) {
+    logger.trace(`Requester.makeRawRequest args`, {
+      queryPayload,
+      variables,
+      signingNodeId,
+      skipAuth
+    });
+    const operationNameRegex = /^\s*(query|mutation|subscription)\s+(\w+)/i;
+    const operationMatch = queryPayload.match(operationNameRegex);
+    if (!operationMatch || operationMatch.length < 3) {
+      throw new LightsparkException_default("InvalidQuery", "Invalid query payload");
+    }
+    const operationType = operationMatch[1];
+    if (operationType == "subscription") {
+      throw new LightsparkException_default(
+        "InvalidQuery",
+        "Subscription queries should call subscribe instead"
+      );
+    }
+    for (const key in variables) {
+      if (variables[key] === void 0) {
+        variables[key] = null;
+      }
+    }
+    const operation = operationMatch[2];
+    const payload = {
+      query: queryPayload,
+      variables,
+      operationName: operation
+    };
+    const browserUserAgent = typeof navigator !== "undefined" ? navigator.userAgent : "";
+    const sdkUserAgent = this.getSdkUserAgent();
+    const baseHeaders = {
+      "Content-Type": "application/json",
+      "X-Lightspark-SDK": sdkUserAgent,
+      "User-Agent": browserUserAgent || sdkUserAgent,
+      "X-GraphQL-Operation": operation
+    };
+    const headers = skipAuth ? baseHeaders : await this.authProvider.addAuthHeaders(baseHeaders);
+    let bodyData = await this.addSigningDataIfNeeded(
+      payload,
+      headers,
+      signingNodeId
+    );
+    if (bodyData.length > 1024 && typeof CompressionStream != "undefined") {
+      bodyData = await compress(bodyData);
+      headers["Content-Encoding"] = "deflate";
+    }
+    let urlWithProtocol = this.baseUrl;
+    if (!urlWithProtocol.startsWith("https://") && !urlWithProtocol.startsWith("http://")) {
+      urlWithProtocol = `https://${urlWithProtocol}`;
+    }
+    const url = `${urlWithProtocol}/${this.schemaEndpoint}`;
+    logger.trace(`Requester.makeRawRequest`, {
+      url,
+      operationName: operation,
+      variables,
+      headers
+    });
+    const response = await this.fetchImpl(url, {
+      method: "POST",
+      headers,
+      body: bodyData
+    });
+    if (!response.ok) {
+      throw new LightsparkException_default(
+        "RequestFailed",
+        `Request ${operation} failed. ${response.statusText}`
+      );
+    }
+    const responseJson = await response.json();
+    const data = responseJson.data;
+    if (!data) {
+      let firstErrorName = void 0;
+      if (Array.isArray(responseJson.errors) && responseJson.errors.length > 0) {
+        const firstError = responseJson.errors[0];
+        firstErrorName = firstError["extensions"]?.["error_name"];
+      }
+      throw new LightsparkException_default(
+        "RequestFailed",
+        `Request ${operation} failed. ${JSON.stringify(responseJson.errors)}`,
+        { errorName: firstErrorName }
+      );
+    }
+    return data;
+  }
+  getSdkUserAgent() {
+    const platform = isNode ? "NodeJS" : "Browser";
+    const platformVersion = isNode ? process.version : "";
+    return `${this.sdkUserAgent} ${platform}/${platformVersion}`;
+  }
+  stripProtocol(url) {
+    return url.replace(/.*?:\/\//g, "");
+  }
+  async addSigningDataIfNeeded(queryPayload, headers, signingNodeId) {
+    if (!signingNodeId) {
+      return new TextEncoder().encode(JSON.stringify(queryPayload));
+    }
+    const query = queryPayload.query;
+    const variables = queryPayload.variables;
+    const operationName = queryPayload.operationName;
+    const nonce = await this.cryptoImpl.getNonce();
+    const expiration = import_dayjs.default.utc().add(1, "hour").format();
+    const payload = {
+      query,
+      variables,
+      operationName,
+      nonce,
+      expires_at: expiration
+    };
+    const key = this.signingKey ?? this.nodeKeyCache.getKey(signingNodeId);
+    if (!key) {
+      throw new LightsparkSigningException_default(
+        "Missing node of encrypted_signing_private_key"
+      );
+    }
+    const encodedPayload = new TextEncoder().encode(JSON.stringify(payload));
+    const signedPayload = await key.sign(encodedPayload);
+    const encodedSignedPayload = b64encode(signedPayload);
+    headers["X-Lightspark-Signing"] = JSON.stringify({
+      v: "1",
+      signature: encodedSignedPayload
+    });
+    return encodedPayload;
+  }
+};
+async function compress(data) {
+  const stream = new Blob([data]).stream();
+  const compressedStream = stream.pipeThrough(new CompressionStream("deflate"));
+  const reader = compressedStream.getReader();
+  const chunks = [];
+  let done, value;
+  while (!done) {
+    ({ done, value } = await reader.read());
+    chunks.push(value);
+  }
+  const blob = new Blob(chunks);
+  return new Uint8Array(await blob.arrayBuffer());
+}
+var Requester_default = Requester;
+
+// src/auth/LightsparkAuthException.ts
+var LightsparkAuthException = class extends LightsparkException_default {
+  constructor(message, extraInfo) {
+    super("AuthException", message, extraInfo);
+  }
+};
+var LightsparkAuthException_default = LightsparkAuthException;
+
+// src/crypto/KeyOrAlias.ts
+var KeyOrAlias = {
+  key: (key) => ({ key }),
+  alias: (alias) => ({ alias })
+};
+
+// src/crypto/SigningKey.ts
+var import_secp256k1 = __toESM(require("secp256k1"), 1);
+
+// src/utils/hex.ts
+var bytesToHex = (bytes) => {
+  return bytes.reduce((acc, byte) => {
+    return acc += ("0" + byte.toString(16)).slice(-2);
+  }, "");
+};
+var hexToBytes = (hex) => {
+  const bytes = [];
+  for (let c = 0; c < hex.length; c += 2) {
+    bytes.push(parseInt(hex.substr(c, 2), 16));
+  }
+  return Uint8Array.from(bytes);
+};
+
+// src/utils/createHash.ts
+async function createSha256Hash(data, asHex) {
+  if (isBrowser) {
+    const source = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const buffer = await window.crypto.subtle.digest("SHA-256", source);
+    const arr = new Uint8Array(buffer);
+    if (asHex) {
+      return bytesToHex(arr);
+    }
+    return arr;
+  } else {
+    const { createHash } = await import("crypto");
+    if (asHex) {
+      const hexStr = createHash("sha256").update(data).digest("hex");
+      return hexStr;
+    }
+    const buffer = createHash("sha256").update(data).digest();
+    return new Uint8Array(buffer);
+  }
+}
+
+// src/crypto/types.ts
+var SigningKeyType = /* @__PURE__ */ ((SigningKeyType2) => {
+  SigningKeyType2["RSASigningKey"] = "RSASigningKey";
+  SigningKeyType2["Secp256k1SigningKey"] = "Secp256k1SigningKey";
+  return SigningKeyType2;
+})(SigningKeyType || {});
+
+// src/crypto/SigningKey.ts
+function isAlias(key) {
+  return "alias" in key;
+}
+var SigningKey = class {
+  type;
+  constructor(type) {
+    this.type = type;
+  }
+};
+var RSASigningKey = class extends SigningKey {
+  constructor(privateKey, cryptoImpl) {
+    super("RSASigningKey" /* RSASigningKey */);
+    this.privateKey = privateKey;
+    this.cryptoImpl = cryptoImpl;
+  }
+  async sign(data) {
+    const key = isAlias(this.privateKey) ? this.privateKey.alias : this.privateKey;
+    return this.cryptoImpl.sign(key, data);
+  }
+};
+var Secp256k1SigningKey = class extends SigningKey {
+  constructor(privateKey) {
+    super("Secp256k1SigningKey" /* Secp256k1SigningKey */);
+    this.privateKey = privateKey;
+  }
+  async sign(data) {
+    const keyBytes = new Uint8Array(hexToBytes(this.privateKey));
+    const hash = await createSha256Hash(data);
+    const signResult = import_secp256k1.default.ecdsaSign(hash, keyBytes);
+    return import_secp256k1.default.signatureExport(signResult.signature);
+  }
+};
+
+// src/crypto/NodeKeyCache.ts
+var NodeKeyCache = class {
+  constructor(cryptoImpl = DefaultCrypto) {
+    this.cryptoImpl = cryptoImpl;
+    this.idToKey = /* @__PURE__ */ new Map();
+    autoBind(this);
+  }
+  idToKey;
+  async loadKey(id, keyOrAlias, signingKeyType) {
+    let signingKey;
+    if (keyOrAlias.alias !== void 0) {
+      switch (signingKeyType) {
+        case "RSASigningKey" /* RSASigningKey */:
+          signingKey = new RSASigningKey(
+            { alias: keyOrAlias.alias },
+            this.cryptoImpl
+          );
+          break;
+        default:
+          throw new LightsparkSigningException_default(
+            `Aliases are not supported for signing key type ${signingKeyType}`
+          );
+      }
+      this.idToKey.set(id, signingKey);
+      return signingKey;
+    }
+    try {
+      if (signingKeyType === "Secp256k1SigningKey" /* Secp256k1SigningKey */) {
+        signingKey = new Secp256k1SigningKey(keyOrAlias.key);
+      } else {
+        const decoded = b64decode(this.stripPemTags(keyOrAlias.key));
+        const cryptoKeyOrAlias = await this.cryptoImpl.importPrivateSigningKey(decoded);
+        const key = typeof cryptoKeyOrAlias === "string" ? { alias: cryptoKeyOrAlias } : cryptoKeyOrAlias;
+        signingKey = new RSASigningKey(key, this.cryptoImpl);
+      }
+      this.idToKey.set(id, signingKey);
+      return signingKey;
+    } catch (e) {
+      console.log("Error importing key: ", e);
+    }
+    return null;
+  }
+  getKey(id) {
+    return this.idToKey.get(id);
+  }
+  hasKey(id) {
+    return this.idToKey.has(id);
+  }
+  stripPemTags(pem) {
+    return pem.replace(/-----BEGIN (.*)-----/, "").replace(/-----END (.*)----/, "");
+  }
+};
+var NodeKeyCache_default = NodeKeyCache;
+
+// src/ServerEnvironment.ts
+var ServerEnvironment = /* @__PURE__ */ ((ServerEnvironment2) => {
+  ServerEnvironment2["PRODUCTION"] = "production";
+  ServerEnvironment2["DEV"] = "dev";
+  return ServerEnvironment2;
+})(ServerEnvironment || {});
+var apiDomainForEnvironment = (environment) => {
+  switch (environment) {
+    case "dev" /* DEV */:
+      return "api.dev.dev.sparkinfra.net";
+    case "production" /* PRODUCTION */:
+      return "api.lightspark.com";
+  }
+};
+var ServerEnvironment_default = ServerEnvironment;
+
+// src/utils/arrays.ts
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/utils/locale.ts
+function getCurrentLocale() {
+  return Intl.NumberFormat().resolvedOptions().locale;
+}
+
+// src/utils/localeToCurrencyCodes.ts
+var countryCodesToCurrencyCodes = {
+  AD: "EUR",
+  // AE: "AED",
+  // AF: "AFN",
+  // AG: "XCD",
+  // AI: "XCD",
+  // AL: "ALL",
+  // AM: "AMD",
+  // AO: "AOA",
+  AR: "ARS",
+  AS: "USD",
+  AT: "EUR",
+  AU: "AUD",
+  // AW: "AWG",
+  AX: "EUR",
+  // AZ: "AZN",
+  // BA: "BAM",
+  // BB: "BBD",
+  // BD: "BDT",
+  BE: "EUR",
+  // BF: "XOF",
+  // BG: "BGN",
+  // BH: "BHD",
+  // BI: "BIF",
+  // BJ: "XOF",
+  BL: "EUR",
+  // BM: "BMD",
+  // BN: "BND",
+  // BO: "BOB",
+  BQ: "USD",
+  BR: "BRL",
+  // BS: "BSD",
+  // BT: "BTN",
+  // BV: "NOK",
+  // BW: "BWP",
+  // BY: "BYN",
+  // BZ: "BZD",
+  CA: "CAD",
+  // CC: "AUD",
+  // CD: "CDF",
+  // CF: "XAF",
+  // CG: "XAF",
+  // CH: "CHF",
+  // CI: "XOF",
+  // CK: "NZD",
+  // CL: "CLP",
+  // CM: "XAF",
+  // CN: "CNY",
+  CO: "COP",
+  // CR: "CRC",
+  // CU: "CUP",
+  // CV: "CVE",
+  // CW: "ANG",
+  // CX: "AUD",
+  CY: "EUR",
+  // CZ: "CZK",
+  DE: "EUR",
+  // DJ: "DJF",
+  // DK: "DKK",
+  // DM: "XCD",
+  // DO: "DOP",
+  // DZ: "DZD",
+  EC: "USD",
+  EE: "EUR",
+  // EG: "EGP",
+  // EH: "MAD",
+  // ER: "ERN",
+  ES: "EUR",
+  // ET: "ETB",
+  FI: "EUR",
+  // FJ: "FJD",
+  // FK: "FKP",
+  FM: "USD",
+  // FO: "DKK",
+  FR: "EUR",
+  // GA: "XAF",
+  GB: "GBP",
+  // GD: "XCD",
+  // GE: "GEL",
+  GF: "EUR",
+  GG: "GBP",
+  // GH: "GHS",
+  // GI: "GIP",
+  // GL: "DKK",
+  // GM: "GMD",
+  // GN: "GNF",
+  GP: "EUR",
+  // GQ: "XAF",
+  GR: "EUR",
+  GS: "GBP",
+  // GT: "GTQ",
+  GU: "USD",
+  // GW: "XOF",
+  // GY: "GYD",
+  // HK: "HKD",
+  // HM: "AUD",
+  // HN: "HNL",
+  // HR: "HRK",
+  // HT: "HTG",
+  // HU: "HUF",
+  // ID: "IDR",
+  IE: "EUR",
+  // IL: "ILS",
+  IM: "GBP",
+  IN: "INR",
+  IO: "USD",
+  // IQ: "IQD",
+  // IR: "IRR",
+  // IS: "ISK",
+  IT: "EUR",
+  JE: "GBP",
+  // JM: "JMD",
+  // JO: "JOD",
+  // JP: "JPY",
+  // KE: "KES",
+  // KG: "KGS",
+  // KH: "KHR",
+  // KI: "AUD",
+  // KM: "KMF",
+  // KN: "XCD",
+  // KP: "KPW",
+  // KR: "KRW",
+  // KW: "KWD",
+  // KY: "KYD",
+  // KZ: "KZT",
+  // LA: "LAK",
+  // LB: "LBP",
+  // LC: "XCD",
+  // LI: "CHF",
+  // LK: "LKR",
+  // LR: "LRD",
+  // LS: "LSL",
+  LT: "EUR",
+  LU: "EUR",
+  LV: "EUR",
+  // LY: "LYD",
+  // MA: "MAD",
+  MC: "EUR",
+  // MD: "MDL",
+  ME: "EUR",
+  MF: "EUR",
+  // MG: "MGA",
+  MH: "USD",
+  // MK: "MKD",
+  // ML: "XOF",
+  // MM: "MMK",
+  // MN: "MNT",
+  // MO: "MOP",
+  MP: "USD",
+  MQ: "EUR",
+  // MR: "MRO",
+  // MS: "XCD",
+  MT: "EUR",
+  // MU: "MUR",
+  // MV: "MVR",
+  // MW: "MWK",
+  MX: "MXN",
+  // MY: "MYR",
+  // MZ: "MZN",
+  // NA: "NAD",
+  // NC: "XPF",
+  // NE: "XOF",
+  NF: "AUD",
+  // NG: "NGN",
+  // NI: "NIO",
+  NL: "EUR",
+  // NO: "NOK",
+  // NP: "NPR",
+  NR: "AUD",
+  // NU: "NZD",
+  // NZ: "NZD",
+  // OM: "OMR",
+  // PA: "PAB",
+  // PE: "PEN",
+  // PF: "XPF",
+  // PG: "PGK",
+  // PH: "PHP",
+  // PK: "PKR",
+  // PL: "PLN",
+  PM: "EUR",
+  // PN: "NZD",
+  PR: "USD",
+  // PS: "ILS",
+  PT: "EUR",
+  PW: "USD",
+  // PY: "PYG",
+  // QA: "QAR",
+  RE: "EUR",
+  // RO: "RON",
+  // RS: "RSD",
+  // RU: "RUB",
+  // RW: "RWF",
+  // SA: "SAR",
+  // SB: "SBD",
+  // SC: "SCR",
+  // SD: "SDG",
+  // SE: "SEK",
+  // SG: "SGD",
+  // SH: "SHP",
+  SI: "EUR",
+  // SJ: "NOK",
+  SK: "EUR",
+  // SL: "SLL",
+  SM: "EUR",
+  // SN: "XOF",
+  // SO: "SOS",
+  // SR: "SRD",
+  // ST: "STD",
+  // SV: "SVC",
+  // SX: "ANG",
+  // SY: "SYP",
+  // SZ: "SZL",
+  TC: "USD",
+  // TD: "XAF",
+  TF: "EUR",
+  // TG: "XOF",
+  // TH: "THB",
+  // TJ: "TJS",
+  // TK: "NZD",
+  TL: "USD",
+  // TM: "TMT",
+  // TN: "TND",
+  // TO: "TOP",
+  // TR: "TRY",
+  // TT: "TTD",
+  TV: "AUD",
+  // TW: "TWD",
+  // TZ: "TZS",
+  // UA: "UAH",
+  // UG: "UGX",
+  UM: "USD",
+  US: "USD",
+  // UY: "UYU",
+  // UZ: "UZS",
+  VA: "EUR",
+  // VC: "XCD",
+  // VE: "VEF",
+  VG: "USD",
+  VI: "USD",
+  // VN: "VND",
+  // VU: "VUV",
+  // WF: "XPF",
+  // WS: "WST",
+  // YE: "YER",
+  YT: "EUR"
+  // ZA: "ZAR",
+  // ZM: "ZMW",
+  // ZW: "ZWL",
+};
+function getCountryCode(localeString) {
+  let components = localeString.split("_");
+  if (components.length === 2) {
+    return components.pop();
+  }
+  components = localeString.split("-");
+  if (components.length === 2) {
+    return components.pop();
+  }
+  return localeString;
+}
+function localeToCurrencyCode(locale) {
+  const countryCode = getCountryCode(locale);
+  return countryCodesToCurrencyCodes[countryCode];
+}
+
+// src/utils/numbers.ts
+function clamp(val, min, max) {
+  return val > max ? max : val < min ? min : val;
+}
+function linearInterpolate(value, fromRangeStart, fromRangeEnd, toRangeStart, toRangeEnd) {
+  const fromRangeMax = fromRangeEnd - fromRangeStart;
+  const fromRangeVal = value - fromRangeStart;
+  const toRangeMax = toRangeEnd - toRangeStart;
+  const val = fromRangeVal / fromRangeMax * toRangeMax + toRangeStart;
+  return clamp(
+    val,
+    Math.min(toRangeStart, toRangeEnd),
+    Math.max(toRangeStart, toRangeEnd)
+  );
+}
+function round(num, decimalPlaces = 0) {
+  const p = Math.pow(10, decimalPlaces);
+  const n = num * p * (1 + Number.EPSILON);
+  return Math.round(n) / p;
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+
+// src/utils/currency.ts
+var defaultCurrencyCode = "USD";
+var CurrencyUnit = {
+  FUTURE_VALUE: "FUTURE_VALUE",
+  BITCOIN: "BITCOIN",
+  SATOSHI: "SATOSHI",
+  MILLISATOSHI: "MILLISATOSHI",
+  NANOBITCOIN: "NANOBITCOIN",
+  MICROBITCOIN: "MICROBITCOIN",
+  MILLIBITCOIN: "MILLIBITCOIN",
+  USD: "USD",
+  MXN: "MXN",
+  PHP: "PHP",
+  EUR: "EUR",
+  GBP: "GBP",
+  INR: "INR",
+  Bitcoin: "BITCOIN",
+  Microbitcoin: "MICROBITCOIN",
+  Millibitcoin: "MILLIBITCOIN",
+  Millisatoshi: "MILLISATOSHI",
+  Nanobitcoin: "NANOBITCOIN",
+  Satoshi: "SATOSHI",
+  Usd: "USD",
+  Mxn: "MXN",
+  Php: "PHP",
+  Gbp: "GBP",
+  Inr: "INR"
+};
+var standardUnitConversionObj = {
+  [CurrencyUnit.BITCOIN]: (v, unitsPerBtc = 1) => v / unitsPerBtc,
+  [CurrencyUnit.MICROBITCOIN]: (v, unitsPerBtc = 1) => v / unitsPerBtc * 1e6,
+  [CurrencyUnit.MILLIBITCOIN]: (v, unitsPerBtc = 1) => v / unitsPerBtc * 1e3,
+  [CurrencyUnit.MILLISATOSHI]: (v, unitsPerBtc = 1) => v / unitsPerBtc * 1e11,
+  [CurrencyUnit.NANOBITCOIN]: (v, unitsPerBtc = 1) => v / unitsPerBtc * 1e9,
+  [CurrencyUnit.SATOSHI]: (v, unitsPerBtc = 1) => v / unitsPerBtc * 1e8,
+  /* Converting between two different fiat types is not currently supported */
+  [CurrencyUnit.USD]: (v) => v,
+  [CurrencyUnit.MXN]: (v) => v,
+  [CurrencyUnit.PHP]: (v) => v,
+  [CurrencyUnit.EUR]: (v) => v,
+  [CurrencyUnit.GBP]: (v) => v,
+  [CurrencyUnit.INR]: (v) => v
+};
+var toBitcoinConversion = (v, unitsPerBtc = 1) => round(v * unitsPerBtc);
+var toMicrobitcoinConversion = (v, unitsPerBtc = 1) => round(v / 1e6 * unitsPerBtc);
+var toMillibitcoinConversion = (v, unitsPerBtc = 1) => round(v / 1e3 * unitsPerBtc);
+var toMillisatoshiConversion = (v, unitsPerBtc = 1) => round(v / 1e11 * unitsPerBtc);
+var toNanobitcoinConversion = (v, unitsPerBtc = 1) => round(v / 1e9 * unitsPerBtc);
+var toSatoshiConversion = (v, unitsPerBtc = 1) => round(v / 1e8 * unitsPerBtc);
+var CONVERSION_MAP = {
+  [CurrencyUnit.BITCOIN]: {
+    [CurrencyUnit.BITCOIN]: (v) => v,
+    [CurrencyUnit.MICROBITCOIN]: (v) => v * 1e6,
+    [CurrencyUnit.MILLIBITCOIN]: (v) => v * 1e3,
+    [CurrencyUnit.MILLISATOSHI]: (v) => v * 1e11,
+    [CurrencyUnit.NANOBITCOIN]: (v) => v * 1e9,
+    [CurrencyUnit.SATOSHI]: (v) => v * 1e8,
+    [CurrencyUnit.USD]: toBitcoinConversion,
+    [CurrencyUnit.MXN]: toBitcoinConversion,
+    [CurrencyUnit.PHP]: toBitcoinConversion,
+    [CurrencyUnit.EUR]: toBitcoinConversion,
+    [CurrencyUnit.GBP]: toBitcoinConversion,
+    [CurrencyUnit.INR]: toBitcoinConversion
+  },
+  [CurrencyUnit.MICROBITCOIN]: {
+    [CurrencyUnit.BITCOIN]: (v) => v / 1e6,
+    [CurrencyUnit.MICROBITCOIN]: (v) => v,
+    [CurrencyUnit.MILLIBITCOIN]: (v) => v / 1e3,
+    [CurrencyUnit.MILLISATOSHI]: (v) => v * 1e5,
+    [CurrencyUnit.NANOBITCOIN]: (v) => v * 1e3,
+    [CurrencyUnit.SATOSHI]: (v) => v * 100,
+    [CurrencyUnit.USD]: toMicrobitcoinConversion,
+    [CurrencyUnit.MXN]: toMicrobitcoinConversion,
+    [CurrencyUnit.PHP]: toMicrobitcoinConversion,
+    [CurrencyUnit.EUR]: toMicrobitcoinConversion,
+    [CurrencyUnit.GBP]: toMicrobitcoinConversion,
+    [CurrencyUnit.INR]: toMicrobitcoinConversion
+  },
+  [CurrencyUnit.MILLIBITCOIN]: {
+    [CurrencyUnit.BITCOIN]: (v) => v / 1e3,
+    [CurrencyUnit.MICROBITCOIN]: (v) => v * 1e3,
+    [CurrencyUnit.MILLIBITCOIN]: (v) => v,
+    [CurrencyUnit.MILLISATOSHI]: (v) => v * 1e8,
+    [CurrencyUnit.NANOBITCOIN]: (v) => v * 1e6,
+    [CurrencyUnit.SATOSHI]: (v) => v * 1e5,
+    [CurrencyUnit.USD]: toMillibitcoinConversion,
+    [CurrencyUnit.MXN]: toMillibitcoinConversion,
+    [CurrencyUnit.PHP]: toMillibitcoinConversion,
+    [CurrencyUnit.EUR]: toMillibitcoinConversion,
+    [CurrencyUnit.GBP]: toMillibitcoinConversion,
+    [CurrencyUnit.INR]: toMillibitcoinConversion
+  },
+  [CurrencyUnit.MILLISATOSHI]: {
+    [CurrencyUnit.BITCOIN]: (v) => v / 1e11,
+    [CurrencyUnit.MICROBITCOIN]: (v) => v / 1e5,
+    [CurrencyUnit.MILLIBITCOIN]: (v) => v / 1e8,
+    [CurrencyUnit.MILLISATOSHI]: (v) => v,
+    [CurrencyUnit.NANOBITCOIN]: (v) => v / 100,
+    [CurrencyUnit.SATOSHI]: (v) => v / 1e3,
+    [CurrencyUnit.USD]: toMillisatoshiConversion,
+    [CurrencyUnit.MXN]: toMillisatoshiConversion,
+    [CurrencyUnit.PHP]: toMillisatoshiConversion,
+    [CurrencyUnit.EUR]: toMillisatoshiConversion,
+    [CurrencyUnit.GBP]: toMillisatoshiConversion,
+    [CurrencyUnit.INR]: toMillisatoshiConversion
+  },
+  [CurrencyUnit.NANOBITCOIN]: {
+    [CurrencyUnit.BITCOIN]: (v) => v / 1e9,
+    [CurrencyUnit.MICROBITCOIN]: (v) => v / 1e3,
+    [CurrencyUnit.MILLIBITCOIN]: (v) => v / 1e6,
+    [CurrencyUnit.MILLISATOSHI]: (v) => v * 100,
+    [CurrencyUnit.NANOBITCOIN]: (v) => v,
+    [CurrencyUnit.SATOSHI]: (v) => v / 10,
+    [CurrencyUnit.USD]: toNanobitcoinConversion,
+    [CurrencyUnit.MXN]: toNanobitcoinConversion,
+    [CurrencyUnit.PHP]: toNanobitcoinConversion,
+    [CurrencyUnit.EUR]: toNanobitcoinConversion,
+    [CurrencyUnit.GBP]: toNanobitcoinConversion,
+    [CurrencyUnit.INR]: toNanobitcoinConversion
+  },
+  [CurrencyUnit.SATOSHI]: {
+    [CurrencyUnit.BITCOIN]: (v) => v / 1e8,
+    [CurrencyUnit.MICROBITCOIN]: (v) => v / 100,
+    [CurrencyUnit.MILLIBITCOIN]: (v) => v / 1e5,
+    [CurrencyUnit.MILLISATOSHI]: (v) => v * 1e3,
+    [CurrencyUnit.NANOBITCOIN]: (v) => v * 10,
+    [CurrencyUnit.SATOSHI]: (v) => v,
+    [CurrencyUnit.USD]: toSatoshiConversion,
+    [CurrencyUnit.MXN]: toSatoshiConversion,
+    [CurrencyUnit.PHP]: toSatoshiConversion,
+    [CurrencyUnit.EUR]: toSatoshiConversion,
+    [CurrencyUnit.GBP]: toSatoshiConversion,
+    [CurrencyUnit.INR]: toSatoshiConversion
+  },
+  [CurrencyUnit.USD]: standardUnitConversionObj,
+  [CurrencyUnit.MXN]: standardUnitConversionObj,
+  [CurrencyUnit.PHP]: standardUnitConversionObj,
+  [CurrencyUnit.EUR]: standardUnitConversionObj,
+  [CurrencyUnit.GBP]: standardUnitConversionObj,
+  [CurrencyUnit.INR]: standardUnitConversionObj
+};
+function convertCurrencyAmountValue(fromUnit, toUnit, amount, unitsPerBtc = 1) {
+  if (fromUnit === CurrencyUnit.FUTURE_VALUE || toUnit === CurrencyUnit.FUTURE_VALUE) {
+    throw new LightsparkException_default("CurrencyError", `Unsupported CurrencyUnit.`);
+  }
+  if (fromUnit === toUnit) {
+    return amount;
+  }
+  const conversionFn = CONVERSION_MAP[fromUnit][toUnit];
+  if (!conversionFn) {
+    throw new LightsparkException_default(
+      "CurrencyError",
+      `Cannot convert from ${fromUnit} to ${toUnit}`
+    );
+  }
+  return conversionFn(amount, unitsPerBtc);
+}
+var convertCurrencyAmount = (from, toUnit) => {
+  const value = convertCurrencyAmountValue(
+    from.originalUnit,
+    toUnit,
+    from.originalValue
+  );
+  return {
+    ...from,
+    preferredCurrencyUnit: toUnit,
+    preferredCurrencyValueApprox: value,
+    preferredCurrencyValueRounded: value
+  };
+};
+function isCurrencyAmountInputObj(arg) {
+  return typeof arg === "object" && arg !== null && "value" in arg && (typeof arg.value === "number" || typeof arg.value === "string" || arg.value === null) && "unit" in arg && typeof arg.unit === "string";
+}
+function isUmaCurrencyAmount(arg) {
+  return typeof arg === "object" && arg !== null && "value" in arg && typeof arg.value === "number" && "currency" in arg && typeof arg.currency === "object" && typeof arg.currency.code === "string" && typeof arg.currency.symbol === "string" && typeof arg.currency.name === "string" && typeof arg.currency.decimals === "number";
+}
+function isDeprecatedCurrencyAmountObj(arg) {
+  return typeof arg === "object" && arg !== null && "value" in arg && "unit" in arg;
+}
+function isCurrencyAmountObj(arg) {
+  return typeof arg === "object" && arg !== null && "original_value" in arg && "original_unit" in arg;
+}
+function isCurrencyAmountPreferenceObj(arg) {
+  return typeof arg === "object" && arg !== null && "original_unit" in arg && typeof arg.original_unit === "string" && "original_value" in arg && typeof arg.original_value === "number" && "preferred_currency_unit" in arg && typeof arg.preferred_currency_unit === "string" && "preferred_currency_value_approx" in arg && typeof arg.preferred_currency_value_approx === "number";
+}
+function isSDKCurrencyAmount(arg) {
+  return typeof arg === "object" && arg !== null && /* We can expect all SDK CurrencyAmount types to always have these exact properties: */
+  "originalValue" in arg && "originalUnit" in arg && "preferredCurrencyUnit" in arg && "preferredCurrencyValueRounded" in arg && "preferredCurrencyValueApprox" in arg;
+}
+function asNumber(value) {
+  if (typeof value === "string") {
+    return Number(value);
+  }
+  return value || 0;
+}
+function getCurrencyAmount(currencyAmountArg) {
+  let value = 0;
+  let unit = void 0;
+  if (isSDKCurrencyAmount(currencyAmountArg)) {
+    value = currencyAmountArg.originalValue;
+    unit = currencyAmountArg.originalUnit;
+  } else if (isCurrencyAmountObj(currencyAmountArg)) {
+    value = asNumber(currencyAmountArg.original_value);
+    unit = currencyAmountArg.original_unit;
+  } else if (isCurrencyAmountInputObj(currencyAmountArg) || isDeprecatedCurrencyAmountObj(currencyAmountArg)) {
+    value = asNumber(currencyAmountArg.value);
+    unit = currencyAmountArg.unit;
+  }
+  return {
+    value: asNumber(value),
+    unit: unit || CurrencyUnit.SATOSHI
+  };
+}
+function convertCurrencyAmountValues(fromUnit, amount, unitsPerBtc = 1, conversionOverride) {
+  const convert = convertCurrencyAmountValue;
+  const namesToUnits = {
+    sats: CurrencyUnit.SATOSHI,
+    btc: CurrencyUnit.BITCOIN,
+    msats: CurrencyUnit.MILLISATOSHI,
+    usd: CurrencyUnit.USD,
+    mxn: CurrencyUnit.MXN,
+    php: CurrencyUnit.PHP,
+    eur: CurrencyUnit.EUR,
+    gbp: CurrencyUnit.GBP,
+    inr: CurrencyUnit.INR,
+    mibtc: CurrencyUnit.MICROBITCOIN,
+    mlbtc: CurrencyUnit.MILLIBITCOIN,
+    nbtc: CurrencyUnit.NANOBITCOIN
+  };
+  return Object.entries(namesToUnits).reduce(
+    (acc, [name, unit]) => {
+      if (conversionOverride && unit === conversionOverride.unit) {
+        acc[name] = conversionOverride.convertedValue;
+      } else {
+        acc[name] = convert(
+          fromUnit,
+          unit,
+          amount,
+          unitsPerBtc
+        );
+      }
+      return acc;
+    },
+    {}
+  );
+}
+function getPreferredConversionOverride(currencyAmountArg) {
+  if (isCurrencyAmountPreferenceObj(currencyAmountArg)) {
+    return {
+      unit: currencyAmountArg.preferred_currency_unit,
+      convertedValue: currencyAmountArg.preferred_currency_value_approx
+    };
+  } else if (isSDKCurrencyAmount(currencyAmountArg)) {
+    return {
+      unit: currencyAmountArg.preferredCurrencyUnit,
+      convertedValue: currencyAmountArg.preferredCurrencyValueApprox
+    };
+  }
+  return void 0;
+}
+function mapCurrencyAmount(currencyAmountArg, unitsPerBtc = 1) {
+  const { value, unit } = getCurrencyAmount(currencyAmountArg);
+  const conversionOverride = getPreferredConversionOverride(currencyAmountArg);
+  const { sats, msats, btc, usd, mxn, php, mibtc, mlbtc, nbtc, eur, gbp, inr } = convertCurrencyAmountValues(unit, value, unitsPerBtc, conversionOverride);
+  const mapWithCurrencyUnits = {
+    [CurrencyUnit.BITCOIN]: btc,
+    [CurrencyUnit.SATOSHI]: sats,
+    [CurrencyUnit.MILLISATOSHI]: msats,
+    [CurrencyUnit.USD]: usd,
+    [CurrencyUnit.MXN]: mxn,
+    [CurrencyUnit.PHP]: php,
+    [CurrencyUnit.EUR]: eur,
+    [CurrencyUnit.GBP]: gbp,
+    [CurrencyUnit.INR]: inr,
+    [CurrencyUnit.MICROBITCOIN]: mibtc,
+    [CurrencyUnit.MILLIBITCOIN]: mlbtc,
+    [CurrencyUnit.NANOBITCOIN]: nbtc,
+    [CurrencyUnit.FUTURE_VALUE]: NaN,
+    formatted: {
+      [CurrencyUnit.BITCOIN]: formatCurrencyStr({
+        value: btc,
+        unit: CurrencyUnit.BITCOIN
+      }),
+      [CurrencyUnit.SATOSHI]: formatCurrencyStr({
+        value: sats,
+        unit: CurrencyUnit.SATOSHI
+      }),
+      [CurrencyUnit.MILLISATOSHI]: formatCurrencyStr({
+        value: msats,
+        unit: CurrencyUnit.MILLISATOSHI
+      }),
+      [CurrencyUnit.MICROBITCOIN]: formatCurrencyStr({
+        value: mibtc,
+        unit: CurrencyUnit.MICROBITCOIN
+      }),
+      [CurrencyUnit.MILLIBITCOIN]: formatCurrencyStr({
+        value: mlbtc,
+        unit: CurrencyUnit.MILLIBITCOIN
+      }),
+      [CurrencyUnit.NANOBITCOIN]: formatCurrencyStr({
+        value: nbtc,
+        unit: CurrencyUnit.NANOBITCOIN
+      }),
+      [CurrencyUnit.USD]: formatCurrencyStr({
+        value: usd,
+        unit: CurrencyUnit.USD
+      }),
+      [CurrencyUnit.MXN]: formatCurrencyStr({
+        value: mxn,
+        unit: CurrencyUnit.MXN
+      }),
+      [CurrencyUnit.PHP]: formatCurrencyStr({
+        value: php,
+        unit: CurrencyUnit.PHP
+      }),
+      [CurrencyUnit.EUR]: formatCurrencyStr({
+        value: eur,
+        unit: CurrencyUnit.EUR
+      }),
+      [CurrencyUnit.GBP]: formatCurrencyStr({
+        value: gbp,
+        unit: CurrencyUnit.GBP
+      }),
+      [CurrencyUnit.INR]: formatCurrencyStr({
+        value: inr,
+        unit: CurrencyUnit.INR
+      }),
+      [CurrencyUnit.FUTURE_VALUE]: "-"
+    }
+  };
+  return {
+    ...mapWithCurrencyUnits,
+    btc,
+    sats,
+    msats,
+    isZero: msats === 0,
+    isLessThan: (other) => {
+      if (isNumber(other)) {
+        return msats < other;
+      }
+      if (isCurrencyAmountObj(other)) {
+        other = mapCurrencyAmount(other);
+      }
+      return msats < other.msats;
+    },
+    isGreaterThan: (other) => {
+      if (isNumber(other)) {
+        return msats > other;
+      }
+      if (isCurrencyAmountObj(other)) {
+        other = mapCurrencyAmount(other);
+      }
+      return msats > other.msats;
+    },
+    isEqualTo: (other) => {
+      if (isNumber(other)) {
+        return msats === other;
+      }
+      if (isCurrencyAmountObj(other)) {
+        other = mapCurrencyAmount(other);
+      }
+      return msats === other.msats;
+    },
+    formatted: {
+      ...mapWithCurrencyUnits.formatted,
+      btc: mapWithCurrencyUnits.formatted[CurrencyUnit.BITCOIN],
+      sats: mapWithCurrencyUnits.formatted[CurrencyUnit.SATOSHI],
+      msats: mapWithCurrencyUnits.formatted[CurrencyUnit.MILLISATOSHI]
+    },
+    type: "CurrencyMap"
+  };
+}
+var isCurrencyMap = (currencyMap) => typeof currencyMap === "object" && currencyMap !== null && "type" in currencyMap && typeof currencyMap.type === "string" && currencyMap.type === "CurrencyMap";
+var abbrCurrencyUnit = (unit) => {
+  switch (unit) {
+    case CurrencyUnit.BITCOIN:
+      return "BTC";
+    case CurrencyUnit.SATOSHI:
+      return "SAT";
+    case CurrencyUnit.MILLISATOSHI:
+      return "MSAT";
+    case CurrencyUnit.MILLIBITCOIN:
+      return "mBTC";
+    case CurrencyUnit.MICROBITCOIN:
+      return "\u03BCBTC";
+    case CurrencyUnit.USD:
+      return "USD";
+    case CurrencyUnit.MXN:
+      return "MXN";
+    case CurrencyUnit.PHP:
+      return "PHP";
+    case CurrencyUnit.EUR:
+      return "EUR";
+    case CurrencyUnit.GBP:
+      return "GBP";
+    case CurrencyUnit.INR:
+      return "INR";
+  }
+  return "Unsupported CurrencyUnit";
+};
+var defaultOptions = {
+  /* undefined indicates to use default precision for unit defined below */
+  precision: void 0,
+  compact: false,
+  showBtcSymbol: false,
+  append: void 0
+};
+function formatCurrencyStr(amount, options) {
+  const { precision, compact, showBtcSymbol } = {
+    ...defaultOptions,
+    ...options
+  };
+  let num;
+  let unit;
+  if (isUmaCurrencyAmount(amount)) {
+    num = amount.value;
+    unit = amount.currency.code;
+    if (amount.currency.decimals > 0) {
+      num = amount.value / Math.pow(10, amount.currency.decimals);
+    }
+  } else {
+    const currencyAmount = getCurrencyAmount(amount);
+    num = currencyAmount.value;
+    unit = currencyAmount.unit;
+    const centCurrencies = [
+      CurrencyUnit.USD,
+      CurrencyUnit.MXN,
+      CurrencyUnit.PHP,
+      CurrencyUnit.EUR,
+      CurrencyUnit.GBP
+    ];
+    if (centCurrencies.includes(unit)) {
+      num = num / 100;
+    }
+  }
+  function getDefaultMaxFractionDigits(defaultDigits, fullPrecisionDigits) {
+    let digits = defaultDigits;
+    if (precision === "full") {
+      digits = fullPrecisionDigits;
+    } else if (typeof precision === "number") {
+      digits = precision;
+    } else if (compact) {
+      digits = 1;
+    }
+    return digits;
+  }
+  const symbol = !showBtcSymbol ? "" : unit === CurrencyUnit.BITCOIN ? "\uE903" : unit === CurrencyUnit.SATOSHI || unit === abbrCurrencyUnit(CurrencyUnit.SATOSHI) ? "\uE902" : "";
+  const currentLocale = getCurrentLocale();
+  function isFormattableFiatCurrencyCode(currencyCode) {
+    try {
+      new Intl.NumberFormat(currentLocale, {
+        style: "currency",
+        currency: currencyCode
+      });
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  let formattedStr = "";
+  let forceAppendUnits = false;
+  switch (unit) {
+    case CurrencyUnit.BITCOIN:
+      formattedStr = `${symbol}${num.toLocaleString(currentLocale, {
+        notation: compact ? "compact" : void 0,
+        maximumFractionDigits: getDefaultMaxFractionDigits(4, 8)
+      })}`;
+      break;
+    case CurrencyUnit.SATOSHI:
+    case abbrCurrencyUnit(CurrencyUnit.SATOSHI):
+      formattedStr = `${symbol}${num.toLocaleString(currentLocale, {
+        notation: compact ? "compact" : void 0,
+        maximumFractionDigits: getDefaultMaxFractionDigits(0, 3)
+      })}`;
+      break;
+    case CurrencyUnit.MILLISATOSHI:
+    case CurrencyUnit.MICROBITCOIN:
+    case CurrencyUnit.MILLIBITCOIN:
+    case CurrencyUnit.NANOBITCOIN:
+      formattedStr = `${symbol}${num.toLocaleString(currentLocale, {
+        notation: compact ? "compact" : void 0,
+        maximumFractionDigits: getDefaultMaxFractionDigits(0, 0)
+      })}`;
+      break;
+    default:
+      if (isFormattableFiatCurrencyCode(unit)) {
+        formattedStr = num.toLocaleString(currentLocale, {
+          style: "currency",
+          currency: unit,
+          currencyDisplay: "narrowSymbol",
+          notation: compact ? "compact" : void 0,
+          maximumFractionDigits: getDefaultMaxFractionDigits(2, 2)
+        });
+      } else {
+        formattedStr = `${num}`;
+        forceAppendUnits = true;
+      }
+      break;
+  }
+  if (options?.appendUnits || forceAppendUnits) {
+    const localeCurrencyCode = localeToCurrencyCode(currentLocale);
+    if (unit === localeCurrencyCode && options?.appendUnits && !options.appendUnits.showForCurrentLocaleUnit) {
+      return formattedStr;
+    }
+    const unitStr = isUmaCurrencyAmount(amount) ? amount.currency.code : abbrCurrencyUnit(unit);
+    const unitSuffix = options?.appendUnits?.plural && num > 1 ? "s" : "";
+    const unitStrWithSuffix = `${unitStr}${unitSuffix}`;
+    formattedStr += ` ${options?.appendUnits?.lowercase ? unitStrWithSuffix.toLowerCase() : unitStrWithSuffix}`;
+  }
+  return formattedStr;
+}
+function separateCurrencyStrParts(currencyStr) {
+  const symbol = currencyStr.replace(/[0-9\s\u00a0.,]/g, "");
+  const amount = currencyStr.replace(/[^\d.,-]/g, "");
+  return { symbol, amount };
+}
+function localeToCurrencySymbol(locale) {
+  const currencyCode = localeToCurrencyCode(locale);
+  const formatted = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: currencyCode,
+    useGrouping: false,
+    // to avoid thousands separators
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0
+  }).format(0);
+  const { symbol } = separateCurrencyStrParts(formatted);
+  return symbol;
+}
+function formatInviteAmount(amount, currency) {
+  if (!amount || !currency) {
+    return "";
+  }
+  const displayAmount = (amount / Math.pow(10, currency.decimals)).toFixed(
+    currency.decimals
+  );
+  return `${displayAmount} ${currency.code}`;
+}
+
+// src/utils/typeGuards.ts
+function isUint8Array(value) {
+  return value instanceof Uint8Array;
+}
+function isObject(value) {
+  const type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+
+// src/utils/errors.ts
+var isError = (e) => {
+  return Boolean(
+    typeof e === "object" && e !== null && "name" in e && typeof e.name === "string" && "message" in e && typeof e.message === "string"
+  );
+};
+var isErrorWithMessage = (e) => {
+  return Boolean(
+    typeof e === "object" && e !== null && "message" in e && typeof e.message === "string"
+  );
+};
+var getErrorMsg = (e) => {
+  return isErrorWithMessage(e) ? e.message : "Unknown error";
+};
+var isErrorMsg = (e, msg) => {
+  if (isError(e)) {
+    return e.message === msg;
+  }
+  return false;
+};
+function normalizeObject(obj) {
+  const normalized = {};
+  if (isObject(obj)) {
+    const props = Object.getOwnPropertyNames(obj);
+    for (const prop of props) {
+      const objRecord = obj;
+      normalized[prop] = objRecord[prop];
+    }
+  }
+  return normalized;
+}
+function errorToJSON(err, stringifyObjects = false) {
+  if (!err) {
+    return null;
+  }
+  if (isObject(err) && "toJSON" in err && typeof err.toJSON === "function") {
+    if (stringifyObjects === true) {
+      return objectToJSON(err.toJSON());
+    }
+    return err.toJSON();
+  }
+  if (typeof err === "object" && /* This happens for certain errors like DOMException: */
+  Object.getOwnPropertyNames(err).length === 0 && "message" in err && typeof err.message === "string") {
+    return { message: err.message };
+  }
+  return objectToJSON(err);
+}
+function objectToJSON(obj) {
+  const normalizedObj = normalizeObject(obj);
+  return JSON.parse(
+    JSON.stringify(normalizedObj, (key, value) => {
+      if (key === "") {
+        return value;
+      }
+      const objProps = Object.getOwnPropertyNames(normalizedObj);
+      if (!objProps.includes(key)) {
+        return void 0;
+      }
+      if (isObject(value)) {
+        return JSON.stringify(value);
+      }
+      return value;
+    })
+  );
+}
+
+// ../../node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal_default = freeGlobal;
+
+// ../../node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// ../../node_modules/lodash-es/_Symbol.js
+var Symbol2 = root_default.Symbol;
+var Symbol_default = Symbol2;
+
+// ../../node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var getRawTag_default = getRawTag;
+
+// ../../node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// ../../node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// ../../node_modules/lodash-es/isObject.js
+function isObject2(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject2;
+
+// ../../node_modules/lodash-es/isFunction.js
+var asyncTag = "[object AsyncFunction]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value)) {
+    return false;
+  }
+  var tag = baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/pollUntil.ts
+function getDefaultMaxPollsError() {
+  return new Error("pollUntil: Max polls reached");
+}
+async function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
+  let polls = 0;
+  let stopPolling = false;
+  let result = {
+    stopPolling: false,
+    value: null
+  };
+  while (!stopPolling) {
+    polls += 1;
+    if (polls > maxPolls) {
+      stopPolling = true;
+      const maxPollsError = getMaxPollsError(maxPolls);
+      throw maxPollsError;
+    }
+    try {
+      const asyncResult = await asyncFn();
+      result = getValue(asyncResult, {
+        stopPolling: false,
+        value: null
+      });
+      if (result.stopPolling) {
+        stopPolling = true;
+      }
+    } catch (e) {
+      if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
+        stopPolling = true;
+        throw e;
+      }
+    }
+    await sleep(pollIntervalMs);
+  }
+  return result.value;
+}
+
+// src/utils/strings.ts
+function lsidToUUID(lsid) {
+  return lsid.replace(/^[^:]+:(.*)$/, "$1");
+}
+
+// src/utils/types.ts
+var isType = (typename) => (node) => {
+  return node?.__typename === typename;
+};
+function notNullUndefined(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/utils/zipcodeToState.ts
+var zipcodeToStateCode = {
+  "20500": "DC",
+  "20501": "DC",
+  "20502": "DC",
+  "20503": "DC",
+  "20504": "DC",
+  "20505": "DC",
+  "20506": "DC",
+  "20507": "DC",
+  "20508": "DC",
+  "20509": "DC",
+  "20510": "DC",
+  "20511": "DC",
+  "20515": "DC",
+  "20520": "DC",
+  "20521": "DC",
+  "20522": "DC",
+  "20523": "DC",
+  "20524": "DC",
+  "20525": "DC",
+  "20526": "DC",
+  "20527": "DC",
+  "20528": "DC",
+  "20529": "DC",
+  "20530": "DC",
+  "20531": "DC",
+  "20532": "DC",
+  "20533": "DC",
+  "20534": "DC",
+  "20535": "DC",
+  "20536": "DC",
+  "20537": "DC",
+  "20538": "DC",
+  "20539": "DC",
+  "20540": "DC",
+  "20541": "DC",
+  "20542": "DC",
+  "20543": "DC",
+  "20544": "DC",
+  "20546": "DC",
+  "20547": "DC",
+  "20548": "DC",
+  "20549": "DC",
+  "20551": "DC",
+  "20552": "DC",
+  "20553": "DC",
+  "20554": "DC",
+  "20555": "DC",
+  "20557": "DC",
+  "20558": "DC",
+  "20559": "DC",
+  "20560": "DC",
+  "20565": "DC",
+  "20566": "DC",
+  "20570": "DC",
+  "20571": "DC",
+  "20572": "DC",
+  "20573": "DC",
+  "20575": "DC",
+  "20576": "DC",
+  "20577": "DC",
+  "20578": "DC",
+  "20579": "DC",
+  "20580": "DC",
+  "20581": "DC",
+  "20585": "DC",
+  "20586": "DC",
+  "20590": "DC",
+  "20591": "DC",
+  "20593": "DC",
+  "20594": "DC",
+  "20597": "DC",
+  "20598": "MD",
+  "20599": "DC",
+  "72643": "AR",
+  "73960": "OK",
+  "83414": "WY",
+  "96799": "HI",
+  "96939": "GU",
+  "96940": "GU",
+  "96941": "MP",
+  "96942": "MP",
+  "96943": "MP",
+  "96944": "MP",
+  "96950": "PW",
+  "96951": "PW",
+  "96952": "PW",
+  "96960": "FM",
+  "96970": "FM",
+  "06390": "CT"
+};
+var prefixToState = {
+  "005": "NY",
+  "006": "PR",
+  "007": "PR",
+  "008": "VI",
+  "009": "PR",
+  "010": "MA",
+  "011": "MA",
+  "012": "MA",
+  "013": "MA",
+  "014": "MA",
+  "015": "MA",
+  "016": "MA",
+  "017": "MA",
+  "018": "MA",
+  "019": "MA",
+  "020": "MA",
+  "021": "MA",
+  "022": "MA",
+  "023": "MA",
+  "024": "MA",
+  "025": "MA",
+  "026": "MA",
+  "027": "MA",
+  "028": "RI",
+  "029": "RI",
+  "030": "NH",
+  "031": "NH",
+  "032": "NH",
+  "033": "NH",
+  "034": "NH",
+  "035": "NH",
+  "036": "NH",
+  "037": "NH",
+  "038": "NH",
+  "039": "ME",
+  "040": "ME",
+  "041": "ME",
+  "042": "ME",
+  "043": "ME",
+  "044": "ME",
+  "045": "ME",
+  "046": "ME",
+  "047": "ME",
+  "048": "ME",
+  "049": "ME",
+  "050": "VT",
+  "051": "VT",
+  "052": "VT",
+  "053": "VT",
+  "054": "VT",
+  "055": "MA",
+  "056": "VT",
+  "057": "VT",
+  "058": "VT",
+  "059": "VT",
+  "060": "CT",
+  "061": "CT",
+  "062": "CT",
+  "063": "CT",
+  "064": "CT",
+  "065": "CT",
+  "066": "CT",
+  "067": "CT",
+  "068": "CT",
+  "069": "CT",
+  "070": "NJ",
+  "071": "NJ",
+  "072": "NJ",
+  "073": "NJ",
+  "074": "NJ",
+  "075": "NJ",
+  "076": "NJ",
+  "077": "NJ",
+  "078": "NJ",
+  "079": "NJ",
+  "080": "NJ",
+  "081": "NJ",
+  "082": "NJ",
+  "083": "NJ",
+  "084": "NJ",
+  "085": "NJ",
+  "086": "NJ",
+  "087": "NJ",
+  "088": "NJ",
+  "089": "NJ",
+  "090": "AE",
+  "091": "AE",
+  "092": "AE",
+  "093": "AE",
+  "094": "AE",
+  "095": "AE",
+  "096": "AE",
+  "097": "AE",
+  "098": "AE",
+  "099": "AE",
+  "100": "NY",
+  "101": "NY",
+  "102": "NY",
+  "103": "NY",
+  "104": "NY",
+  "105": "NY",
+  "106": "NY",
+  "107": "NY",
+  "108": "NY",
+  "109": "NY",
+  "110": "NY",
+  "111": "NY",
+  "112": "NY",
+  "113": "NY",
+  "114": "NY",
+  "115": "NY",
+  "116": "NY",
+  "117": "NY",
+  "118": "NY",
+  "119": "NY",
+  "120": "NY",
+  "121": "NY",
+  "122": "NY",
+  "123": "NY",
+  "124": "NY",
+  "125": "NY",
+  "126": "NY",
+  "127": "NY",
+  "128": "NY",
+  "129": "NY",
+  "130": "NY",
+  "131": "NY",
+  "132": "NY",
+  "133": "NY",
+  "134": "NY",
+  "135": "NY",
+  "136": "NY",
+  "137": "NY",
+  "138": "NY",
+  "139": "NY",
+  "140": "NY",
+  "141": "NY",
+  "142": "NY",
+  "143": "NY",
+  "144": "NY",
+  "145": "NY",
+  "146": "NY",
+  "147": "NY",
+  "148": "NY",
+  "149": "NY",
+  "150": "PA",
+  "151": "PA",
+  "152": "PA",
+  "153": "PA",
+  "154": "PA",
+  "155": "PA",
+  "156": "PA",
+  "157": "PA",
+  "158": "PA",
+  "159": "PA",
+  "160": "PA",
+  "161": "PA",
+  "162": "PA",
+  "163": "PA",
+  "164": "PA",
+  "165": "PA",
+  "166": "PA",
+  "167": "PA",
+  "168": "PA",
+  "169": "PA",
+  "170": "PA",
+  "171": "PA",
+  "172": "PA",
+  "173": "PA",
+  "174": "PA",
+  "175": "PA",
+  "176": "PA",
+  "177": "PA",
+  "178": "PA",
+  "179": "PA",
+  "180": "PA",
+  "181": "PA",
+  "182": "PA",
+  "183": "PA",
+  "184": "PA",
+  "185": "PA",
+  "186": "PA",
+  "187": "PA",
+  "188": "PA",
+  "189": "PA",
+  "190": "PA",
+  "191": "PA",
+  "192": "PA",
+  "193": "PA",
+  "194": "PA",
+  "195": "PA",
+  "196": "PA",
+  "197": "DE",
+  "198": "DE",
+  "199": "DE",
+  "200": "DC",
+  "201": "VA",
+  "202": "DC",
+  "203": "DC",
+  "204": "DC",
+  "205": "DC",
+  "206": "MD",
+  "207": "MD",
+  "208": "MD",
+  "209": "MD",
+  "210": "MD",
+  "211": "MD",
+  "212": "MD",
+  "213": "MD",
+  "214": "MD",
+  "215": "MD",
+  "216": "MD",
+  "217": "MD",
+  "218": "MD",
+  "219": "MD",
+  "220": "VA",
+  "221": "VA",
+  "222": "VA",
+  "223": "VA",
+  "224": "VA",
+  "225": "VA",
+  "226": "VA",
+  "227": "VA",
+  "228": "VA",
+  "229": "VA",
+  "230": "VA",
+  "231": "VA",
+  "232": "VA",
+  "233": "VA",
+  "234": "VA",
+  "235": "VA",
+  "236": "VA",
+  "237": "VA",
+  "238": "VA",
+  "239": "VA",
+  "240": "VA",
+  "241": "VA",
+  "242": "VA",
+  "243": "VA",
+  "244": "VA",
+  "245": "VA",
+  "246": "VA",
+  "247": "WV",
+  "248": "WV",
+  "249": "WV",
+  "250": "WV",
+  "251": "WV",
+  "252": "WV",
+  "253": "WV",
+  "254": "WV",
+  "255": "WV",
+  "256": "WV",
+  "257": "WV",
+  "258": "WV",
+  "259": "WV",
+  "260": "WV",
+  "261": "WV",
+  "262": "WV",
+  "263": "WV",
+  "264": "WV",
+  "265": "WV",
+  "266": "WV",
+  "267": "WV",
+  "268": "WV",
+  "269": "WV",
+  "270": "NC",
+  "271": "NC",
+  "272": "NC",
+  "273": "NC",
+  "274": "NC",
+  "275": "NC",
+  "276": "NC",
+  "277": "NC",
+  "278": "NC",
+  "279": "NC",
+  "280": "NC",
+  "281": "NC",
+  "282": "NC",
+  "283": "NC",
+  "284": "NC",
+  "285": "NC",
+  "286": "NC",
+  "287": "NC",
+  "288": "NC",
+  "289": "NC",
+  "290": "SC",
+  "291": "SC",
+  "292": "SC",
+  "293": "SC",
+  "294": "SC",
+  "295": "SC",
+  "296": "SC",
+  "297": "SC",
+  "298": "SC",
+  "299": "SC",
+  "300": "GA",
+  "301": "GA",
+  "302": "GA",
+  "303": "GA",
+  "304": "GA",
+  "305": "GA",
+  "306": "GA",
+  "307": "GA",
+  "308": "GA",
+  "309": "GA",
+  "310": "GA",
+  "311": "GA",
+  "312": "GA",
+  "313": "GA",
+  "314": "GA",
+  "315": "GA",
+  "316": "GA",
+  "317": "GA",
+  "318": "GA",
+  "319": "GA",
+  "320": "FL",
+  "321": "FL",
+  "322": "FL",
+  "323": "FL",
+  "324": "FL",
+  "325": "FL",
+  "326": "FL",
+  "327": "FL",
+  "328": "FL",
+  "329": "FL",
+  "330": "FL",
+  "331": "FL",
+  "332": "FL",
+  "333": "FL",
+  "334": "FL",
+  "335": "FL",
+  "336": "FL",
+  "337": "FL",
+  "338": "FL",
+  "339": "FL",
+  "340": "AA",
+  "341": "FL",
+  "342": "FL",
+  "344": "FL",
+  "346": "FL",
+  "347": "FL",
+  "349": "FL",
+  "350": "AL",
+  "351": "AL",
+  "352": "AL",
+  "354": "AL",
+  "355": "AL",
+  "356": "AL",
+  "357": "AL",
+  "358": "AL",
+  "359": "AL",
+  "360": "AL",
+  "361": "AL",
+  "362": "AL",
+  "363": "AL",
+  "364": "AL",
+  "365": "AL",
+  "366": "AL",
+  "367": "AL",
+  "368": "AL",
+  "369": "AL",
+  "370": "TN",
+  "371": "TN",
+  "372": "TN",
+  "373": "TN",
+  "374": "TN",
+  "375": "TN",
+  "376": "TN",
+  "377": "TN",
+  "378": "TN",
+  "379": "TN",
+  "380": "TN",
+  "381": "TN",
+  "382": "TN",
+  "383": "TN",
+  "384": "TN",
+  "385": "TN",
+  "386": "MS",
+  "387": "MS",
+  "388": "MS",
+  "389": "MS",
+  "390": "MS",
+  "391": "MS",
+  "392": "MS",
+  "393": "MS",
+  "394": "MS",
+  "395": "MS",
+  "396": "MS",
+  "397": "MS",
+  "398": "GA",
+  "399": "GA",
+  "400": "KY",
+  "401": "KY",
+  "402": "KY",
+  "403": "KY",
+  "404": "KY",
+  "405": "KY",
+  "406": "KY",
+  "407": "KY",
+  "408": "KY",
+  "409": "KY",
+  "410": "KY",
+  "411": "KY",
+  "412": "KY",
+  "413": "KY",
+  "414": "KY",
+  "415": "KY",
+  "416": "KY",
+  "417": "KY",
+  "418": "KY",
+  "420": "KY",
+  "421": "KY",
+  "422": "KY",
+  "423": "KY",
+  "424": "KY",
+  "425": "KY",
+  "426": "KY",
+  "427": "KY",
+  "430": "OH",
+  "431": "OH",
+  "432": "OH",
+  "433": "OH",
+  "434": "OH",
+  "435": "OH",
+  "436": "OH",
+  "437": "OH",
+  "438": "OH",
+  "439": "OH",
+  "440": "OH",
+  "441": "OH",
+  "442": "OH",
+  "443": "OH",
+  "444": "OH",
+  "445": "OH",
+  "446": "OH",
+  "447": "OH",
+  "448": "OH",
+  "449": "OH",
+  "450": "OH",
+  "451": "OH",
+  "452": "OH",
+  "453": "OH",
+  "454": "OH",
+  "455": "OH",
+  "456": "OH",
+  "457": "OH",
+  "458": "OH",
+  "459": "OH",
+  "460": "IN",
+  "461": "IN",
+  "462": "IN",
+  "463": "IN",
+  "464": "IN",
+  "465": "IN",
+  "466": "IN",
+  "467": "IN",
+  "468": "IN",
+  "469": "IN",
+  "470": "IN",
+  "471": "IN",
+  "472": "IN",
+  "473": "IN",
+  "474": "IN",
+  "475": "IN",
+  "476": "IN",
+  "477": "IN",
+  "478": "IN",
+  "479": "IN",
+  "480": "MI",
+  "481": "MI",
+  "482": "MI",
+  "483": "MI",
+  "484": "MI",
+  "485": "MI",
+  "486": "MI",
+  "487": "MI",
+  "488": "MI",
+  "489": "MI",
+  "490": "MI",
+  "491": "MI",
+  "492": "MI",
+  "493": "MI",
+  "494": "MI",
+  "495": "MI",
+  "496": "MI",
+  "497": "MI",
+  "498": "MI",
+  "499": "MI",
+  "500": "IA",
+  "501": "IA",
+  "502": "IA",
+  "503": "IA",
+  "504": "IA",
+  "505": "IA",
+  "506": "IA",
+  "507": "IA",
+  "508": "IA",
+  "509": "IA",
+  "510": "IA",
+  "511": "IA",
+  "512": "IA",
+  "513": "IA",
+  "514": "IA",
+  "515": "IA",
+  "516": "IA",
+  "520": "IA",
+  "521": "IA",
+  "522": "IA",
+  "523": "IA",
+  "524": "IA",
+  "525": "IA",
+  "526": "IA",
+  "527": "IA",
+  "528": "IA",
+  "530": "WI",
+  "531": "WI",
+  "532": "WI",
+  "534": "WI",
+  "535": "WI",
+  "537": "WI",
+  "538": "WI",
+  "539": "WI",
+  "540": "WI",
+  "541": "WI",
+  "542": "WI",
+  "543": "WI",
+  "544": "WI",
+  "545": "WI",
+  "546": "WI",
+  "547": "WI",
+  "548": "WI",
+  "549": "WI",
+  "550": "MN",
+  "551": "MN",
+  "553": "MN",
+  "554": "MN",
+  "555": "MN",
+  "556": "MN",
+  "557": "MN",
+  "558": "MN",
+  "559": "MN",
+  "560": "MN",
+  "561": "MN",
+  "562": "MN",
+  "563": "MN",
+  "564": "MN",
+  "565": "MN",
+  "566": "MN",
+  "567": "MN",
+  "570": "SD",
+  "571": "SD",
+  "572": "SD",
+  "573": "SD",
+  "574": "SD",
+  "575": "SD",
+  "576": "SD",
+  "577": "SD",
+  "580": "ND",
+  "581": "ND",
+  "582": "ND",
+  "583": "ND",
+  "584": "ND",
+  "585": "ND",
+  "586": "ND",
+  "587": "ND",
+  "588": "ND",
+  "590": "MT",
+  "591": "MT",
+  "592": "MT",
+  "593": "MT",
+  "594": "MT",
+  "595": "MT",
+  "596": "MT",
+  "597": "MT",
+  "598": "MT",
+  "599": "MT",
+  "600": "IL",
+  "601": "IL",
+  "602": "IL",
+  "603": "IL",
+  "604": "IL",
+  "605": "IL",
+  "606": "IL",
+  "607": "IL",
+  "608": "IL",
+  "609": "IL",
+  "610": "IL",
+  "611": "IL",
+  "612": "IL",
+  "613": "IL",
+  "614": "IL",
+  "615": "IL",
+  "616": "IL",
+  "617": "IL",
+  "618": "IL",
+  "619": "IL",
+  "620": "IL",
+  "622": "IL",
+  "623": "IL",
+  "624": "IL",
+  "625": "IL",
+  "626": "IL",
+  "627": "IL",
+  "628": "IL",
+  "629": "IL",
+  "630": "MO",
+  "631": "MO",
+  "633": "MO",
+  "634": "MO",
+  "635": "MO",
+  "636": "MO",
+  "637": "MO",
+  "638": "MO",
+  "639": "MO",
+  "640": "MO",
+  "641": "MO",
+  "644": "MO",
+  "645": "MO",
+  "646": "MO",
+  "647": "MO",
+  "648": "MO",
+  "649": "MO",
+  "650": "MO",
+  "651": "MO",
+  "652": "MO",
+  "653": "MO",
+  "654": "MO",
+  "655": "MO",
+  "656": "MO",
+  "657": "MO",
+  "658": "MO",
+  "660": "KS",
+  "661": "KS",
+  "662": "KS",
+  "664": "KS",
+  "665": "KS",
+  "666": "KS",
+  "667": "KS",
+  "668": "KS",
+  "669": "KS",
+  "670": "KS",
+  "671": "KS",
+  "672": "KS",
+  "673": "KS",
+  "674": "KS",
+  "675": "KS",
+  "676": "KS",
+  "677": "KS",
+  "678": "KS",
+  "679": "KS",
+  "680": "NE",
+  "681": "NE",
+  "683": "NE",
+  "684": "NE",
+  "685": "NE",
+  "686": "NE",
+  "687": "NE",
+  "688": "NE",
+  "689": "NE",
+  "690": "NE",
+  "691": "NE",
+  "692": "NE",
+  "693": "NE",
+  "700": "LA",
+  "701": "LA",
+  "703": "LA",
+  "704": "LA",
+  "705": "LA",
+  "706": "LA",
+  "707": "LA",
+  "708": "LA",
+  "710": "LA",
+  "711": "LA",
+  "712": "LA",
+  "713": "LA",
+  "714": "LA",
+  "716": "AR",
+  "717": "AR",
+  "718": "AR",
+  "719": "AR",
+  "720": "AR",
+  "721": "AR",
+  "722": "AR",
+  "723": "AR",
+  "724": "AR",
+  "725": "AR",
+  "726": "AR",
+  "727": "AR",
+  "728": "AR",
+  "729": "AR",
+  "730": "OK",
+  "731": "OK",
+  "733": "OK",
+  "734": "OK",
+  "735": "OK",
+  "736": "OK",
+  "737": "OK",
+  "738": "OK",
+  "739": "OK",
+  "740": "OK",
+  "741": "OK",
+  "743": "OK",
+  "744": "OK",
+  "745": "OK",
+  "746": "OK",
+  "747": "OK",
+  "748": "OK",
+  "749": "OK",
+  "750": "TX",
+  "751": "TX",
+  "752": "TX",
+  "753": "TX",
+  "754": "TX",
+  "755": "TX",
+  "756": "TX",
+  "757": "TX",
+  "758": "TX",
+  "759": "TX",
+  "760": "TX",
+  "761": "TX",
+  "762": "TX",
+  "763": "TX",
+  "764": "TX",
+  "765": "TX",
+  "766": "TX",
+  "767": "TX",
+  "768": "TX",
+  "769": "TX",
+  "770": "TX",
+  "771": "TX",
+  "772": "TX",
+  "773": "TX",
+  "774": "TX",
+  "775": "TX",
+  "776": "TX",
+  "777": "TX",
+  "778": "TX",
+  "779": "TX",
+  "780": "TX",
+  "781": "TX",
+  "782": "TX",
+  "783": "TX",
+  "784": "TX",
+  "785": "TX",
+  "786": "TX",
+  "787": "TX",
+  "788": "TX",
+  "789": "TX",
+  "790": "TX",
+  "791": "TX",
+  "792": "TX",
+  "793": "TX",
+  "794": "TX",
+  "795": "TX",
+  "796": "TX",
+  "797": "TX",
+  "798": "TX",
+  "799": "TX",
+  "800": "CO",
+  "801": "CO",
+  "802": "CO",
+  "803": "CO",
+  "804": "CO",
+  "805": "CO",
+  "806": "CO",
+  "807": "CO",
+  "808": "CO",
+  "809": "CO",
+  "810": "CO",
+  "811": "CO",
+  "812": "CO",
+  "813": "CO",
+  "814": "CO",
+  "815": "CO",
+  "816": "CO",
+  "820": "WY",
+  "821": "WY",
+  "822": "WY",
+  "823": "WY",
+  "824": "WY",
+  "825": "WY",
+  "826": "WY",
+  "827": "WY",
+  "828": "WY",
+  "829": "WY",
+  "830": "WY",
+  "831": "WY",
+  "832": "ID",
+  "833": "ID",
+  "834": "ID",
+  "835": "ID",
+  "836": "ID",
+  "837": "ID",
+  "838": "ID",
+  "839": "ID",
+  "840": "UT",
+  "841": "UT",
+  "842": "UT",
+  "843": "UT",
+  "844": "UT",
+  "845": "UT",
+  "846": "UT",
+  "847": "UT",
+  "850": "AZ",
+  "851": "AZ",
+  "852": "AZ",
+  "853": "AZ",
+  "854": "AZ",
+  "855": "AZ",
+  "856": "AZ",
+  "857": "AZ",
+  "859": "AZ",
+  "860": "AZ",
+  "863": "AZ",
+  "864": "AZ",
+  "865": "AZ",
+  "870": "NM",
+  "871": "NM",
+  "872": "NM",
+  "873": "NM",
+  "874": "NM",
+  "875": "NM",
+  "877": "NM",
+  "878": "NM",
+  "879": "NM",
+  "880": "NM",
+  "881": "NM",
+  "882": "NM",
+  "883": "NM",
+  "884": "NM",
+  "885": "TX",
+  "889": "NV",
+  "890": "NV",
+  "891": "NV",
+  "893": "NV",
+  "894": "NV",
+  "895": "NV",
+  "897": "NV",
+  "898": "NV",
+  "899": "NV",
+  "900": "CA",
+  "901": "CA",
+  "902": "CA",
+  "903": "CA",
+  "904": "CA",
+  "905": "CA",
+  "906": "CA",
+  "907": "CA",
+  "908": "CA",
+  "909": "CA",
+  "910": "CA",
+  "911": "CA",
+  "912": "CA",
+  "913": "CA",
+  "914": "CA",
+  "915": "CA",
+  "916": "CA",
+  "917": "CA",
+  "918": "CA",
+  "919": "CA",
+  "920": "CA",
+  "921": "CA",
+  "922": "CA",
+  "923": "CA",
+  "924": "CA",
+  "925": "CA",
+  "926": "CA",
+  "927": "CA",
+  "928": "CA",
+  "929": "CA",
+  "930": "CA",
+  "931": "CA",
+  "932": "CA",
+  "933": "CA",
+  "934": "CA",
+  "935": "CA",
+  "936": "CA",
+  "937": "CA",
+  "938": "CA",
+  "939": "CA",
+  "940": "CA",
+  "941": "CA",
+  "942": "CA",
+  "943": "CA",
+  "944": "CA",
+  "945": "CA",
+  "946": "CA",
+  "947": "CA",
+  "948": "CA",
+  "949": "CA",
+  "950": "CA",
+  "951": "CA",
+  "952": "CA",
+  "953": "CA",
+  "954": "CA",
+  "955": "CA",
+  "956": "CA",
+  "957": "CA",
+  "958": "CA",
+  "959": "CA",
+  "960": "CA",
+  "961": "CA",
+  "962": "AP",
+  "963": "GU",
+  "964": "AP",
+  "965": "AP",
+  "966": "AP",
+  "967": "HI",
+  "968": "HI",
+  "969": "MP",
+  "970": "OR",
+  "971": "OR",
+  "972": "OR",
+  "973": "OR",
+  "974": "OR",
+  "975": "OR",
+  "976": "OR",
+  "977": "OR",
+  "978": "OR",
+  "979": "OR",
+  "980": "WA",
+  "981": "WA",
+  "982": "WA",
+  "983": "WA",
+  "984": "WA",
+  "985": "WA",
+  "986": "WA",
+  "987": "WA",
+  "988": "WA",
+  "989": "WA",
+  "990": "WA",
+  "991": "WA",
+  "992": "WA",
+  "993": "WA",
+  "994": "WA",
+  "995": "AK",
+  "996": "AK",
+  "997": "AK",
+  "998": "AK",
+  "999": "AK"
+};
+function zipcodeToState(zipcode) {
+  const fullZip = zipcode.slice(0, 5);
+  if (zipcodeToStateCode[fullZip]) {
+    return zipcodeToStateCode[fullZip];
+  }
+  const prefix = zipcode.slice(0, 3);
+  return prefixToState[prefix] || null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigKeys,
+  CurrencyUnit,
+  DefaultCrypto,
+  KeyOrAlias,
+  LightsparkAuthException,
+  LightsparkException,
+  LightsparkSigningException,
+  Logger,
+  LoggingLevel,
+  NodeKeyCache,
+  RSASigningKey,
+  Requester,
+  Secp256k1SigningKey,
+  ServerEnvironment,
+  SigningKey,
+  SigningKeyType,
+  StubAuthProvider,
+  abbrCurrencyUnit,
+  apiDomainForEnvironment,
+  b64decode,
+  b64encode,
+  bytesToHex,
+  clamp,
+  convertCurrencyAmount,
+  convertCurrencyAmountValue,
+  countryCodesToCurrencyCodes,
+  createSha256Hash,
+  defaultCurrencyCode,
+  deleteLocalStorageItem,
+  ensureArray,
+  errorToJSON,
+  formatCurrencyStr,
+  formatInviteAmount,
+  getCurrencyAmount,
+  getCurrentLocale,
+  getErrorMsg,
+  getLocalStorageBoolean,
+  getLocalStorageConfigItem,
+  hexToBytes,
+  isBare,
+  isBrowser,
+  isCurrencyAmountInputObj,
+  isCurrencyAmountObj,
+  isCurrencyAmountPreferenceObj,
+  isCurrencyMap,
+  isDeprecatedCurrencyAmountObj,
+  isError,
+  isErrorMsg,
+  isErrorWithMessage,
+  isNode,
+  isNumber,
+  isObject,
+  isReactNative,
+  isRecord,
+  isSDKCurrencyAmount,
+  isTest,
+  isType,
+  isUint8Array,
+  isUmaCurrencyAmount,
+  linearInterpolate,
+  localeToCurrencyCode,
+  localeToCurrencySymbol,
+  logger,
+  lsidToUUID,
+  mapCurrencyAmount,
+  notNullUndefined,
+  pollUntil,
+  round,
+  separateCurrencyStrParts,
+  setLocalStorageBoolean,
+  sleep,
+  urlsafe_b64decode,
+  zipcodeToState,
+  zipcodeToStateCode
+});
+/*! Bundled license information:
+
+lodash-es/lodash.js:
+  (**
+   * @license
+   * Lodash (Custom Build) <https://lodash.com/>
+   * Build: `lodash modularize exports="es" -o ./`
+   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+   * Released under MIT license <https://lodash.com/license>
+   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+   *)
+*/