@stackframe/stack-shared 2.8.8 → 2.8.11

package/dist/esm/utils/errors.js

@@ -0,0 +1,174 @@
+// src/utils/errors.tsx
+import { globalVar } from "./globals";
+import { pick } from "./objects";
+import { nicify } from "./strings";
+function throwErr(...args) {
+  if (typeof args[0] === "string") {
+    throw new StackAssertionError(args[0], args[1]);
+  } else if (args[0] instanceof Error) {
+    throw args[0];
+  } else {
+    throw new StatusError(...args);
+  }
+}
+function removeStacktraceNameLine(stack) {
+  const addsNameLine = new Error().stack?.startsWith("Error\n");
+  return stack.split("\n").slice(addsNameLine ? 1 : 0).join("\n");
+}
+function concatStacktraces(first, ...errors) {
+  const addsEmptyLineAtEnd = first.stack?.endsWith("\n");
+  const separator = removeStacktraceNameLine(new Error().stack ?? "").split("\n")[0];
+  for (const error of errors) {
+    const toAppend = removeStacktraceNameLine(error.stack ?? "");
+    first.stack += (addsEmptyLineAtEnd ? "" : "\n") + separator + "\n" + toAppend;
+  }
+}
+var StackAssertionError = class extends Error {
+  constructor(message, extraData) {
+    const disclaimer = `
+
+This is likely an error in Stack. Please make sure you are running the newest version and report it.`;
+    super(`${message}${message.endsWith(disclaimer) ? "" : disclaimer}`, pick(extraData ?? {}, ["cause"]));
+    this.extraData = extraData;
+    Object.defineProperty(this, "customCaptureExtraArgs", {
+      get() {
+        return [this.extraData];
+      },
+      enumerable: false
+    });
+  }
+};
+StackAssertionError.prototype.name = "StackAssertionError";
+function errorToNiceString(error) {
+  if (!(error instanceof Error)) return `${typeof error}<${nicify(error)}>`;
+  return nicify(error, { maxDepth: 8 });
+}
+var errorSinks = /* @__PURE__ */ new Set();
+function registerErrorSink(sink) {
+  if (errorSinks.has(sink)) {
+    return;
+  }
+  errorSinks.add(sink);
+}
+registerErrorSink((location, error, ...extraArgs) => {
+  console.error(
+    `\x1B[41mCaptured error in ${location}:`,
+    // HACK: Log a nicified version of the error to get around buggy Next.js pretty-printing
+    // https://www.reddit.com/r/nextjs/comments/1gkxdqe/comment/m19kxgn/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button
+    errorToNiceString(error),
+    ...extraArgs,
+    "\x1B[0m"
+  );
+});
+registerErrorSink((location, error, ...extraArgs) => {
+  globalVar.stackCapturedErrors = globalVar.stackCapturedErrors ?? [];
+  globalVar.stackCapturedErrors.push({ location, error, extraArgs });
+});
+function captureError(location, error) {
+  for (const sink of errorSinks) {
+    sink(
+      location,
+      error,
+      ...error && (typeof error === "object" || typeof error === "function") && "customCaptureExtraArgs" in error && Array.isArray(error.customCaptureExtraArgs) ? error.customCaptureExtraArgs : []
+    );
+  }
+}
+var StatusError = class extends Error {
+  constructor(status, message) {
+    if (typeof status === "object") {
+      message ??= status.message;
+      status = status.statusCode;
+    }
+    super(message);
+    this.name = "StatusError";
+    this.statusCode = status;
+    if (!message) {
+      throw new StackAssertionError("StatusError always requires a message unless a Status object is passed", { cause: this });
+    }
+  }
+  isClientError() {
+    return this.statusCode >= 400 && this.statusCode < 500;
+  }
+  isServerError() {
+    return !this.isClientError();
+  }
+  getStatusCode() {
+    return this.statusCode;
+  }
+  getBody() {
+    return new TextEncoder().encode(this.message);
+  }
+  getHeaders() {
+    return {
+      "Content-Type": ["text/plain; charset=utf-8"]
+    };
+  }
+  toDescriptiveJson() {
+    return {
+      status_code: this.getStatusCode(),
+      message: this.message,
+      headers: this.getHeaders()
+    };
+  }
+  /**
+   * @deprecated this is not a good way to make status errors human-readable, use toDescriptiveJson instead
+   */
+  toHttpJson() {
+    return {
+      status_code: this.statusCode,
+      body: this.message,
+      headers: this.getHeaders()
+    };
+  }
+};
+StatusError.BadRequest = { statusCode: 400, message: "Bad Request" };
+StatusError.Unauthorized = { statusCode: 401, message: "Unauthorized" };
+StatusError.PaymentRequired = { statusCode: 402, message: "Payment Required" };
+StatusError.Forbidden = { statusCode: 403, message: "Forbidden" };
+StatusError.NotFound = { statusCode: 404, message: "Not Found" };
+StatusError.MethodNotAllowed = { statusCode: 405, message: "Method Not Allowed" };
+StatusError.NotAcceptable = { statusCode: 406, message: "Not Acceptable" };
+StatusError.ProxyAuthenticationRequired = { statusCode: 407, message: "Proxy Authentication Required" };
+StatusError.RequestTimeout = { statusCode: 408, message: "Request Timeout" };
+StatusError.Conflict = { statusCode: 409, message: "Conflict" };
+StatusError.Gone = { statusCode: 410, message: "Gone" };
+StatusError.LengthRequired = { statusCode: 411, message: "Length Required" };
+StatusError.PreconditionFailed = { statusCode: 412, message: "Precondition Failed" };
+StatusError.PayloadTooLarge = { statusCode: 413, message: "Payload Too Large" };
+StatusError.URITooLong = { statusCode: 414, message: "URI Too Long" };
+StatusError.UnsupportedMediaType = { statusCode: 415, message: "Unsupported Media Type" };
+StatusError.RangeNotSatisfiable = { statusCode: 416, message: "Range Not Satisfiable" };
+StatusError.ExpectationFailed = { statusCode: 417, message: "Expectation Failed" };
+StatusError.ImATeapot = { statusCode: 418, message: "I'm a teapot" };
+StatusError.MisdirectedRequest = { statusCode: 421, message: "Misdirected Request" };
+StatusError.UnprocessableEntity = { statusCode: 422, message: "Unprocessable Entity" };
+StatusError.Locked = { statusCode: 423, message: "Locked" };
+StatusError.FailedDependency = { statusCode: 424, message: "Failed Dependency" };
+StatusError.TooEarly = { statusCode: 425, message: "Too Early" };
+StatusError.UpgradeRequired = { statusCode: 426, message: "Upgrade Required" };
+StatusError.PreconditionRequired = { statusCode: 428, message: "Precondition Required" };
+StatusError.TooManyRequests = { statusCode: 429, message: "Too Many Requests" };
+StatusError.RequestHeaderFieldsTooLarge = { statusCode: 431, message: "Request Header Fields Too Large" };
+StatusError.UnavailableForLegalReasons = { statusCode: 451, message: "Unavailable For Legal Reasons" };
+StatusError.InternalServerError = { statusCode: 500, message: "Internal Server Error" };
+StatusError.NotImplemented = { statusCode: 501, message: "Not Implemented" };
+StatusError.BadGateway = { statusCode: 502, message: "Bad Gateway" };
+StatusError.ServiceUnavailable = { statusCode: 503, message: "Service Unavailable" };
+StatusError.GatewayTimeout = { statusCode: 504, message: "Gateway Timeout" };
+StatusError.HTTPVersionNotSupported = { statusCode: 505, message: "HTTP Version Not Supported" };
+StatusError.VariantAlsoNegotiates = { statusCode: 506, message: "Variant Also Negotiates" };
+StatusError.InsufficientStorage = { statusCode: 507, message: "Insufficient Storage" };
+StatusError.LoopDetected = { statusCode: 508, message: "Loop Detected" };
+StatusError.NotExtended = { statusCode: 510, message: "Not Extended" };
+StatusError.NetworkAuthenticationRequired = { statusCode: 511, message: "Network Authentication Required" };
+StatusError.prototype.name = "StatusError";
+export {
+  StackAssertionError,
+  StatusError,
+  captureError,
+  concatStacktraces,
+  errorToNiceString,
+  registerErrorSink,
+  throwErr
+};
+//# sourceMappingURL=errors.js.map

package/dist/esm/utils/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/errors.tsx"],"sourcesContent":["import { globalVar } from \"./globals\";\nimport { Json } from \"./json\";\nimport { pick } from \"./objects\";\nimport { nicify } from \"./strings\";\n\n\nexport function throwErr(errorMessage: string, extraData?: any): never;\nexport function throwErr(error: Error): never;\nexport function throwErr(...args: StatusErrorConstructorParameters): never;\nexport function throwErr(...args: any[]): never {\n  if (typeof args[0] === \"string\") {\n    throw new StackAssertionError(args[0], args[1]);\n  } else if (args[0] instanceof Error) {\n    throw args[0];\n  } else {\n    // @ts-expect-error\n    throw new StatusError(...args);\n  }\n}\n\nfunction removeStacktraceNameLine(stack: string): string {\n  // some browsers (eg. Chrome) prepend the stack with an extra line with the error name\n  const addsNameLine = new Error().stack?.startsWith(\"Error\\n\");\n  return stack.split(\"\\n\").slice(addsNameLine ? 1 : 0).join(\"\\n\");\n}\n\n\n/**\n * Concatenates the (original) stacktraces of the given errors onto the first.\n *\n * Useful when you invoke an async function to receive a promise without awaiting it immediately. Browsers are smart\n * enough to keep track of the call stack in async function calls when you invoke `.then` within the same async tick,\n * but if you don't, the stacktrace will be lost.\n *\n * Here's an example of the unwanted behavior:\n *\n * ```tsx\n * async function log() {\n *   await wait(0);  // simulate an put the task on the event loop\n *   console.log(new Error().stack);\n * }\n *\n * async function main() {\n *   await log();  // good; prints both \"log\" and \"main\" on the stacktrace\n *   log();  // bad; prints only \"log\" on the stacktrace\n * }\n * ```\n */\nexport function concatStacktraces(first: Error, ...errors: Error[]): void {\n  // some browsers (eg. Firefox) add an extra empty line at the end\n  const addsEmptyLineAtEnd = first.stack?.endsWith(\"\\n\");\n\n\n  // Add a reference to this function itself so that we know that stacktraces were concatenated\n  // If you are coming here from a stacktrace, please know that the two parts before and after this line are different\n  // stacktraces that were concatenated with concatStacktraces\n  const separator = removeStacktraceNameLine(new Error().stack ?? \"\").split(\"\\n\")[0];\n\n\n  for (const error of errors) {\n    const toAppend = removeStacktraceNameLine(error.stack ?? \"\");\n    first.stack += (addsEmptyLineAtEnd ? \"\" : \"\\n\") + separator + \"\\n\" + toAppend;\n  }\n}\n\n\nexport class StackAssertionError extends Error {\n  constructor(message: string, public readonly extraData?: Record<string, any> & ErrorOptions) {\n    const disclaimer = `\\n\\nThis is likely an error in Stack. Please make sure you are running the newest version and report it.`;\n    super(`${message}${message.endsWith(disclaimer) ? \"\" : disclaimer}`, pick(extraData ?? {}, [\"cause\"]));\n\n    Object.defineProperty(this, \"customCaptureExtraArgs\", {\n      get() {\n        return [this.extraData];\n      },\n      enumerable: false,\n    });\n  }\n}\nStackAssertionError.prototype.name = \"StackAssertionError\";\n\n\nexport function errorToNiceString(error: unknown): string {\n  if (!(error instanceof Error)) return `${typeof error}<${nicify(error)}>`;\n  return nicify(error, { maxDepth: 8 });\n}\n\n\nconst errorSinks = new Set<(location: string, error: unknown, ...extraArgs: unknown[]) => void>();\nexport function registerErrorSink(sink: (location: string, error: unknown) => void): void {\n  if (errorSinks.has(sink)) {\n    return;\n  }\n  errorSinks.add(sink);\n}\nregisterErrorSink((location, error, ...extraArgs) => {\n  console.error(\n    `\\x1b[41mCaptured error in ${location}:`,\n    // HACK: Log a nicified version of the error to get around buggy Next.js pretty-printing\n    // https://www.reddit.com/r/nextjs/comments/1gkxdqe/comment/m19kxgn/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button\n    errorToNiceString(error),\n    ...extraArgs,\n    \"\\x1b[0m\",\n  );\n});\nregisterErrorSink((location, error, ...extraArgs) => {\n  globalVar.stackCapturedErrors = globalVar.stackCapturedErrors ?? [];\n  globalVar.stackCapturedErrors.push({ location, error, extraArgs });\n});\n\nexport function captureError(location: string, error: unknown): void {\n  for (const sink of errorSinks) {\n    sink(\n      location,\n      error,\n      ...error && (typeof error === 'object' || typeof error === 'function') && \"customCaptureExtraArgs\" in error && Array.isArray(error.customCaptureExtraArgs) ? (error.customCaptureExtraArgs as any[]) : [],\n    );\n  }\n}\n\n\ntype Status = {\n  statusCode: number,\n  message: string,\n};\n\ntype StatusErrorConstructorParameters =\n| [\n  status: Status,\n  message?: string\n]\n| [\n  statusCode: number | Status,\n  message: string,\n];\n\nexport class StatusError extends Error {\n  public name = \"StatusError\";\n  public readonly statusCode: number;\n\n  public static BadRequest = { statusCode: 400, message: \"Bad Request\" };\n  public static Unauthorized = { statusCode: 401, message: \"Unauthorized\" };\n  public static PaymentRequired = { statusCode: 402, message: \"Payment Required\" };\n  public static Forbidden = { statusCode: 403, message: \"Forbidden\" };\n  public static NotFound = { statusCode: 404, message: \"Not Found\" };\n  public static MethodNotAllowed = { statusCode: 405, message: \"Method Not Allowed\" };\n  public static NotAcceptable = { statusCode: 406, message: \"Not Acceptable\" };\n  public static ProxyAuthenticationRequired = { statusCode: 407, message: \"Proxy Authentication Required\" };\n  public static RequestTimeout = { statusCode: 408, message: \"Request Timeout\" };\n  public static Conflict = { statusCode: 409, message: \"Conflict\" };\n  public static Gone = { statusCode: 410, message: \"Gone\" };\n  public static LengthRequired = { statusCode: 411, message: \"Length Required\" };\n  public static PreconditionFailed = { statusCode: 412, message: \"Precondition Failed\" };\n  public static PayloadTooLarge = { statusCode: 413, message: \"Payload Too Large\" };\n  public static URITooLong = { statusCode: 414, message: \"URI Too Long\" };\n  public static UnsupportedMediaType = { statusCode: 415, message: \"Unsupported Media Type\" };\n  public static RangeNotSatisfiable = { statusCode: 416, message: \"Range Not Satisfiable\" };\n  public static ExpectationFailed = { statusCode: 417, message: \"Expectation Failed\" };\n  public static ImATeapot = { statusCode: 418, message: \"I'm a teapot\" };\n  public static MisdirectedRequest = { statusCode: 421, message: \"Misdirected Request\" };\n  public static UnprocessableEntity = { statusCode: 422, message: \"Unprocessable Entity\" };\n  public static Locked = { statusCode: 423, message: \"Locked\" };\n  public static FailedDependency = { statusCode: 424, message: \"Failed Dependency\" };\n  public static TooEarly = { statusCode: 425, message: \"Too Early\" };\n  public static UpgradeRequired = { statusCode: 426, message: \"Upgrade Required\" };\n  public static PreconditionRequired = { statusCode: 428, message: \"Precondition Required\" };\n  public static TooManyRequests = { statusCode: 429, message: \"Too Many Requests\" };\n  public static RequestHeaderFieldsTooLarge = { statusCode: 431, message: \"Request Header Fields Too Large\" };\n  public static UnavailableForLegalReasons = { statusCode: 451, message: \"Unavailable For Legal Reasons\" };\n\n  public static InternalServerError = { statusCode: 500, message: \"Internal Server Error\" };\n  public static NotImplemented = { statusCode: 501, message: \"Not Implemented\" };\n  public static BadGateway = { statusCode: 502, message: \"Bad Gateway\" };\n  public static ServiceUnavailable = { statusCode: 503, message: \"Service Unavailable\" };\n  public static GatewayTimeout = { statusCode: 504, message: \"Gateway Timeout\" };\n  public static HTTPVersionNotSupported = { statusCode: 505, message: \"HTTP Version Not Supported\" };\n  public static VariantAlsoNegotiates = { statusCode: 506, message: \"Variant Also Negotiates\" };\n  public static InsufficientStorage = { statusCode: 507, message: \"Insufficient Storage\" };\n  public static LoopDetected = { statusCode: 508, message: \"Loop Detected\" };\n  public static NotExtended = { statusCode: 510, message: \"Not Extended\" };\n  public static NetworkAuthenticationRequired = { statusCode: 511, message: \"Network Authentication Required\" };\n\n\n  constructor(...args: StatusErrorConstructorParameters);\n  constructor(\n    status: number | Status,\n    message?: string,\n  ) {\n    if (typeof status === \"object\") {\n      message ??= status.message;\n      status = status.statusCode;\n    }\n    super(message);\n    this.statusCode = status;\n    if (!message) {\n      throw new StackAssertionError(\"StatusError always requires a message unless a Status object is passed\", { cause: this });\n    }\n  }\n\n  public isClientError() {\n    return this.statusCode >= 400 && this.statusCode < 500;\n  }\n\n  public isServerError() {\n    return !this.isClientError();\n  }\n\n  public getStatusCode(): number {\n    return this.statusCode;\n  }\n\n  public getBody(): Uint8Array {\n    return new TextEncoder().encode(this.message);\n  }\n\n  public getHeaders(): Record<string, string[]> {\n    return {\n      \"Content-Type\": [\"text/plain; charset=utf-8\"],\n    };\n  }\n\n  public toDescriptiveJson(): Json {\n    return {\n      status_code: this.getStatusCode(),\n      message: this.message,\n      headers: this.getHeaders(),\n    };\n  }\n\n  /**\n   * @deprecated this is not a good way to make status errors human-readable, use toDescriptiveJson instead\n   */\n  public toHttpJson(): Json {\n    return {\n      status_code: this.statusCode,\n      body: this.message,\n      headers: this.getHeaders(),\n    };\n  }\n}\nStatusError.prototype.name = \"StatusError\";\n"],"mappings":"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","names":[]}

package/dist/esm/utils/fs.js

@@ -0,0 +1,37 @@
+// src/utils/fs.tsx
+import * as stackFs from "fs";
+import * as path from "path";
+async function list(path2) {
+  return await stackFs.promises.readdir(path2);
+}
+async function listRecursively(p, options = {}) {
+  const files = await list(p);
+  return [
+    ...(await Promise.all(files.map(async (fileName) => {
+      const filePath = path.join(p, fileName);
+      if ((await stackFs.promises.stat(filePath)).isDirectory()) {
+        return [
+          ...await listRecursively(filePath, options),
+          ...options.excludeDirectories ? [] : [filePath]
+        ];
+      } else {
+        return [filePath];
+      }
+    }))).flat()
+  ];
+}
+function writeFileSyncIfChanged(path2, content) {
+  if (stackFs.existsSync(path2)) {
+    const existingContent = stackFs.readFileSync(path2, "utf-8");
+    if (existingContent === content) {
+      return;
+    }
+  }
+  stackFs.writeFileSync(path2, content);
+}
+export {
+  list,
+  listRecursively,
+  writeFileSyncIfChanged
+};
+//# sourceMappingURL=fs.js.map

package/dist/esm/utils/fs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/fs.tsx"],"sourcesContent":["import * as stackFs from \"fs\";\nimport * as path from \"path\";\n\nexport async function list(path: string) {\n  return await stackFs.promises.readdir(path);\n}\n\nexport async function listRecursively(p: string, options: { excludeDirectories?: boolean } = {}): Promise<string[]> {\n  const files = await list(p);\n  return [\n    ...(await Promise.all(files.map(async (fileName) => {\n      const filePath = path.join(p, fileName);\n      if ((await stackFs.promises.stat(filePath)).isDirectory()) {\n        return [\n          ...(await listRecursively(filePath, options)),\n          ...(options.excludeDirectories ? [] : [filePath]),\n        ];\n      } else {\n        return [filePath];\n      }\n    }))).flat(),\n  ];\n}\n\nexport function writeFileSyncIfChanged(path: string, content: string): void {\n  if (stackFs.existsSync(path)) {\n    const existingContent = stackFs.readFileSync(path, \"utf-8\");\n    if (existingContent === content) {\n      return;\n    }\n  }\n  stackFs.writeFileSync(path, content);\n}\n"],"mappings":";AAAA,YAAY,aAAa;AACzB,YAAY,UAAU;AAEtB,eAAsB,KAAKA,OAAc;AACvC,SAAO,MAAc,iBAAS,QAAQA,KAAI;AAC5C;AAEA,eAAsB,gBAAgB,GAAW,UAA4C,CAAC,GAAsB;AAClH,QAAM,QAAQ,MAAM,KAAK,CAAC;AAC1B,SAAO;AAAA,IACL,IAAI,MAAM,QAAQ,IAAI,MAAM,IAAI,OAAO,aAAa;AAClD,YAAM,WAAgB,UAAK,GAAG,QAAQ;AACtC,WAAK,MAAc,iBAAS,KAAK,QAAQ,GAAG,YAAY,GAAG;AACzD,eAAO;AAAA,UACL,GAAI,MAAM,gBAAgB,UAAU,OAAO;AAAA,UAC3C,GAAI,QAAQ,qBAAqB,CAAC,IAAI,CAAC,QAAQ;AAAA,QACjD;AAAA,MACF,OAAO;AACL,eAAO,CAAC,QAAQ;AAAA,MAClB;AAAA,IACF,CAAC,CAAC,GAAG,KAAK;AAAA,EACZ;AACF;AAEO,SAAS,uBAAuBA,OAAc,SAAuB;AAC1E,MAAY,mBAAWA,KAAI,GAAG;AAC5B,UAAM,kBAA0B,qBAAaA,OAAM,OAAO;AAC1D,QAAI,oBAAoB,SAAS;AAC/B;AAAA,IACF;AAAA,EACF;AACA,EAAQ,sBAAcA,OAAM,OAAO;AACrC;","names":["path"]}

package/dist/esm/utils/functions.js

@@ -0,0 +1,12 @@
+// src/utils/functions.tsx
+function identity(t) {
+  return t;
+}
+function identityArgs(...args) {
+  return args;
+}
+export {
+  identity,
+  identityArgs
+};
+//# sourceMappingURL=functions.js.map

package/dist/esm/utils/functions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/functions.tsx"],"sourcesContent":["export function identity<T>(t: T): T {\n  return t;\n}\nundefined?.test(\"identity\", ({ expect }) => {\n  expect(identity(1)).toBe(1);\n  expect(identity(\"test\")).toBe(\"test\");\n  expect(identity(null)).toBe(null);\n  expect(identity(undefined)).toBe(undefined);\n  const obj = { a: 1 };\n  expect(identity(obj)).toBe(obj);\n});\n\nexport function identityArgs<T extends any[]>(...args: T): T {\n  return args;\n}\nundefined?.test(\"identityArgs\", ({ expect }) => {\n  expect(identityArgs()).toEqual([]);\n  expect(identityArgs(1)).toEqual([1]);\n  expect(identityArgs(1, 2, 3)).toEqual([1, 2, 3]);\n  expect(identityArgs(\"a\", \"b\", \"c\")).toEqual([\"a\", \"b\", \"c\"]);\n  expect(identityArgs(null, undefined)).toEqual([null, undefined]);\n});\n"],"mappings":";AAAO,SAAS,SAAY,GAAS;AACnC,SAAO;AACT;AAUO,SAAS,gBAAiC,MAAY;AAC3D,SAAO;AACT;","names":[]}

package/dist/esm/utils/geo.js

@@ -0,0 +1,15 @@
+// src/utils/geo.tsx
+import { yupNumber, yupObject, yupString } from "../schema-fields";
+var geoInfoSchema = yupObject({
+  ip: yupString().defined(),
+  countryCode: yupString().nullable(),
+  regionCode: yupString().nullable(),
+  cityName: yupString().nullable(),
+  latitude: yupNumber().nullable(),
+  longitude: yupNumber().nullable(),
+  tzIdentifier: yupString().nullable()
+});
+export {
+  geoInfoSchema
+};
+//# sourceMappingURL=geo.js.map

package/dist/esm/utils/geo.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/geo.tsx"],"sourcesContent":["\nimport * as yup from \"yup\";\nimport { yupNumber, yupObject, yupString } from \"../schema-fields\";\n\nexport const geoInfoSchema = yupObject({\n  ip: yupString().defined(),\n  countryCode: yupString().nullable(),\n  regionCode: yupString().nullable(),\n  cityName: yupString().nullable(),\n  latitude: yupNumber().nullable(),\n  longitude: yupNumber().nullable(),\n  tzIdentifier: yupString().nullable(),\n});\n\nexport type GeoInfo = yup.InferType<typeof geoInfoSchema>;\n\n"],"mappings":";AAEA,SAAS,WAAW,WAAW,iBAAiB;AAEzC,IAAM,gBAAgB,UAAU;AAAA,EACrC,IAAI,UAAU,EAAE,QAAQ;AAAA,EACxB,aAAa,UAAU,EAAE,SAAS;AAAA,EAClC,YAAY,UAAU,EAAE,SAAS;AAAA,EACjC,UAAU,UAAU,EAAE,SAAS;AAAA,EAC/B,UAAU,UAAU,EAAE,SAAS;AAAA,EAC/B,WAAW,UAAU,EAAE,SAAS;AAAA,EAChC,cAAc,UAAU,EAAE,SAAS;AACrC,CAAC;","names":[]}

package/dist/esm/utils/globals.js

@@ -0,0 +1,18 @@
+// src/utils/globals.tsx
+var globalVar = typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {};
+if (typeof globalThis === "undefined") {
+  globalVar.globalThis = globalVar;
+}
+var stackGlobalsSymbol = Symbol.for("__stack-globals");
+globalVar[stackGlobalsSymbol] ??= {};
+function createGlobal(key, init) {
+  if (!globalVar[stackGlobalsSymbol][key]) {
+    globalVar[stackGlobalsSymbol][key] = init();
+  }
+  return globalVar[stackGlobalsSymbol][key];
+}
+export {
+  createGlobal,
+  globalVar
+};
+//# sourceMappingURL=globals.js.map

package/dist/esm/utils/globals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/globals.tsx"],"sourcesContent":["const globalVar: any =\n  typeof globalThis !== 'undefined' ? globalThis :\n    typeof global !== 'undefined' ? global :\n      typeof window !== 'undefined' ? window :\n        typeof self !== 'undefined' ? self :\n          {};\nexport {\n  globalVar,\n};\n\nif (typeof globalThis === 'undefined') {\n  (globalVar as any).globalThis = globalVar;\n}\n\nconst stackGlobalsSymbol = Symbol.for('__stack-globals');\nglobalVar[stackGlobalsSymbol] ??= {};\n\nexport function createGlobal<T>(key: string, init: () => T) {\n  if (!globalVar[stackGlobalsSymbol][key]) {\n    globalVar[stackGlobalsSymbol][key] = init();\n  }\n  return globalVar[stackGlobalsSymbol][key] as T;\n}\n"],"mappings":";AAAA,IAAM,YACJ,OAAO,eAAe,cAAc,aAClC,OAAO,WAAW,cAAc,SAC9B,OAAO,WAAW,cAAc,SAC9B,OAAO,SAAS,cAAc,OAC5B,CAAC;AAKX,IAAI,OAAO,eAAe,aAAa;AACrC,EAAC,UAAkB,aAAa;AAClC;AAEA,IAAM,qBAAqB,OAAO,IAAI,iBAAiB;AACvD,UAAU,kBAAkB,MAAM,CAAC;AAE5B,SAAS,aAAgB,KAAa,MAAe;AAC1D,MAAI,CAAC,UAAU,kBAAkB,EAAE,GAAG,GAAG;AACvC,cAAU,kBAAkB,EAAE,GAAG,IAAI,KAAK;AAAA,EAC5C;AACA,SAAO,UAAU,kBAAkB,EAAE,GAAG;AAC1C;","names":[]}

package/dist/esm/utils/hashes.js

@@ -0,0 +1,55 @@
+// src/utils/hashes.tsx
+import bcrypt from "bcrypt";
+import { StackAssertionError } from "./errors";
+async function sha512(input) {
+  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  return new Uint8Array(await crypto.subtle.digest("SHA-512", bytes));
+}
+async function hashPassword(password) {
+  const passwordBytes = new TextEncoder().encode(password);
+  if (passwordBytes.length >= 72) {
+    throw new StackAssertionError(`Password is too long for bcrypt`, { len: passwordBytes.length });
+  }
+  const salt = await bcrypt.genSalt(10);
+  return await bcrypt.hash(password, salt);
+}
+async function comparePassword(password, hash) {
+  switch (await getPasswordHashAlgorithm(hash)) {
+    case "bcrypt": {
+      return await bcrypt.compare(password, hash);
+    }
+    default: {
+      return false;
+    }
+  }
+}
+async function isPasswordHashValid(hash) {
+  return !!await getPasswordHashAlgorithm(hash);
+}
+async function getPasswordHashAlgorithm(hash) {
+  if (typeof hash !== "string") {
+    throw new StackAssertionError(`Passed non-string value to getPasswordHashAlgorithm`, { hash });
+  }
+  if (hash.match(/^\$2[ayb]\$.{56}$/)) {
+    try {
+      if (bcrypt.getRounds(hash) > 16) {
+        return void 0;
+      }
+      await bcrypt.compare("any string", hash);
+      return "bcrypt";
+    } catch (e) {
+      console.warn(`Error while checking bcrypt password hash. Assuming the hash is invalid`, e);
+      return void 0;
+    }
+  } else {
+    return void 0;
+  }
+}
+export {
+  comparePassword,
+  getPasswordHashAlgorithm,
+  hashPassword,
+  isPasswordHashValid,
+  sha512
+};
+//# sourceMappingURL=hashes.js.map

package/dist/esm/utils/hashes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/hashes.tsx"],"sourcesContent":["import bcrypt from 'bcrypt';\nimport { StackAssertionError } from './errors';\n\nexport async function sha512(input: Uint8Array | string): Promise<Uint8Array> {\n  const bytes = typeof input === \"string\" ? new TextEncoder().encode(input) : input;\n  return new Uint8Array(await crypto.subtle.digest(\"SHA-512\", bytes));\n}\n\nexport async function hashPassword(password: string) {\n  const passwordBytes = new TextEncoder().encode(password);\n  if (passwordBytes.length >= 72) {\n    throw new StackAssertionError(`Password is too long for bcrypt`, { len: passwordBytes.length });\n  }\n  const salt = await bcrypt.genSalt(10);\n  return await bcrypt.hash(password, salt);\n}\n\nexport async function comparePassword(password: string, hash: string): Promise<boolean> {\n  switch (await getPasswordHashAlgorithm(hash)) {\n    case \"bcrypt\": {\n      return await bcrypt.compare(password, hash);\n    }\n    default: {\n      return false;\n    }\n  }\n}\n\nexport async function isPasswordHashValid(hash: string) {\n  return !!(await getPasswordHashAlgorithm(hash));\n}\n\nexport async function getPasswordHashAlgorithm(hash: string): Promise<\"bcrypt\" | undefined> {\n  if (typeof hash !== \"string\") {\n    throw new StackAssertionError(`Passed non-string value to getPasswordHashAlgorithm`, { hash });\n  }\n  if (hash.match(/^\\$2[ayb]\\$.{56}$/)) {\n    try {\n      if (bcrypt.getRounds(hash) > 16) {\n        return undefined;\n      }\n      await bcrypt.compare(\"any string\", hash);\n      return \"bcrypt\";\n    } catch (e) {\n      console.warn(`Error while checking bcrypt password hash. Assuming the hash is invalid`, e);\n      return undefined;\n    }\n  } else {\n    return undefined;\n  }\n}\n"],"mappings":";AAAA,OAAO,YAAY;AACnB,SAAS,2BAA2B;AAEpC,eAAsB,OAAO,OAAiD;AAC5E,QAAM,QAAQ,OAAO,UAAU,WAAW,IAAI,YAAY,EAAE,OAAO,KAAK,IAAI;AAC5E,SAAO,IAAI,WAAW,MAAM,OAAO,OAAO,OAAO,WAAW,KAAK,CAAC;AACpE;AAEA,eAAsB,aAAa,UAAkB;AACnD,QAAM,gBAAgB,IAAI,YAAY,EAAE,OAAO,QAAQ;AACvD,MAAI,cAAc,UAAU,IAAI;AAC9B,UAAM,IAAI,oBAAoB,mCAAmC,EAAE,KAAK,cAAc,OAAO,CAAC;AAAA,EAChG;AACA,QAAM,OAAO,MAAM,OAAO,QAAQ,EAAE;AACpC,SAAO,MAAM,OAAO,KAAK,UAAU,IAAI;AACzC;AAEA,eAAsB,gBAAgB,UAAkB,MAAgC;AACtF,UAAQ,MAAM,yBAAyB,IAAI,GAAG;AAAA,IAC5C,KAAK,UAAU;AACb,aAAO,MAAM,OAAO,QAAQ,UAAU,IAAI;AAAA,IAC5C;AAAA,IACA,SAAS;AACP,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAEA,eAAsB,oBAAoB,MAAc;AACtD,SAAO,CAAC,CAAE,MAAM,yBAAyB,IAAI;AAC/C;AAEA,eAAsB,yBAAyB,MAA6C;AAC1F,MAAI,OAAO,SAAS,UAAU;AAC5B,UAAM,IAAI,oBAAoB,uDAAuD,EAAE,KAAK,CAAC;AAAA,EAC/F;AACA,MAAI,KAAK,MAAM,mBAAmB,GAAG;AACnC,QAAI;AACF,UAAI,OAAO,UAAU,IAAI,IAAI,IAAI;AAC/B,eAAO;AAAA,MACT;AACA,YAAM,OAAO,QAAQ,cAAc,IAAI;AACvC,aAAO;AAAA,IACT,SAAS,GAAG;AACV,cAAQ,KAAK,2EAA2E,CAAC;AACzF,aAAO;AAAA,IACT;AAAA,EACF,OAAO;AACL,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/esm/utils/html.js

@@ -0,0 +1,13 @@
+// src/utils/html.tsx
+import { templateIdentity } from "./strings";
+function escapeHtml(unsafe) {
+  return `${unsafe}`.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function html(strings, ...values) {
+  return templateIdentity(strings, ...values.map((v) => escapeHtml(`${v}`)));
+}
+export {
+  escapeHtml,
+  html
+};
+//# sourceMappingURL=html.js.map

package/dist/esm/utils/html.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/html.tsx"],"sourcesContent":["import { templateIdentity } from \"./strings\";\n\nexport function escapeHtml(unsafe: string): string {\n  return `${unsafe}`\n    .replace(/&/g, '&amp;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\"/g, \"&quot;\")\n    .replace(/'/g, \"&#039;\");\n}\nundefined?.test(\"escapeHtml\", ({ expect }) => {\n  // Test with empty string\n  expect(escapeHtml(\"\")).toBe(\"\");\n\n  // Test with string without special characters\n  expect(escapeHtml(\"hello world\")).toBe(\"hello world\");\n\n  // Test with special characters\n  expect(escapeHtml(\"<div>\")).toBe(\"&lt;div&gt;\");\n  expect(escapeHtml(\"a & b\")).toBe(\"a &amp; b\");\n  expect(escapeHtml('a \"quoted\" string')).toBe(\"a &quot;quoted&quot; string\");\n  expect(escapeHtml(\"it's a test\")).toBe(\"it&#039;s a test\");\n\n  // Test with multiple special characters\n  expect(escapeHtml(\"<a href=\\\"test\\\">It's a link</a>\")).toBe(\n    \"&lt;a href=&quot;test&quot;&gt;It&#039;s a link&lt;/a&gt;\"\n  );\n});\n\nexport function html(strings: TemplateStringsArray, ...values: any[]): string {\n  return templateIdentity(strings, ...values.map(v => escapeHtml(`${v}`)));\n}\nundefined?.test(\"html\", ({ expect }) => {\n  // Test with no interpolation\n  expect(html`simple string`).toBe(\"simple string\");\n\n  // Test with string interpolation\n  expect(html`Hello, ${\"world\"}!`).toBe(\"Hello, world!\");\n\n  // Test with number interpolation\n  expect(html`Count: ${42}`).toBe(\"Count: 42\");\n\n  // Test with HTML special characters in interpolated values\n  expect(html`<div>${\"<script>\"}</div>`).toBe(\"<div>&lt;script&gt;</div>\");\n\n  // Test with multiple interpolations\n  expect(html`${1} + ${2} = ${\"<3\"}`).toBe(\"1 + 2 = &lt;3\");\n\n  // Test with object interpolation\n  const obj = { toString: () => \"<object>\" };\n  expect(html`Object: ${obj}`).toBe(\"Object: &lt;object&gt;\");\n});\n"],"mappings":";AAAA,SAAS,wBAAwB;AAE1B,SAAS,WAAW,QAAwB;AACjD,SAAO,GAAG,MAAM,GACb,QAAQ,MAAM,OAAO,EACrB,QAAQ,MAAM,MAAM,EACpB,QAAQ,MAAM,MAAM,EACpB,QAAQ,MAAM,QAAQ,EACtB,QAAQ,MAAM,QAAQ;AAC3B;AAoBO,SAAS,KAAK,YAAkC,QAAuB;AAC5E,SAAO,iBAAiB,SAAS,GAAG,OAAO,IAAI,OAAK,WAAW,GAAG,CAAC,EAAE,CAAC,CAAC;AACzE;","names":[]}

package/dist/esm/utils/http.js

@@ -0,0 +1,60 @@
+// src/utils/http.tsx
+import { decodeBase64, encodeBase64, isBase64 } from "./bytes";
+var HTTP_METHODS = {
+  "GET": {
+    safe: true,
+    idempotent: true
+  },
+  "POST": {
+    safe: false,
+    idempotent: false
+  },
+  "PUT": {
+    safe: false,
+    idempotent: true
+  },
+  "DELETE": {
+    safe: false,
+    idempotent: true
+  },
+  "PATCH": {
+    safe: false,
+    idempotent: false
+  },
+  "OPTIONS": {
+    safe: true,
+    idempotent: true
+  },
+  "HEAD": {
+    safe: true,
+    idempotent: true
+  },
+  "TRACE": {
+    safe: true,
+    idempotent: true
+  },
+  "CONNECT": {
+    safe: false,
+    idempotent: false
+  }
+};
+function decodeBasicAuthorizationHeader(value) {
+  const [type, encoded, ...rest] = value.split(" ");
+  if (rest.length > 0) return null;
+  if (!encoded) return null;
+  if (type !== "Basic") return null;
+  if (!isBase64(encoded)) return null;
+  const decoded = new TextDecoder().decode(decodeBase64(encoded));
+  const split = decoded.split(":");
+  return [split[0], split.slice(1).join(":")];
+}
+function encodeBasicAuthorizationHeader(id, password) {
+  if (id.includes(":")) throw new Error("Basic authorization header id cannot contain ':'");
+  return `Basic ${encodeBase64(new TextEncoder().encode(`${id}:${password}`))}`;
+}
+export {
+  HTTP_METHODS,
+  decodeBasicAuthorizationHeader,
+  encodeBasicAuthorizationHeader
+};
+//# sourceMappingURL=http.js.map

package/dist/esm/utils/http.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/http.tsx"],"sourcesContent":["import { decodeBase64, encodeBase64, isBase64 } from \"./bytes\";\n\nexport const HTTP_METHODS = {\n  \"GET\": {\n    safe: true,\n    idempotent: true,\n  },\n  \"POST\": {\n    safe: false,\n    idempotent: false,\n  },\n  \"PUT\": {\n    safe: false,\n    idempotent: true,\n  },\n  \"DELETE\": {\n    safe: false,\n    idempotent: true,\n  },\n  \"PATCH\": {\n    safe: false,\n    idempotent: false,\n  },\n  \"OPTIONS\": {\n    safe: true,\n    idempotent: true,\n  },\n  \"HEAD\": {\n    safe: true,\n    idempotent: true,\n  },\n  \"TRACE\": {\n    safe: true,\n    idempotent: true,\n  },\n  \"CONNECT\": {\n    safe: false,\n    idempotent: false,\n  },\n} as const;\nexport type HttpMethod = keyof typeof HTTP_METHODS;\n\nexport function decodeBasicAuthorizationHeader(value: string): [string, string] | null {\n  const [type, encoded, ...rest] = value.split(' ');\n  if (rest.length > 0) return null;\n  if (!encoded) return null;\n  if (type !== 'Basic') return null;\n  if (!isBase64(encoded)) return null;\n  const decoded = new TextDecoder().decode(decodeBase64(encoded));\n  const split = decoded.split(':');\n  return [split[0], split.slice(1).join(':')];\n}\nundefined?.test(\"decodeBasicAuthorizationHeader\", ({ expect }) => {\n  // Test with valid Basic Authorization header\n  const username = \"user\";\n  const password = \"pass\";\n  const encoded = encodeBasicAuthorizationHeader(username, password);\n  expect(decodeBasicAuthorizationHeader(encoded)).toEqual([username, password]);\n\n  // Test with password containing colons\n  const complexPassword = \"pass:with:colons\";\n  const encodedComplex = encodeBasicAuthorizationHeader(username, complexPassword);\n  expect(decodeBasicAuthorizationHeader(encodedComplex)).toEqual([username, complexPassword]);\n\n  // Test with invalid headers\n  expect(decodeBasicAuthorizationHeader(\"NotBasic dXNlcjpwYXNz\")).toBe(null); // Wrong type\n  expect(decodeBasicAuthorizationHeader(\"Basic\")).toBe(null); // Missing encoded part\n  expect(decodeBasicAuthorizationHeader(\"Basic not-base64\")).toBe(null); // Not base64\n  expect(decodeBasicAuthorizationHeader(\"Basic dXNlcjpwYXNz extra\")).toBe(null); // Extra parts\n});\n\nexport function encodeBasicAuthorizationHeader(id: string, password: string): string {\n  if (id.includes(':')) throw new Error(\"Basic authorization header id cannot contain ':'\");\n  return `Basic ${encodeBase64(new TextEncoder().encode(`${id}:${password}`))}`;\n}\nundefined?.test(\"encodeBasicAuthorizationHeader\", ({ expect }) => {\n  // Test with simple username and password\n  const encoded = encodeBasicAuthorizationHeader(\"user\", \"pass\");\n  expect(encoded).toMatch(/^Basic [A-Za-z0-9+/=]+$/); // Should start with \"Basic \" followed by base64\n\n  // Test with empty password\n  const encodedEmptyPass = encodeBasicAuthorizationHeader(\"user\", \"\");\n  expect(encodedEmptyPass).toMatch(/^Basic [A-Za-z0-9+/=]+$/);\n\n  // Test with password containing special characters\n  const encodedSpecialChars = encodeBasicAuthorizationHeader(\"user\", \"p@ss!w0rd\");\n  expect(encodedSpecialChars).toMatch(/^Basic [A-Za-z0-9+/=]+$/);\n\n  // Test with username containing colon should throw\n  expect(() => encodeBasicAuthorizationHeader(\"user:name\", \"pass\")).toThrow();\n});\n"],"mappings":";AAAA,SAAS,cAAc,cAAc,gBAAgB;AAE9C,IAAM,eAAe;AAAA,EAC1B,OAAO;AAAA,IACL,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,QAAQ;AAAA,IACN,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,UAAU;AAAA,IACR,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,SAAS;AAAA,IACP,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,WAAW;AAAA,IACT,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,QAAQ;AAAA,IACN,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,SAAS;AAAA,IACP,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AAAA,EACA,WAAW;AAAA,IACT,MAAM;AAAA,IACN,YAAY;AAAA,EACd;AACF;AAGO,SAAS,+BAA+B,OAAwC;AACrF,QAAM,CAAC,MAAM,SAAS,GAAG,IAAI,IAAI,MAAM,MAAM,GAAG;AAChD,MAAI,KAAK,SAAS,EAAG,QAAO;AAC5B,MAAI,CAAC,QAAS,QAAO;AACrB,MAAI,SAAS,QAAS,QAAO;AAC7B,MAAI,CAAC,SAAS,OAAO,EAAG,QAAO;AAC/B,QAAM,UAAU,IAAI,YAAY,EAAE,OAAO,aAAa,OAAO,CAAC;AAC9D,QAAM,QAAQ,QAAQ,MAAM,GAAG;AAC/B,SAAO,CAAC,MAAM,CAAC,GAAG,MAAM,MAAM,CAAC,EAAE,KAAK,GAAG,CAAC;AAC5C;AAoBO,SAAS,+BAA+B,IAAY,UAA0B;AACnF,MAAI,GAAG,SAAS,GAAG,EAAG,OAAM,IAAI,MAAM,kDAAkD;AACxF,SAAO,SAAS,aAAa,IAAI,YAAY,EAAE,OAAO,GAAG,EAAE,IAAI,QAAQ,EAAE,CAAC,CAAC;AAC7E;","names":[]}

package/dist/esm/utils/ips.js

@@ -0,0 +1,15 @@
+// src/utils/ips.tsx
+import ipRegex from "ip-regex";
+function isIpAddress(ip) {
+  return ipRegex({ exact: true }).test(ip);
+}
+function assertIpAddress(ip) {
+  if (!isIpAddress(ip)) {
+    throw new Error(`Invalid IP address: ${ip}`);
+  }
+}
+export {
+  assertIpAddress,
+  isIpAddress
+};
+//# sourceMappingURL=ips.js.map

package/dist/esm/utils/ips.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/ips.tsx"],"sourcesContent":["import ipRegex from \"ip-regex\";\n\nexport type Ipv4Address = `${number}.${number}.${number}.${number}`;\nexport type Ipv6Address = string;\n\nexport function isIpAddress(ip: string): ip is Ipv4Address | Ipv6Address {\n  return ipRegex({ exact: true }).test(ip);\n}\nundefined?.test(\"isIpAddress\", ({ expect }) => {\n  // Test valid IPv4 addresses\n  expect(isIpAddress(\"192.168.1.1\")).toBe(true);\n  expect(isIpAddress(\"127.0.0.1\")).toBe(true);\n  expect(isIpAddress(\"0.0.0.0\")).toBe(true);\n  expect(isIpAddress(\"255.255.255.255\")).toBe(true);\n\n  // Test valid IPv6 addresses\n  expect(isIpAddress(\"::1\")).toBe(true);\n  expect(isIpAddress(\"2001:db8::\")).toBe(true);\n  expect(isIpAddress(\"2001:db8:85a3:8d3:1319:8a2e:370:7348\")).toBe(true);\n\n  // Test invalid IP addresses\n  expect(isIpAddress(\"\")).toBe(false);\n  expect(isIpAddress(\"not an ip\")).toBe(false);\n  expect(isIpAddress(\"256.256.256.256\")).toBe(false);\n  expect(isIpAddress(\"192.168.1\")).toBe(false);\n  expect(isIpAddress(\"192.168.1.1.1\")).toBe(false);\n  expect(isIpAddress(\"2001:db8::xyz\")).toBe(false);\n});\n\nexport function assertIpAddress(ip: string): asserts ip is Ipv4Address | Ipv6Address {\n  if (!isIpAddress(ip)) {\n    throw new Error(`Invalid IP address: ${ip}`);\n  }\n}\nundefined?.test(\"assertIpAddress\", ({ expect }) => {\n  // Test with valid IPv4 address\n  expect(() => assertIpAddress(\"192.168.1.1\")).not.toThrow();\n\n  // Test with valid IPv6 address\n  expect(() => assertIpAddress(\"::1\")).not.toThrow();\n\n  // Test with invalid IP addresses\n  expect(() => assertIpAddress(\"\")).toThrow(\"Invalid IP address: \");\n  expect(() => assertIpAddress(\"not an ip\")).toThrow(\"Invalid IP address: not an ip\");\n  expect(() => assertIpAddress(\"256.256.256.256\")).toThrow(\"Invalid IP address: 256.256.256.256\");\n  expect(() => assertIpAddress(\"192.168.1\")).toThrow(\"Invalid IP address: 192.168.1\");\n});\n"],"mappings":";AAAA,OAAO,aAAa;AAKb,SAAS,YAAY,IAA6C;AACvE,SAAO,QAAQ,EAAE,OAAO,KAAK,CAAC,EAAE,KAAK,EAAE;AACzC;AAsBO,SAAS,gBAAgB,IAAqD;AACnF,MAAI,CAAC,YAAY,EAAE,GAAG;AACpB,UAAM,IAAI,MAAM,uBAAuB,EAAE,EAAE;AAAA,EAC7C;AACF;","names":[]}

package/dist/esm/utils/json.js

@@ -0,0 +1,31 @@
+// src/utils/json.tsx
+import { Result } from "./results";
+function isJson(value) {
+  switch (typeof value) {
+    case "object": {
+      if (value === null) return true;
+      if (Array.isArray(value)) return value.every(isJson);
+      return Object.keys(value).every((k) => typeof k === "string") && Object.values(value).every(isJson);
+    }
+    case "string":
+    case "number":
+    case "boolean": {
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+function parseJson(json) {
+  return Result.fromThrowing(() => JSON.parse(json));
+}
+function stringifyJson(json) {
+  return Result.fromThrowing(() => JSON.stringify(json));
+}
+export {
+  isJson,
+  parseJson,
+  stringifyJson
+};
+//# sourceMappingURL=json.js.map

package/dist/esm/utils/json.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/json.tsx"],"sourcesContent":["import { Result } from \"./results\";\n\nexport type Json =\n  | null\n  | boolean\n  | number\n  | string\n  | Json[]\n  | { [key: string]: Json };\n\nexport type ReadonlyJson =\n  | null\n  | boolean\n  | number\n  | string\n  | readonly ReadonlyJson[]\n  | { readonly [key: string]: ReadonlyJson };\n\nexport function isJson(value: unknown): value is Json {\n  switch (typeof value) {\n    case \"object\": {\n      if (value === null) return true;\n      if (Array.isArray(value)) return value.every(isJson);\n      return Object.keys(value).every(k => typeof k === \"string\") && Object.values(value).every(isJson);\n    }\n    case \"string\":\n    case \"number\":\n    case \"boolean\": {\n      return true;\n    }\n    default: {\n      return false;\n    }\n  }\n}\nundefined?.test(\"isJson\", ({ expect }) => {\n  // Test primitive values\n  expect(isJson(null)).toBe(true);\n  expect(isJson(true)).toBe(true);\n  expect(isJson(false)).toBe(true);\n  expect(isJson(123)).toBe(true);\n  expect(isJson(\"string\")).toBe(true);\n\n  // Test arrays\n  expect(isJson([])).toBe(true);\n  expect(isJson([1, 2, 3])).toBe(true);\n  expect(isJson([\"a\", \"b\", \"c\"])).toBe(true);\n  expect(isJson([1, \"a\", true, null])).toBe(true);\n  expect(isJson([1, [2, 3], { a: \"b\" }])).toBe(true);\n\n  // Test objects\n  expect(isJson({})).toBe(true);\n  expect(isJson({ a: 1, b: 2 })).toBe(true);\n  expect(isJson({ a: \"string\", b: true, c: null })).toBe(true);\n  expect(isJson({ a: [1, 2, 3], b: { c: \"d\" } })).toBe(true);\n\n  // Test invalid JSON values\n  expect(isJson(undefined)).toBe(false);\n  expect(isJson(() => {})).toBe(false);\n  expect(isJson(Symbol())).toBe(false);\n  expect(isJson(BigInt(123))).toBe(false);\n\n  // Test arrays with invalid JSON values\n  expect(isJson([1, undefined, 3])).toBe(false);\n  expect(isJson([1, () => {}, 3])).toBe(false);\n\n  // Test objects with invalid JSON values\n  expect(isJson({ a: 1, b: undefined })).toBe(false);\n  expect(isJson({ a: 1, b: () => {} })).toBe(false);\n});\n\nexport function parseJson(json: string): Result<Json> {\n  return Result.fromThrowing(() => JSON.parse(json));\n}\nundefined?.test(\"parseJson\", ({ expect }) => {\n  // Test valid JSON strings\n  const nullResult = parseJson(\"null\");\n  expect(nullResult.status).toBe(\"ok\");\n  if (nullResult.status === \"ok\") {\n    expect(nullResult.data).toBe(null);\n  }\n\n  const trueResult = parseJson(\"true\");\n  expect(trueResult.status).toBe(\"ok\");\n  if (trueResult.status === \"ok\") {\n    expect(trueResult.data).toBe(true);\n  }\n\n  const numberResult = parseJson(\"123\");\n  expect(numberResult.status).toBe(\"ok\");\n  if (numberResult.status === \"ok\") {\n    expect(numberResult.data).toBe(123);\n  }\n\n  const stringResult = parseJson('\"string\"');\n  expect(stringResult.status).toBe(\"ok\");\n  if (stringResult.status === \"ok\") {\n    expect(stringResult.data).toBe(\"string\");\n  }\n\n  const emptyArrayResult = parseJson(\"[]\");\n  expect(emptyArrayResult.status).toBe(\"ok\");\n  if (emptyArrayResult.status === \"ok\") {\n    expect(emptyArrayResult.data).toEqual([]);\n  }\n\n  const arrayResult = parseJson(\"[1,2,3]\");\n  expect(arrayResult.status).toBe(\"ok\");\n  if (arrayResult.status === \"ok\") {\n    expect(arrayResult.data).toEqual([1, 2, 3]);\n  }\n\n  const emptyObjectResult = parseJson(\"{}\");\n  expect(emptyObjectResult.status).toBe(\"ok\");\n  if (emptyObjectResult.status === \"ok\") {\n    expect(emptyObjectResult.data).toEqual({});\n  }\n\n  const objectResult = parseJson('{\"a\":1,\"b\":\"string\"}');\n  expect(objectResult.status).toBe(\"ok\");\n  if (objectResult.status === \"ok\") {\n    expect(objectResult.data).toEqual({ a: 1, b: \"string\" });\n  }\n\n  // Test invalid JSON strings\n  expect(parseJson(\"\").status).toBe(\"error\");\n  expect(parseJson(\"undefined\").status).toBe(\"error\");\n  expect(parseJson(\"{\").status).toBe(\"error\");\n  expect(parseJson('{\"a\":1,}').status).toBe(\"error\");\n  expect(parseJson(\"function(){}\").status).toBe(\"error\");\n});\n\nexport function stringifyJson(json: Json): Result<string> {\n  return Result.fromThrowing(() => JSON.stringify(json));\n}\nundefined?.test(\"stringifyJson\", ({ expect }) => {\n  // Test primitive values\n  const nullResult = stringifyJson(null);\n  expect(nullResult.status).toBe(\"ok\");\n  if (nullResult.status === \"ok\") {\n    expect(nullResult.data).toBe(\"null\");\n  }\n\n  const trueResult = stringifyJson(true);\n  expect(trueResult.status).toBe(\"ok\");\n  if (trueResult.status === \"ok\") {\n    expect(trueResult.data).toBe(\"true\");\n  }\n\n  const numberResult = stringifyJson(123);\n  expect(numberResult.status).toBe(\"ok\");\n  if (numberResult.status === \"ok\") {\n    expect(numberResult.data).toBe(\"123\");\n  }\n\n  const stringResult = stringifyJson(\"string\");\n  expect(stringResult.status).toBe(\"ok\");\n  if (stringResult.status === \"ok\") {\n    expect(stringResult.data).toBe('\"string\"');\n  }\n\n  // Test arrays\n  const emptyArrayResult = stringifyJson([]);\n  expect(emptyArrayResult.status).toBe(\"ok\");\n  if (emptyArrayResult.status === \"ok\") {\n    expect(emptyArrayResult.data).toBe(\"[]\");\n  }\n\n  const arrayResult = stringifyJson([1, 2, 3]);\n  expect(arrayResult.status).toBe(\"ok\");\n  if (arrayResult.status === \"ok\") {\n    expect(arrayResult.data).toBe(\"[1,2,3]\");\n  }\n\n  // Test objects\n  const emptyObjectResult = stringifyJson({});\n  expect(emptyObjectResult.status).toBe(\"ok\");\n  if (emptyObjectResult.status === \"ok\") {\n    expect(emptyObjectResult.data).toBe(\"{}\");\n  }\n\n  const objectResult = stringifyJson({ a: 1, b: \"string\" });\n  expect(objectResult.status).toBe(\"ok\");\n  if (objectResult.status === \"ok\") {\n    expect(objectResult.data).toBe('{\"a\":1,\"b\":\"string\"}');\n  }\n\n  // Test nested structures\n  const nested = { a: [1, 2, 3], b: { c: \"d\" } };\n  const nestedResult = stringifyJson(nested);\n  expect(nestedResult.status).toBe(\"ok\");\n  if (nestedResult.status === \"ok\") {\n    expect(nestedResult.data).toBe('{\"a\":[1,2,3],\"b\":{\"c\":\"d\"}}');\n  }\n\n  // Test circular references (should error)\n  const circular: any = { a: 1 };\n  circular.self = circular;\n  expect(stringifyJson(circular).status).toBe(\"error\");\n});\n"],"mappings":";AAAA,SAAS,cAAc;AAkBhB,SAAS,OAAO,OAA+B;AACpD,UAAQ,OAAO,OAAO;AAAA,IACpB,KAAK,UAAU;AACb,UAAI,UAAU,KAAM,QAAO;AAC3B,UAAI,MAAM,QAAQ,KAAK,EAAG,QAAO,MAAM,MAAM,MAAM;AACnD,aAAO,OAAO,KAAK,KAAK,EAAE,MAAM,OAAK,OAAO,MAAM,QAAQ,KAAK,OAAO,OAAO,KAAK,EAAE,MAAM,MAAM;AAAA,IAClG;AAAA,IACA,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK,WAAW;AACd,aAAO;AAAA,IACT;AAAA,IACA,SAAS;AACP,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAqCO,SAAS,UAAU,MAA4B;AACpD,SAAO,OAAO,aAAa,MAAM,KAAK,MAAM,IAAI,CAAC;AACnD;AA2DO,SAAS,cAAc,MAA4B;AACxD,SAAO,OAAO,aAAa,MAAM,KAAK,UAAU,IAAI,CAAC;AACvD;","names":[]}

package/dist/esm/utils/jwt.js

@@ -0,0 +1,87 @@
+// src/utils/jwt.tsx
+import crypto from "crypto";
+import elliptic from "elliptic";
+import * as jose from "jose";
+import { JOSEError } from "jose/errors";
+import { encodeBase64Url } from "./bytes";
+import { StackAssertionError } from "./errors";
+import { globalVar } from "./globals";
+import { pick } from "./objects";
+var STACK_SERVER_SECRET = process.env.STACK_SERVER_SECRET ?? "";
+try {
+  jose.base64url.decode(STACK_SERVER_SECRET);
+} catch (e) {
+  throw new Error("STACK_SERVER_SECRET is not valid. Please use the generateKeys script to generate a new secret.");
+}
+async function legacySignGlobalJWT(issuer, payload, expirationTime = "5m") {
+  const privateJwk = await jose.importJWK(await getPrivateJwk(STACK_SERVER_SECRET));
+  return await new jose.SignJWT(payload).setProtectedHeader({ alg: "ES256" }).setIssuer(issuer).setIssuedAt().setExpirationTime(expirationTime).sign(privateJwk);
+}
+async function legacyVerifyGlobalJWT(issuer, jwt) {
+  const jwkSet = jose.createLocalJWKSet(await getPublicJwkSet(STACK_SERVER_SECRET));
+  const verified = await jose.jwtVerify(jwt, jwkSet, { issuer });
+  return verified.payload;
+}
+async function signJWT(options) {
+  const secret = getPerAudienceSecret({ audience: options.audience, secret: STACK_SERVER_SECRET });
+  const kid = getKid({ secret });
+  const privateJwk = await jose.importJWK(await getPrivateJwk(secret));
+  return await new jose.SignJWT(options.payload).setProtectedHeader({ alg: "ES256", kid }).setIssuer(options.issuer).setIssuedAt().setAudience(options.audience).setExpirationTime(options.expirationTime || "5m").sign(privateJwk);
+}
+async function verifyJWT(options) {
+  const audience = jose.decodeJwt(options.jwt).aud;
+  if (!audience || typeof audience !== "string") {
+    throw new JOSEError("Invalid JWT audience");
+  }
+  const secret = getPerAudienceSecret({ audience, secret: STACK_SERVER_SECRET });
+  const jwkSet = jose.createLocalJWKSet(await getPublicJwkSet(secret));
+  const verified = await jose.jwtVerify(options.jwt, jwkSet, { issuer: options.issuer });
+  return verified.payload;
+}
+async function getPrivateJwk(secret) {
+  const secretHash = await globalVar.crypto.subtle.digest("SHA-256", jose.base64url.decode(secret));
+  const priv = new Uint8Array(secretHash);
+  const ec = new elliptic.ec("p256");
+  const key = ec.keyFromPrivate(priv);
+  const publicKey = key.getPublic();
+  return {
+    kty: "EC",
+    crv: "P-256",
+    alg: "ES256",
+    kid: getKid({ secret }),
+    d: encodeBase64Url(priv),
+    x: encodeBase64Url(publicKey.getX().toBuffer()),
+    y: encodeBase64Url(publicKey.getY().toBuffer())
+  };
+}
+async function getPublicJwkSet(secretOrPrivateJwk) {
+  const privateJwk = typeof secretOrPrivateJwk === "string" ? await getPrivateJwk(secretOrPrivateJwk) : secretOrPrivateJwk;
+  const jwk = pick(privateJwk, ["kty", "alg", "crv", "x", "y", "kid"]);
+  return {
+    keys: [jwk]
+  };
+}
+function getPerAudienceSecret(options) {
+  if (options.audience === "kid") {
+    throw new StackAssertionError("You cannot use the 'kid' audience for a per-audience secret, see comment below in jwt.tsx");
+  }
+  return jose.base64url.encode(
+    crypto.createHash("sha256").update(JSON.stringify([options.secret, options.audience])).digest()
+  );
+}
+function getKid(options) {
+  return jose.base64url.encode(
+    crypto.createHash("sha256").update(JSON.stringify([options.secret, "kid"])).digest()
+  ).slice(0, 12);
+}
+export {
+  getKid,
+  getPerAudienceSecret,
+  getPrivateJwk,
+  getPublicJwkSet,
+  legacySignGlobalJWT,
+  legacyVerifyGlobalJWT,
+  signJWT,
+  verifyJWT
+};
+//# sourceMappingURL=jwt.js.map