@1shotapi/1shotpay-common 0.1.0

package/dist/index.js

@@ -0,0 +1,1377 @@
+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 __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// ../../node_modules/safe-stable-stringify/index.js
+var require_safe_stable_stringify = __commonJS({
+  "../../node_modules/safe-stable-stringify/index.js"(exports, module) {
+    "use strict";
+    var { hasOwnProperty } = Object.prototype;
+    var stringify = configure2();
+    stringify.configure = configure2;
+    stringify.stringify = stringify;
+    stringify.default = stringify;
+    exports.stringify = stringify;
+    exports.configure = configure2;
+    module.exports = stringify;
+    var strEscapeSequencesRegExp = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
+    function strEscape(str) {
+      if (str.length < 5e3 && !strEscapeSequencesRegExp.test(str)) {
+        return `"${str}"`;
+      }
+      return JSON.stringify(str);
+    }
+    function sort(array, comparator) {
+      if (array.length > 200 || comparator) {
+        return array.sort(comparator);
+      }
+      for (let i = 1; i < array.length; i++) {
+        const currentValue = array[i];
+        let position = i;
+        while (position !== 0 && array[position - 1] > currentValue) {
+          array[position] = array[position - 1];
+          position--;
+        }
+        array[position] = currentValue;
+      }
+      return array;
+    }
+    var typedArrayPrototypeGetSymbolToStringTag = Object.getOwnPropertyDescriptor(
+      Object.getPrototypeOf(
+        Object.getPrototypeOf(
+          new Int8Array()
+        )
+      ),
+      Symbol.toStringTag
+    ).get;
+    function isTypedArrayWithEntries(value) {
+      return typedArrayPrototypeGetSymbolToStringTag.call(value) !== void 0 && value.length !== 0;
+    }
+    function stringifyTypedArray(array, separator, maximumBreadth) {
+      if (array.length < maximumBreadth) {
+        maximumBreadth = array.length;
+      }
+      const whitespace = separator === "," ? "" : " ";
+      let res = `"0":${whitespace}${array[0]}`;
+      for (let i = 1; i < maximumBreadth; i++) {
+        res += `${separator}"${i}":${whitespace}${array[i]}`;
+      }
+      return res;
+    }
+    function getCircularValueOption(options) {
+      if (hasOwnProperty.call(options, "circularValue")) {
+        const circularValue = options.circularValue;
+        if (typeof circularValue === "string") {
+          return `"${circularValue}"`;
+        }
+        if (circularValue == null) {
+          return circularValue;
+        }
+        if (circularValue === Error || circularValue === TypeError) {
+          return {
+            toString() {
+              throw new TypeError("Converting circular structure to JSON");
+            }
+          };
+        }
+        throw new TypeError('The "circularValue" argument must be of type string or the value null or undefined');
+      }
+      return '"[Circular]"';
+    }
+    function getDeterministicOption(options) {
+      let value;
+      if (hasOwnProperty.call(options, "deterministic")) {
+        value = options.deterministic;
+        if (typeof value !== "boolean" && typeof value !== "function") {
+          throw new TypeError('The "deterministic" argument must be of type boolean or comparator function');
+        }
+      }
+      return value === void 0 ? true : value;
+    }
+    function getBooleanOption(options, key) {
+      let value;
+      if (hasOwnProperty.call(options, key)) {
+        value = options[key];
+        if (typeof value !== "boolean") {
+          throw new TypeError(`The "${key}" argument must be of type boolean`);
+        }
+      }
+      return value === void 0 ? true : value;
+    }
+    function getPositiveIntegerOption(options, key) {
+      let value;
+      if (hasOwnProperty.call(options, key)) {
+        value = options[key];
+        if (typeof value !== "number") {
+          throw new TypeError(`The "${key}" argument must be of type number`);
+        }
+        if (!Number.isInteger(value)) {
+          throw new TypeError(`The "${key}" argument must be an integer`);
+        }
+        if (value < 1) {
+          throw new RangeError(`The "${key}" argument must be >= 1`);
+        }
+      }
+      return value === void 0 ? Infinity : value;
+    }
+    function getItemCount(number) {
+      if (number === 1) {
+        return "1 item";
+      }
+      return `${number} items`;
+    }
+    function getUniqueReplacerSet(replacerArray) {
+      const replacerSet = /* @__PURE__ */ new Set();
+      for (const value of replacerArray) {
+        if (typeof value === "string" || typeof value === "number") {
+          replacerSet.add(String(value));
+        }
+      }
+      return replacerSet;
+    }
+    function getStrictOption(options) {
+      if (hasOwnProperty.call(options, "strict")) {
+        const value = options.strict;
+        if (typeof value !== "boolean") {
+          throw new TypeError('The "strict" argument must be of type boolean');
+        }
+        if (value) {
+          return (value2) => {
+            let message = `Object can not safely be stringified. Received type ${typeof value2}`;
+            if (typeof value2 !== "function") message += ` (${value2.toString()})`;
+            throw new Error(message);
+          };
+        }
+      }
+    }
+    function configure2(options) {
+      options = { ...options };
+      const fail = getStrictOption(options);
+      if (fail) {
+        if (options.bigint === void 0) {
+          options.bigint = false;
+        }
+        if (!("circularValue" in options)) {
+          options.circularValue = Error;
+        }
+      }
+      const circularValue = getCircularValueOption(options);
+      const bigint = getBooleanOption(options, "bigint");
+      const deterministic = getDeterministicOption(options);
+      const comparator = typeof deterministic === "function" ? deterministic : void 0;
+      const maximumDepth = getPositiveIntegerOption(options, "maximumDepth");
+      const maximumBreadth = getPositiveIntegerOption(options, "maximumBreadth");
+      function stringifyFnReplacer(key, parent, stack, replacer, spacer, indentation) {
+        let value = parent[key];
+        if (typeof value === "object" && value !== null && typeof value.toJSON === "function") {
+          value = value.toJSON(key);
+        }
+        value = replacer.call(parent, key, value);
+        switch (typeof value) {
+          case "string":
+            return strEscape(value);
+          case "object": {
+            if (value === null) {
+              return "null";
+            }
+            if (stack.indexOf(value) !== -1) {
+              return circularValue;
+            }
+            let res = "";
+            let join = ",";
+            const originalIndentation = indentation;
+            if (Array.isArray(value)) {
+              if (value.length === 0) {
+                return "[]";
+              }
+              if (maximumDepth < stack.length + 1) {
+                return '"[Array]"';
+              }
+              stack.push(value);
+              if (spacer !== "") {
+                indentation += spacer;
+                res += `
+${indentation}`;
+                join = `,
+${indentation}`;
+              }
+              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+              let i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+                res += tmp2 !== void 0 ? tmp2 : "null";
+                res += join;
+              }
+              const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+              res += tmp !== void 0 ? tmp : "null";
+              if (value.length - 1 > maximumBreadth) {
+                const removedKeys = value.length - maximumBreadth - 1;
+                res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              if (spacer !== "") {
+                res += `
+${originalIndentation}`;
+              }
+              stack.pop();
+              return `[${res}]`;
+            }
+            let keys = Object.keys(value);
+            const keyLength = keys.length;
+            if (keyLength === 0) {
+              return "{}";
+            }
+            if (maximumDepth < stack.length + 1) {
+              return '"[Object]"';
+            }
+            let whitespace = "";
+            let separator = "";
+            if (spacer !== "") {
+              indentation += spacer;
+              join = `,
+${indentation}`;
+              whitespace = " ";
+            }
+            const maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+            if (deterministic && !isTypedArrayWithEntries(value)) {
+              keys = sort(keys, comparator);
+            }
+            stack.push(value);
+            for (let i = 0; i < maximumPropertiesToStringify; i++) {
+              const key2 = keys[i];
+              const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
+              if (tmp !== void 0) {
+                res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
+                separator = join;
+              }
+            }
+            if (keyLength > maximumBreadth) {
+              const removedKeys = keyLength - maximumBreadth;
+              res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
+              separator = join;
+            }
+            if (spacer !== "" && separator.length > 1) {
+              res = `
+${indentation}${res}
+${originalIndentation}`;
+            }
+            stack.pop();
+            return `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+          case "boolean":
+            return value === true ? "true" : "false";
+          case "undefined":
+            return void 0;
+          case "bigint":
+            if (bigint) {
+              return String(value);
+            }
+          // fallthrough
+          default:
+            return fail ? fail(value) : void 0;
+        }
+      }
+      function stringifyArrayReplacer(key, value, stack, replacer, spacer, indentation) {
+        if (typeof value === "object" && value !== null && typeof value.toJSON === "function") {
+          value = value.toJSON(key);
+        }
+        switch (typeof value) {
+          case "string":
+            return strEscape(value);
+          case "object": {
+            if (value === null) {
+              return "null";
+            }
+            if (stack.indexOf(value) !== -1) {
+              return circularValue;
+            }
+            const originalIndentation = indentation;
+            let res = "";
+            let join = ",";
+            if (Array.isArray(value)) {
+              if (value.length === 0) {
+                return "[]";
+              }
+              if (maximumDepth < stack.length + 1) {
+                return '"[Array]"';
+              }
+              stack.push(value);
+              if (spacer !== "") {
+                indentation += spacer;
+                res += `
+${indentation}`;
+                join = `,
+${indentation}`;
+              }
+              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+              let i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+                res += tmp2 !== void 0 ? tmp2 : "null";
+                res += join;
+              }
+              const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+              res += tmp !== void 0 ? tmp : "null";
+              if (value.length - 1 > maximumBreadth) {
+                const removedKeys = value.length - maximumBreadth - 1;
+                res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              if (spacer !== "") {
+                res += `
+${originalIndentation}`;
+              }
+              stack.pop();
+              return `[${res}]`;
+            }
+            stack.push(value);
+            let whitespace = "";
+            if (spacer !== "") {
+              indentation += spacer;
+              join = `,
+${indentation}`;
+              whitespace = " ";
+            }
+            let separator = "";
+            for (const key2 of replacer) {
+              const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
+              if (tmp !== void 0) {
+                res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
+                separator = join;
+              }
+            }
+            if (spacer !== "" && separator.length > 1) {
+              res = `
+${indentation}${res}
+${originalIndentation}`;
+            }
+            stack.pop();
+            return `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+          case "boolean":
+            return value === true ? "true" : "false";
+          case "undefined":
+            return void 0;
+          case "bigint":
+            if (bigint) {
+              return String(value);
+            }
+          // fallthrough
+          default:
+            return fail ? fail(value) : void 0;
+        }
+      }
+      function stringifyIndent(key, value, stack, spacer, indentation) {
+        switch (typeof value) {
+          case "string":
+            return strEscape(value);
+          case "object": {
+            if (value === null) {
+              return "null";
+            }
+            if (typeof value.toJSON === "function") {
+              value = value.toJSON(key);
+              if (typeof value !== "object") {
+                return stringifyIndent(key, value, stack, spacer, indentation);
+              }
+              if (value === null) {
+                return "null";
+              }
+            }
+            if (stack.indexOf(value) !== -1) {
+              return circularValue;
+            }
+            const originalIndentation = indentation;
+            if (Array.isArray(value)) {
+              if (value.length === 0) {
+                return "[]";
+              }
+              if (maximumDepth < stack.length + 1) {
+                return '"[Array]"';
+              }
+              stack.push(value);
+              indentation += spacer;
+              let res2 = `
+${indentation}`;
+              const join2 = `,
+${indentation}`;
+              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+              let i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+                res2 += tmp2 !== void 0 ? tmp2 : "null";
+                res2 += join2;
+              }
+              const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+              res2 += tmp !== void 0 ? tmp : "null";
+              if (value.length - 1 > maximumBreadth) {
+                const removedKeys = value.length - maximumBreadth - 1;
+                res2 += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              res2 += `
+${originalIndentation}`;
+              stack.pop();
+              return `[${res2}]`;
+            }
+            let keys = Object.keys(value);
+            const keyLength = keys.length;
+            if (keyLength === 0) {
+              return "{}";
+            }
+            if (maximumDepth < stack.length + 1) {
+              return '"[Object]"';
+            }
+            indentation += spacer;
+            const join = `,
+${indentation}`;
+            let res = "";
+            let separator = "";
+            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+            if (isTypedArrayWithEntries(value)) {
+              res += stringifyTypedArray(value, join, maximumBreadth);
+              keys = keys.slice(value.length);
+              maximumPropertiesToStringify -= value.length;
+              separator = join;
+            }
+            if (deterministic) {
+              keys = sort(keys, comparator);
+            }
+            stack.push(value);
+            for (let i = 0; i < maximumPropertiesToStringify; i++) {
+              const key2 = keys[i];
+              const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
+              if (tmp !== void 0) {
+                res += `${separator}${strEscape(key2)}: ${tmp}`;
+                separator = join;
+              }
+            }
+            if (keyLength > maximumBreadth) {
+              const removedKeys = keyLength - maximumBreadth;
+              res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
+              separator = join;
+            }
+            if (separator !== "") {
+              res = `
+${indentation}${res}
+${originalIndentation}`;
+            }
+            stack.pop();
+            return `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+          case "boolean":
+            return value === true ? "true" : "false";
+          case "undefined":
+            return void 0;
+          case "bigint":
+            if (bigint) {
+              return String(value);
+            }
+          // fallthrough
+          default:
+            return fail ? fail(value) : void 0;
+        }
+      }
+      function stringifySimple(key, value, stack) {
+        switch (typeof value) {
+          case "string":
+            return strEscape(value);
+          case "object": {
+            if (value === null) {
+              return "null";
+            }
+            if (typeof value.toJSON === "function") {
+              value = value.toJSON(key);
+              if (typeof value !== "object") {
+                return stringifySimple(key, value, stack);
+              }
+              if (value === null) {
+                return "null";
+              }
+            }
+            if (stack.indexOf(value) !== -1) {
+              return circularValue;
+            }
+            let res = "";
+            const hasLength = value.length !== void 0;
+            if (hasLength && Array.isArray(value)) {
+              if (value.length === 0) {
+                return "[]";
+              }
+              if (maximumDepth < stack.length + 1) {
+                return '"[Array]"';
+              }
+              stack.push(value);
+              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+              let i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                const tmp2 = stringifySimple(String(i), value[i], stack);
+                res += tmp2 !== void 0 ? tmp2 : "null";
+                res += ",";
+              }
+              const tmp = stringifySimple(String(i), value[i], stack);
+              res += tmp !== void 0 ? tmp : "null";
+              if (value.length - 1 > maximumBreadth) {
+                const removedKeys = value.length - maximumBreadth - 1;
+                res += `,"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              stack.pop();
+              return `[${res}]`;
+            }
+            let keys = Object.keys(value);
+            const keyLength = keys.length;
+            if (keyLength === 0) {
+              return "{}";
+            }
+            if (maximumDepth < stack.length + 1) {
+              return '"[Object]"';
+            }
+            let separator = "";
+            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+            if (hasLength && isTypedArrayWithEntries(value)) {
+              res += stringifyTypedArray(value, ",", maximumBreadth);
+              keys = keys.slice(value.length);
+              maximumPropertiesToStringify -= value.length;
+              separator = ",";
+            }
+            if (deterministic) {
+              keys = sort(keys, comparator);
+            }
+            stack.push(value);
+            for (let i = 0; i < maximumPropertiesToStringify; i++) {
+              const key2 = keys[i];
+              const tmp = stringifySimple(key2, value[key2], stack);
+              if (tmp !== void 0) {
+                res += `${separator}${strEscape(key2)}:${tmp}`;
+                separator = ",";
+              }
+            }
+            if (keyLength > maximumBreadth) {
+              const removedKeys = keyLength - maximumBreadth;
+              res += `${separator}"...":"${getItemCount(removedKeys)} not stringified"`;
+            }
+            stack.pop();
+            return `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+          case "boolean":
+            return value === true ? "true" : "false";
+          case "undefined":
+            return void 0;
+          case "bigint":
+            if (bigint) {
+              return String(value);
+            }
+          // fallthrough
+          default:
+            return fail ? fail(value) : void 0;
+        }
+      }
+      function stringify2(value, replacer, space) {
+        if (arguments.length > 1) {
+          let spacer = "";
+          if (typeof space === "number") {
+            spacer = " ".repeat(Math.min(space, 10));
+          } else if (typeof space === "string") {
+            spacer = space.slice(0, 10);
+          }
+          if (replacer != null) {
+            if (typeof replacer === "function") {
+              return stringifyFnReplacer("", { "": value }, [], replacer, spacer, "");
+            }
+            if (Array.isArray(replacer)) {
+              return stringifyArrayReplacer("", value, [], getUniqueReplacerSet(replacer), spacer, "");
+            }
+          }
+          if (spacer.length !== 0) {
+            return stringifyIndent("", value, [], spacer, "");
+          }
+        }
+        return stringifySimple("", value, []);
+      }
+      return stringify2;
+    }
+  }
+});
+
+// types/enum/EHttpStatusCode.ts
+var EHttpStatusCode = /* @__PURE__ */ ((EHttpStatusCode2) => {
+  EHttpStatusCode2[EHttpStatusCode2["CONTINUE"] = 100] = "CONTINUE";
+  EHttpStatusCode2[EHttpStatusCode2["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+  EHttpStatusCode2[EHttpStatusCode2["PROCESSING"] = 102] = "PROCESSING";
+  EHttpStatusCode2[EHttpStatusCode2["OK"] = 200] = "OK";
+  EHttpStatusCode2[EHttpStatusCode2["CREATED"] = 201] = "CREATED";
+  EHttpStatusCode2[EHttpStatusCode2["ACCEPTED"] = 202] = "ACCEPTED";
+  EHttpStatusCode2[EHttpStatusCode2["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+  EHttpStatusCode2[EHttpStatusCode2["NO_CONTENT"] = 204] = "NO_CONTENT";
+  EHttpStatusCode2[EHttpStatusCode2["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+  EHttpStatusCode2[EHttpStatusCode2["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+  EHttpStatusCode2[EHttpStatusCode2["MULTI_STATUS"] = 207] = "MULTI_STATUS";
+  EHttpStatusCode2[EHttpStatusCode2["ALREADY_REPORTED"] = 208] = "ALREADY_REPORTED";
+  EHttpStatusCode2[EHttpStatusCode2["IM_USED"] = 226] = "IM_USED";
+  EHttpStatusCode2[EHttpStatusCode2["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
+  EHttpStatusCode2[EHttpStatusCode2["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+  EHttpStatusCode2[EHttpStatusCode2["FOUND"] = 302] = "FOUND";
+  EHttpStatusCode2[EHttpStatusCode2["SEE_OTHER"] = 303] = "SEE_OTHER";
+  EHttpStatusCode2[EHttpStatusCode2["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+  EHttpStatusCode2[EHttpStatusCode2["USE_PROXY"] = 305] = "USE_PROXY";
+  EHttpStatusCode2[EHttpStatusCode2["SWITCH_PROXY"] = 306] = "SWITCH_PROXY";
+  EHttpStatusCode2[EHttpStatusCode2["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+  EHttpStatusCode2[EHttpStatusCode2["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+  EHttpStatusCode2[EHttpStatusCode2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  EHttpStatusCode2[EHttpStatusCode2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  EHttpStatusCode2[EHttpStatusCode2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+  EHttpStatusCode2[EHttpStatusCode2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  EHttpStatusCode2[EHttpStatusCode2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  EHttpStatusCode2[EHttpStatusCode2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+  EHttpStatusCode2[EHttpStatusCode2["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+  EHttpStatusCode2[EHttpStatusCode2["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+  EHttpStatusCode2[EHttpStatusCode2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+  EHttpStatusCode2[EHttpStatusCode2["CONFLICT"] = 409] = "CONFLICT";
+  EHttpStatusCode2[EHttpStatusCode2["GONE"] = 410] = "GONE";
+  EHttpStatusCode2[EHttpStatusCode2["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+  EHttpStatusCode2[EHttpStatusCode2["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+  EHttpStatusCode2[EHttpStatusCode2["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+  EHttpStatusCode2[EHttpStatusCode2["URI_TOO_LONG"] = 414] = "URI_TOO_LONG";
+  EHttpStatusCode2[EHttpStatusCode2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+  EHttpStatusCode2[EHttpStatusCode2["RANGE_NOT_SATISFIABLE"] = 416] = "RANGE_NOT_SATISFIABLE";
+  EHttpStatusCode2[EHttpStatusCode2["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+  EHttpStatusCode2[EHttpStatusCode2["I_AM_A_TEAPOT"] = 418] = "I_AM_A_TEAPOT";
+  EHttpStatusCode2[EHttpStatusCode2["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+  EHttpStatusCode2[EHttpStatusCode2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+  EHttpStatusCode2[EHttpStatusCode2["LOCKED"] = 423] = "LOCKED";
+  EHttpStatusCode2[EHttpStatusCode2["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+  EHttpStatusCode2[EHttpStatusCode2["UPGRADE_REQUIRED"] = 426] = "UPGRADE_REQUIRED";
+  EHttpStatusCode2[EHttpStatusCode2["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+  EHttpStatusCode2[EHttpStatusCode2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  EHttpStatusCode2[EHttpStatusCode2["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
+  EHttpStatusCode2[EHttpStatusCode2["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
+  EHttpStatusCode2[EHttpStatusCode2["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+  EHttpStatusCode2[EHttpStatusCode2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+  EHttpStatusCode2[EHttpStatusCode2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+  EHttpStatusCode2[EHttpStatusCode2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  EHttpStatusCode2[EHttpStatusCode2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+  EHttpStatusCode2[EHttpStatusCode2["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+  EHttpStatusCode2[EHttpStatusCode2["VARIANT_ALSO_NEGOTIATES"] = 506] = "VARIANT_ALSO_NEGOTIATES";
+  EHttpStatusCode2[EHttpStatusCode2["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+  EHttpStatusCode2[EHttpStatusCode2["LOOP_DETECTED"] = 508] = "LOOP_DETECTED";
+  EHttpStatusCode2[EHttpStatusCode2["NOT_EXTENDED"] = 510] = "NOT_EXTENDED";
+  EHttpStatusCode2[EHttpStatusCode2["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+  return EHttpStatusCode2;
+})(EHttpStatusCode || {});
+
+// types/enum/ELocale.ts
+var ELocale = /* @__PURE__ */ ((ELocale2) => {
+  ELocale2["English"] = "en";
+  ELocale2["Spanish"] = "es";
+  ELocale2["Turkish"] = "tr";
+  return ELocale2;
+})(ELocale || {});
+
+// types/enum/EPayLinkStatus.ts
+var EPayLinkStatus = /* @__PURE__ */ ((EPayLinkStatus2) => {
+  EPayLinkStatus2[EPayLinkStatus2["Active"] = 0] = "Active";
+  EPayLinkStatus2[EPayLinkStatus2["Paid"] = 1] = "Paid";
+  EPayLinkStatus2[EPayLinkStatus2["Expired"] = 2] = "Expired";
+  return EPayLinkStatus2;
+})(EPayLinkStatus || {});
+
+// types/primitives/ApiToken.ts
+import { make } from "ts-brand";
+var ApiToken = make();
+
+// types/primitives/BigNumberString.ts
+import { make as make2 } from "ts-brand";
+var BigNumberString = make2();
+
+// types/primitives/Base64String.ts
+import { make as make3 } from "ts-brand";
+var Base64String = make3();
+
+// types/primitives/DecimalAmount.ts
+import { make as make4 } from "ts-brand";
+var DecimalAmount = make4();
+
+// types/primitives/EVMAccountAddress.ts
+import { make as make5 } from "ts-brand";
+var EVMAccountAddress = make5();
+
+// types/primitives/EVMContractAddress.ts
+import { make as make6 } from "ts-brand";
+var EVMContractAddress = make6();
+
+// types/primitives/HexString.ts
+import { make as make7 } from "ts-brand";
+var HexString = make7();
+
+// types/primitives/ISO8601DateString.ts
+import { make as make8 } from "ts-brand";
+var ISO8601DateString = make8();
+
+// types/primitives/JSONWebToken.ts
+import { make as make9 } from "ts-brand";
+var JsonWebToken = make9();
+
+// types/primitives/JSONString.ts
+import { make as make10 } from "ts-brand";
+var JSONString = make10();
+
+// types/primitives/MillisecondTimestamp.ts
+import { make as make11 } from "ts-brand";
+var MillisecondTimestamp = make11();
+
+// types/primitives/PayLinkId.ts
+import { make as make12 } from "ts-brand";
+var PayLinkId = make12();
+
+// types/primitives/PayLinkPaymentId.ts
+import { make as make13 } from "ts-brand";
+var PayLinkPaymentId = make13();
+
+// types/primitives/RelayerTransactionId.ts
+import { make as make14 } from "ts-brand";
+var RelayerTransactionId = make14();
+
+// types/primitives/Signature.ts
+import { make as make15 } from "ts-brand";
+var Signature = make15();
+
+// types/primitives/TransactionHash.ts
+import { make as make16 } from "ts-brand";
+var TransactionHash = make16();
+
+// types/primitives/UnixTimestamp.ts
+import { make as make17 } from "ts-brand";
+var UnixTimestamp = make17();
+
+// types/primitives/URLString.ts
+import { make as make18 } from "ts-brand";
+var URLString = make18();
+
+// types/primitives/USDCAmount.ts
+import { make as make19 } from "ts-brand";
+var USDCAmount = make19();
+
+// types/primitives/UserId.ts
+import { make as make20 } from "ts-brand";
+var UserId = make20();
+
+// types/primitives/Username.ts
+import { make as make21 } from "ts-brand";
+var Username = make21();
+
+// types/errors/BaseError.ts
+var BaseError = class extends Error {
+  constructor(src, errorType) {
+    super(src.message);
+    this.name = errorType;
+    this.stack = src.stack;
+    Object.setPrototypeOf(this, this.constructor.prototype);
+  }
+  // Helper method to get error details
+  getErrorDetails() {
+    return {
+      name: this.name,
+      message: this.message,
+      errorCode: this.errorCode,
+      errorType: this.errorType,
+      stack: this.stack
+    };
+  }
+};
+
+// types/errors/AjaxError.ts
+var AjaxError = class _AjaxError extends BaseError {
+  errorCode = "ERR_AJAX";
+  errorType = "AjaxError";
+  httpStatus = 500 /* INTERNAL_SERVER_ERROR */;
+  constructor(src) {
+    super(src, "AjaxError");
+  }
+  // Static factory method
+  static fromError(src) {
+    return new _AjaxError(src);
+  }
+  // Static type guard method
+  static isError(error) {
+    return error instanceof _AjaxError;
+  }
+};
+
+// types/errors/ProxyError.ts
+var ProxyError = class _ProxyError extends BaseError {
+  errorCode = "ERR_PROXY";
+  errorType = "ProxyError";
+  httpStatus = 500 /* INTERNAL_SERVER_ERROR */;
+  constructor(src) {
+    super(src, "ProxyError");
+  }
+  // Static factory method
+  static fromError(src) {
+    return new _ProxyError(src);
+  }
+  // Static type guard method
+  static isError(error) {
+    return error instanceof _ProxyError;
+  }
+};
+
+// types/errors/RetryError.ts
+var RetryError = class _RetryError extends BaseError {
+  errorCode = "ERR_RETRY";
+  errorType = "REtryError";
+  httpStatus = 418 /* I_AM_A_TEAPOT */;
+  constructor(src) {
+    super(src, "RetryError");
+  }
+  // Static factory method
+  static fromError(src) {
+    return new _RetryError(src);
+  }
+  // Static type guard method
+  static isError(error) {
+    return error instanceof _RetryError;
+  }
+};
+
+// types/errors/ValidationError.ts
+var ValidationError = class _ValidationError extends BaseError {
+  errorCode = "ERR_VALIDATION";
+  errorType = "ValidationError";
+  httpStatus = 400 /* BAD_REQUEST */;
+  constructor(src) {
+    super(src, "ValidationError");
+  }
+  // Static factory method
+  static fromError(src) {
+    return new _ValidationError(src);
+  }
+  // Static type guard method
+  static isError(error) {
+    return error instanceof _ValidationError;
+  }
+};
+
+// types/models/OAuthTokenModel.ts
+var OAuthTokenModel = class {
+  constructor(access_token, token_type, expires_in) {
+    this.access_token = access_token;
+    this.token_type = token_type;
+    this.expires_in = expires_in;
+  }
+};
+
+// utils/AjaxUtils.ts
+import { ResultAsync } from "neverthrow";
+function isJsonBody(data) {
+  return typeof data === "object" && data !== null && !(data instanceof ArrayBuffer) && !(data instanceof Blob) && !(data instanceof FormData) && !(data instanceof URLSearchParams) && !ArrayBuffer.isView(data) && typeof data.getReader !== "function";
+}
+function bodyToRequestInit(data) {
+  if (data === void 0 || data === null) {
+    return {};
+  }
+  if (isJsonBody(data)) {
+    return {
+      body: JSON.stringify(data),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    };
+  }
+  return { body: data };
+}
+var AjaxUtils = class {
+  defaultToken = "";
+  setDefaultToken(token) {
+    this.defaultToken = token;
+  }
+  get(url, config) {
+    return this.doFetch(url, this.mergeConfig(config, { method: "GET" }));
+  }
+  post(url, data, config) {
+    const { body, headers } = bodyToRequestInit(data);
+    const init = { method: "POST" };
+    if (body !== void 0) init.body = body;
+    if (headers !== void 0) init.headers = headers;
+    return this.doFetch(url, this.mergeConfig(config, init));
+  }
+  put(url, data, config) {
+    const { body, headers } = bodyToRequestInit(data);
+    return this.doFetch(
+      url,
+      this.mergeConfig(config, { method: "PUT", body, headers })
+    );
+  }
+  delete(url, config) {
+    return this.doFetch(url, this.mergeConfig(config, { method: "DELETE" }));
+  }
+  mergeConfig(config, init) {
+    const headers = new Headers(init.headers);
+    if (config?.headers) {
+      const c = new Headers(config.headers);
+      c.forEach((v, k) => headers.set(k, v));
+    }
+    if (this.defaultToken) {
+      headers.set("Authorization", `Bearer ${this.defaultToken}`);
+    }
+    return {
+      ...config,
+      ...init,
+      headers
+    };
+  }
+  doFetch(url, init) {
+    return ResultAsync.fromPromise(
+      (async () => {
+        const res = await fetch(url, init);
+        if (!res.ok) {
+          const text = await res.text();
+          throw new Error(
+            `HTTP ${res.status} ${res.statusText}${text ? `: ${text}` : ""}`
+          );
+        }
+        const contentType = res.headers.get("content-type") ?? "";
+        if (contentType.toLowerCase().includes("application/json")) {
+          return await res.json();
+        }
+        return await res.text();
+      })(),
+      (e) => AjaxError.fromError(e)
+    );
+  }
+};
+
+// utils/ITimeUtils.ts
+var ITimeUtilsType = /* @__PURE__ */ Symbol.for("ITimeUtils");
+
+// utils/ObjectUtils.ts
+import { okAsync, ResultAsync as ResultAsync2 } from "neverthrow";
+
+// ../../node_modules/safe-stable-stringify/esm/wrapper.js
+var import__ = __toESM(require_safe_stable_stringify(), 1);
+var configure = import__.default.configure;
+var wrapper_default = import__.default;
+
+// utils/ObjectUtils.ts
+var ObjectUtils = class _ObjectUtils {
+  // Taken from https://stackoverflow.com/questions/27936772/how-to-deep-merge-instead-of-shallow-merge
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static mergeDeep(...objects) {
+    const isObject = (obj) => obj && typeof obj === "object";
+    return objects.reduce((prev, obj) => {
+      Object.keys(obj).forEach((key) => {
+        const pVal = prev[key];
+        const oVal = obj[key];
+        if (Array.isArray(pVal) && Array.isArray(oVal)) {
+          prev[key] = pVal.concat(...oVal);
+        } else if (isObject(pVal) && isObject(oVal)) {
+          prev[key] = _ObjectUtils.mergeDeep(pVal, oVal);
+        } else {
+          prev[key] = oVal;
+        }
+      });
+      return prev;
+    }, {});
+  }
+  /**
+   * This method is an improvement on JSON.stringify. It uses a stable stringify method so that objects will always generate the same
+   * hash, and it support a few non-serializeable types that are useful, such as BigInt, Map, and Set. The output is correct JSON
+   * but uses markup to support the non-native types and must be deserialized with the deserialize() method to get the same object
+   * back.
+   * @param obj
+   * @returns
+   */
+  static serialize(obj) {
+    return JSONString(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      wrapper_default(obj, (_key, value) => {
+        if (value instanceof Error) {
+          return {
+            dataType: "Error",
+            value: {
+              name: value.name || "Error",
+              message: value.message || "Unknown error",
+              stack: value.stack || void 0
+            }
+          };
+        } else if (value instanceof Map) {
+          return {
+            dataType: "Map",
+            value: Array.from(value.entries())
+            // or with spread: value: [...value]
+          };
+        } else if (value instanceof Set) {
+          return {
+            dataType: "Set",
+            value: [...value]
+          };
+        } else if (value instanceof BigInt) {
+          return {
+            dataType: "BigInt",
+            value: value.toString()
+          };
+        } else if (typeof value == "bigint") {
+          return {
+            dataType: "bigint",
+            value: BigInt(value).toString()
+          };
+        } else {
+          return value;
+        }
+      })
+    );
+  }
+  static deserialize(json) {
+    return ResultAsync2.fromPromise(
+      Promise.resolve(JSON.parse(json)),
+      (e) => ValidationError.fromError(e)
+    ).andThen((parsed) => {
+      const processValue = (value) => {
+        if (typeof value === "object" && value !== null && "dataType" in value && "value" in value) {
+          const dataType = value.dataType;
+          const dataValue = value.value;
+          if (dataType === "Error") {
+            const errorData = dataValue;
+            const error = new Error(errorData.message || "Unknown error");
+            error.name = errorData.name || "Error";
+            if (errorData.stack) {
+              error.stack = errorData.stack;
+            }
+            return error;
+          } else if (dataType === "Map") {
+            return new Map(dataValue);
+          } else if (dataType === "Set") {
+            return new Set(dataValue);
+          } else if (dataType === "BigInt" || dataType === "bigint") {
+            return BigInt(dataValue);
+          }
+        }
+        if (Array.isArray(value)) {
+          return value.map(processValue);
+        } else if (value && typeof value === "object") {
+          const processed2 = {};
+          for (const [key, val] of Object.entries(value)) {
+            processed2[key] = processValue(val);
+          }
+          return processed2;
+        }
+        return value;
+      };
+      const processed = processValue(parsed);
+      return okAsync(processed);
+    });
+  }
+  static deserializeUnsafe(json) {
+    return JSON.parse(json, (_key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (value.dataType === "Error") {
+          const errorData = value.value;
+          const error = new Error(errorData.message || "Unknown error");
+          error.name = errorData.name || "Error";
+          if (errorData.stack) {
+            error.stack = errorData.stack;
+          }
+          return error;
+        } else if (value.dataType === "Map") {
+          return new Map(value.value);
+        } else if (value.dataType === "Set") {
+          return new Set(value.value);
+        } else if (value.dataType === "BigInt") {
+          return BigInt(value.value);
+        } else if (value.dataType === "bigint") {
+          return BigInt(value.value);
+        }
+      }
+      return value;
+    });
+  }
+  /**
+   * This object will convert an object with a Prototype into a generic object. This can be done by nulling the prototype but that's not
+   * really possible in Typescript, so we we do it differently by cloning the object. This means this is also one way of doing a deep
+   * copy of an object, but it will fail and instanceof() check.
+   * @param obj
+   * @returns
+   */
+  static toGenericObject(obj) {
+    return _ObjectUtils.deserialize(_ObjectUtils.serialize(obj));
+  }
+  static removeNullValues(array) {
+    function notEmpty(value) {
+      if (value === null || value === void 0) return false;
+      return true;
+    }
+    return array.filter(notEmpty);
+  }
+  static getEnumKeyByValue(enumObj, value) {
+    return Object.keys(enumObj).find((key) => enumObj[key] === value) || "Undefined";
+  }
+  static getEnumKeyByValueSafely(enumObj, value) {
+    const stringKeys = Object.keys(enumObj).filter((key) => isNaN(Number(key)));
+    for (const key of stringKeys) {
+      if (enumObj[key] === value) {
+        return key;
+      }
+    }
+    return "Undefined";
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static convertBigIntsToStrings(input) {
+    if (typeof input === "bigint") {
+      return input.toString();
+    }
+    if (Array.isArray(input)) {
+      return input.map((i) => {
+        return this.convertBigIntsToStrings(i);
+      });
+    }
+    if (input && typeof input === "object") {
+      const result = {};
+      for (const [key, value] of Object.entries(input)) {
+        result[key] = this.convertBigIntsToStrings(value);
+      }
+      return result;
+    }
+    return input;
+  }
+};
+
+// utils/TimeUtils.ts
+import { injectable } from "inversify";
+var _TimeUtils_decorators, _init;
+_TimeUtils_decorators = [injectable()];
+var TimeUtils = class {
+  lastBlockchainCheck;
+  lastBlockchainTimestamp;
+  constructor() {
+  }
+  getUnixNow() {
+    return UnixTimestamp(Math.floor(Date.now() / 1e3));
+  }
+  getMillisecondNow() {
+    return MillisecondTimestamp(Date.now());
+  }
+  getISO8601TimeString(time = MillisecondTimestamp(Date.now())) {
+    return ISO8601DateString(new Date(time).toISOString());
+  }
+  convertTimestampToISOString(unixTimestamp) {
+    const date = new Date(unixTimestamp * 1e3);
+    return ISO8601DateString(date.toISOString());
+  }
+  convertISOStringToTimestamp(isoString) {
+    const date = new Date(isoString);
+    return UnixTimestamp(Math.floor(date.getTime() / 1e3));
+  }
+  getUnixTodayStart() {
+    const date = /* @__PURE__ */ new Date();
+    date.setHours(0, 0, 0, 0);
+    return UnixTimestamp(Math.floor(date.getTime() / 1e3));
+  }
+  getUnixTodayEnd() {
+    const date = /* @__PURE__ */ new Date();
+    date.setHours(23, 59, 59, 999);
+    return UnixTimestamp(Math.floor(date.getTime() / 1e3));
+  }
+  getStartOfMonth() {
+    const startOfMonth = new Date(
+      (/* @__PURE__ */ new Date()).getFullYear(),
+      (/* @__PURE__ */ new Date()).getMonth(),
+      1
+    ).getTime();
+    return UnixTimestamp(Math.floor(startOfMonth / 1e3));
+  }
+};
+_init = __decoratorStart(null);
+TimeUtils = __decorateElement(_init, 0, "TimeUtils", _TimeUtils_decorators, TimeUtils);
+__runInitializers(_init, 1, TimeUtils);
+
+// utils/x402Utils.ts
+function x402ResolveRequestUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.toString();
+  return input.url;
+}
+function x402Base64EncodeUtf8(input) {
+  if (typeof btoa === "function") {
+    return Base64String(btoa(unescape(encodeURIComponent(input))));
+  }
+  const B = globalThis.Buffer;
+  if (B) {
+    return Base64String(B.from(input, "utf8").toString("base64"));
+  }
+  throw new Error("No base64 encoder available in this environment.");
+}
+function x402Base64DecodeUtf8(input) {
+  if (typeof atob === "function") {
+    return decodeURIComponent(escape(atob(input)));
+  }
+  const B = globalThis.Buffer;
+  if (B) {
+    return B.from(input, "base64").toString("utf8");
+  }
+  throw new Error("No base64 decoder available in this environment.");
+}
+function x402ParseJsonOrBase64Json(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return JSON.parse(trimmed);
+  }
+  try {
+    const decoded = x402Base64DecodeUtf8(Base64String(trimmed));
+    return JSON.parse(decoded);
+  } catch {
+    const unquoted = trimmed.replace(/^"+|"+$/g, "");
+    if (unquoted.startsWith("{") || unquoted.startsWith("[")) {
+      return JSON.parse(unquoted);
+    }
+    const decoded = x402Base64DecodeUtf8(Base64String(unquoted));
+    return JSON.parse(decoded);
+  }
+}
+function x402NormalizeAcceptedPayments(req) {
+  const candidates = [];
+  if (req.accepted != null) {
+    if (Array.isArray(req.accepted)) candidates.push(...req.accepted);
+    else candidates.push(req.accepted);
+  }
+  if (req.paymentRequirements != null) {
+    if (Array.isArray(req.paymentRequirements))
+      candidates.push(...req.paymentRequirements);
+  }
+  return candidates.filter(Boolean).map((c) => c);
+}
+function x402GetChainIdFromNetwork(network) {
+  const m = /^eip155:(\d+)$/.exec(network);
+  if (!m) return null;
+  const n = Number(m[1]);
+  return Number.isFinite(n) ? n : null;
+}
+function x402IsUsdcOnBase(chainId, asset) {
+  const a = asset.toLowerCase();
+  if (chainId === 8453 && a === "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913")
+    return true;
+  return false;
+}
+
+// index.ts
+async function resultAsyncToPromise(resultAsync) {
+  const result = await resultAsync;
+  if (result.isErr()) {
+    throw result.error;
+  }
+  return result.value;
+}
+export {
+  AjaxError,
+  AjaxUtils,
+  ApiToken,
+  Base64String,
+  BaseError,
+  BigNumberString,
+  DecimalAmount,
+  EHttpStatusCode,
+  ELocale,
+  EPayLinkStatus,
+  EVMAccountAddress,
+  EVMContractAddress,
+  HexString,
+  ISO8601DateString,
+  ITimeUtilsType,
+  JSONString,
+  JsonWebToken,
+  MillisecondTimestamp,
+  OAuthTokenModel,
+  ObjectUtils,
+  PayLinkId,
+  PayLinkPaymentId,
+  ProxyError,
+  RelayerTransactionId,
+  RetryError,
+  Signature,
+  TimeUtils,
+  TransactionHash,
+  URLString,
+  USDCAmount,
+  UnixTimestamp,
+  UserId,
+  Username,
+  ValidationError,
+  resultAsyncToPromise,
+  x402Base64DecodeUtf8,
+  x402Base64EncodeUtf8,
+  x402GetChainIdFromNetwork,
+  x402IsUsdcOnBase,
+  x402NormalizeAcceptedPayments,
+  x402ParseJsonOrBase64Json,
+  x402ResolveRequestUrl
+};
+//# sourceMappingURL=index.js.map