@stackframe/stack-shared 2.8.8 → 2.8.11

package/dist/utils/errors.d.cts

@@ -0,0 +1,223 @@
+import { Json } from './json.cjs';
+import './results.cjs';
+
+declare function throwErr(errorMessage: string, extraData?: any): never;
+declare function throwErr(error: Error): never;
+declare function throwErr(...args: StatusErrorConstructorParameters): never;
+/**
+ * Concatenates the (original) stacktraces of the given errors onto the first.
+ *
+ * Useful when you invoke an async function to receive a promise without awaiting it immediately. Browsers are smart
+ * enough to keep track of the call stack in async function calls when you invoke `.then` within the same async tick,
+ * but if you don't, the stacktrace will be lost.
+ *
+ * Here's an example of the unwanted behavior:
+ *
+ * ```tsx
+ * async function log() {
+ *   await wait(0);  // simulate an put the task on the event loop
+ *   console.log(new Error().stack);
+ * }
+ *
+ * async function main() {
+ *   await log();  // good; prints both "log" and "main" on the stacktrace
+ *   log();  // bad; prints only "log" on the stacktrace
+ * }
+ * ```
+ */
+declare function concatStacktraces(first: Error, ...errors: Error[]): void;
+declare class StackAssertionError extends Error {
+    readonly extraData?: (Record<string, any> & ErrorOptions) | undefined;
+    constructor(message: string, extraData?: (Record<string, any> & ErrorOptions) | undefined);
+}
+declare function errorToNiceString(error: unknown): string;
+declare function registerErrorSink(sink: (location: string, error: unknown) => void): void;
+declare function captureError(location: string, error: unknown): void;
+type Status = {
+    statusCode: number;
+    message: string;
+};
+type StatusErrorConstructorParameters = [
+    status: Status,
+    message?: string
+] | [
+    statusCode: number | Status,
+    message: string
+];
+declare class StatusError extends Error {
+    name: string;
+    readonly statusCode: number;
+    static BadRequest: {
+        statusCode: number;
+        message: string;
+    };
+    static Unauthorized: {
+        statusCode: number;
+        message: string;
+    };
+    static PaymentRequired: {
+        statusCode: number;
+        message: string;
+    };
+    static Forbidden: {
+        statusCode: number;
+        message: string;
+    };
+    static NotFound: {
+        statusCode: number;
+        message: string;
+    };
+    static MethodNotAllowed: {
+        statusCode: number;
+        message: string;
+    };
+    static NotAcceptable: {
+        statusCode: number;
+        message: string;
+    };
+    static ProxyAuthenticationRequired: {
+        statusCode: number;
+        message: string;
+    };
+    static RequestTimeout: {
+        statusCode: number;
+        message: string;
+    };
+    static Conflict: {
+        statusCode: number;
+        message: string;
+    };
+    static Gone: {
+        statusCode: number;
+        message: string;
+    };
+    static LengthRequired: {
+        statusCode: number;
+        message: string;
+    };
+    static PreconditionFailed: {
+        statusCode: number;
+        message: string;
+    };
+    static PayloadTooLarge: {
+        statusCode: number;
+        message: string;
+    };
+    static URITooLong: {
+        statusCode: number;
+        message: string;
+    };
+    static UnsupportedMediaType: {
+        statusCode: number;
+        message: string;
+    };
+    static RangeNotSatisfiable: {
+        statusCode: number;
+        message: string;
+    };
+    static ExpectationFailed: {
+        statusCode: number;
+        message: string;
+    };
+    static ImATeapot: {
+        statusCode: number;
+        message: string;
+    };
+    static MisdirectedRequest: {
+        statusCode: number;
+        message: string;
+    };
+    static UnprocessableEntity: {
+        statusCode: number;
+        message: string;
+    };
+    static Locked: {
+        statusCode: number;
+        message: string;
+    };
+    static FailedDependency: {
+        statusCode: number;
+        message: string;
+    };
+    static TooEarly: {
+        statusCode: number;
+        message: string;
+    };
+    static UpgradeRequired: {
+        statusCode: number;
+        message: string;
+    };
+    static PreconditionRequired: {
+        statusCode: number;
+        message: string;
+    };
+    static TooManyRequests: {
+        statusCode: number;
+        message: string;
+    };
+    static RequestHeaderFieldsTooLarge: {
+        statusCode: number;
+        message: string;
+    };
+    static UnavailableForLegalReasons: {
+        statusCode: number;
+        message: string;
+    };
+    static InternalServerError: {
+        statusCode: number;
+        message: string;
+    };
+    static NotImplemented: {
+        statusCode: number;
+        message: string;
+    };
+    static BadGateway: {
+        statusCode: number;
+        message: string;
+    };
+    static ServiceUnavailable: {
+        statusCode: number;
+        message: string;
+    };
+    static GatewayTimeout: {
+        statusCode: number;
+        message: string;
+    };
+    static HTTPVersionNotSupported: {
+        statusCode: number;
+        message: string;
+    };
+    static VariantAlsoNegotiates: {
+        statusCode: number;
+        message: string;
+    };
+    static InsufficientStorage: {
+        statusCode: number;
+        message: string;
+    };
+    static LoopDetected: {
+        statusCode: number;
+        message: string;
+    };
+    static NotExtended: {
+        statusCode: number;
+        message: string;
+    };
+    static NetworkAuthenticationRequired: {
+        statusCode: number;
+        message: string;
+    };
+    constructor(...args: StatusErrorConstructorParameters);
+    isClientError(): boolean;
+    isServerError(): boolean;
+    getStatusCode(): number;
+    getBody(): Uint8Array;
+    getHeaders(): Record<string, string[]>;
+    toDescriptiveJson(): Json;
+    /**
+     * @deprecated this is not a good way to make status errors human-readable, use toDescriptiveJson instead
+     */
+    toHttpJson(): Json;
+}
+
+export { StackAssertionError, StatusError, captureError, concatStacktraces, errorToNiceString, registerErrorSink, throwErr };

package/dist/utils/errors.d.ts

@@ -1,7 +1,9 @@
-import { Json } from "./json";
-export declare function throwErr(errorMessage: string, extraData?: any): never;
-export declare function throwErr(error: Error): never;
-export declare function throwErr(...args: StatusErrorConstructorParameters): never;
+import { Json } from './json.js';
+import './results.js';
+
+declare function throwErr(errorMessage: string, extraData?: any): never;
+declare function throwErr(error: Error): never;
+declare function throwErr(...args: StatusErrorConstructorParameters): never;
 /**
  * Concatenates the (original) stacktraces of the given errors onto the first.
  *
@@ -23,14 +25,14 @@ export declare function throwErr(...args: StatusErrorConstructorParameters): nev
  * }
  * ```
  */
-export declare function concatStacktraces(first: Error, ...errors: Error[]): void;
-export declare class StackAssertionError extends Error {
+declare function concatStacktraces(first: Error, ...errors: Error[]): void;
+declare class StackAssertionError extends Error {
     readonly extraData?: (Record<string, any> & ErrorOptions) | undefined;
     constructor(message: string, extraData?: (Record<string, any> & ErrorOptions) | undefined);
 }
-export declare function errorToNiceString(error: unknown): string;
-export declare function registerErrorSink(sink: (location: string, error: unknown) => void): void;
-export declare function captureError(location: string, error: unknown): void;
+declare function errorToNiceString(error: unknown): string;
+declare function registerErrorSink(sink: (location: string, error: unknown) => void): void;
+declare function captureError(location: string, error: unknown): void;
 type Status = {
     statusCode: number;
     message: string;
@@ -42,7 +44,7 @@ type StatusErrorConstructorParameters = [
     statusCode: number | Status,
     message: string
 ];
-export declare class StatusError extends Error {
+declare class StatusError extends Error {
     name: string;
     readonly statusCode: number;
     static BadRequest: {
@@ -217,4 +219,5 @@ export declare class StatusError extends Error {
      */
     toHttpJson(): Json;
 }
-export {};
+
+export { StackAssertionError, StatusError, captureError, concatStacktraces, errorToNiceString, registerErrorSink, throwErr };

package/dist/utils/errors.js

@@ -1,145 +1,156 @@
-import { globalVar } from "./globals";
-import { pick } from "./objects";
-import { nicify } from "./strings";
-export 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 {
-        // @ts-expect-error
-        throw new StatusError(...args);
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/errors.tsx
+var errors_exports = {};
+__export(errors_exports, {
+  StackAssertionError: () => StackAssertionError,
+  StatusError: () => StatusError,
+  captureError: () => captureError,
+  concatStacktraces: () => concatStacktraces,
+  errorToNiceString: () => errorToNiceString,
+  registerErrorSink: () => registerErrorSink,
+  throwErr: () => throwErr
+});
+module.exports = __toCommonJS(errors_exports);
+var import_globals = require("./globals");
+var import_objects = require("./objects");
+var import_strings = require("./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) {
-    // some browsers (eg. Chrome) prepend the stack with an extra line with the error name
-    const addsNameLine = new Error().stack?.startsWith("Error\n");
-    return stack.split("\n").slice(addsNameLine ? 1 : 0).join("\n");
+  const addsNameLine = new Error().stack?.startsWith("Error\n");
+  return stack.split("\n").slice(addsNameLine ? 1 : 0).join("\n");
 }
-/**
- * Concatenates the (original) stacktraces of the given errors onto the first.
- *
- * Useful when you invoke an async function to receive a promise without awaiting it immediately. Browsers are smart
- * enough to keep track of the call stack in async function calls when you invoke `.then` within the same async tick,
- * but if you don't, the stacktrace will be lost.
- *
- * Here's an example of the unwanted behavior:
- *
- * ```tsx
- * async function log() {
- *   await wait(0);  // simulate an put the task on the event loop
- *   console.log(new Error().stack);
- * }
- *
- * async function main() {
- *   await log();  // good; prints both "log" and "main" on the stacktrace
- *   log();  // bad; prints only "log" on the stacktrace
- * }
- * ```
- */
-export function concatStacktraces(first, ...errors) {
-    // some browsers (eg. Firefox) add an extra empty line at the end
-    const addsEmptyLineAtEnd = first.stack?.endsWith("\n");
-    // Add a reference to this function itself so that we know that stacktraces were concatenated
-    // If you are coming here from a stacktrace, please know that the two parts before and after this line are different
-    // stacktraces that were concatenated with concatStacktraces
-    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;
-    }
-}
-export class StackAssertionError extends Error {
-    constructor(message, extraData) {
-        const disclaimer = `\n\nThis 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,
-        });
-    }
+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}`, (0, import_objects.pick)(extraData ?? {}, ["cause"]));
+    this.extraData = extraData;
+    Object.defineProperty(this, "customCaptureExtraArgs", {
+      get() {
+        return [this.extraData];
+      },
+      enumerable: false
+    });
+  }
+};
 StackAssertionError.prototype.name = "StackAssertionError";
-export function errorToNiceString(error) {
-    if (!(error instanceof Error))
-        return `${typeof error}<${nicify(error)}>`;
-    return nicify(error, { maxDepth: 8 });
+function errorToNiceString(error) {
+  if (!(error instanceof Error)) return `${typeof error}<${(0, import_strings.nicify)(error)}>`;
+  return (0, import_strings.nicify)(error, { maxDepth: 8 });
 }
-const errorSinks = new Set();
-export function registerErrorSink(sink) {
-    if (errorSinks.has(sink)) {
-        return;
-    }
-    errorSinks.add(sink);
+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}:`, 
+  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");
+    errorToNiceString(error),
+    ...extraArgs,
+    "\x1B[0m"
+  );
 });
 registerErrorSink((location, error, ...extraArgs) => {
-    globalVar.stackCapturedErrors = globalVar.stackCapturedErrors ?? [];
-    globalVar.stackCapturedErrors.push({ location, error, extraArgs });
+  import_globals.globalVar.stackCapturedErrors = import_globals.globalVar.stackCapturedErrors ?? [];
+  import_globals.globalVar.stackCapturedErrors.push({ location, error, extraArgs });
 });
-export 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 : []);
-    }
+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 : []
+    );
+  }
 }
-export class StatusError 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 });
-        }
+var StatusError = class extends Error {
+  constructor(status, message) {
+    if (typeof status === "object") {
+      message ??= status.message;
+      status = status.statusCode;
     }
-    isClientError() {
-        return this.statusCode >= 400 && this.statusCode < 500;
+    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 });
     }
-    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(),
-        };
-    }
-}
+  }
+  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" };
@@ -181,3 +192,14 @@ 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";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StackAssertionError,
+  StatusError,
+  captureError,
+  concatStacktraces,
+  errorToNiceString,
+  registerErrorSink,
+  throwErr
+});
+//# sourceMappingURL=errors.js.map

package/dist/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/utils/fs.d.cts

@@ -0,0 +1,7 @@
+declare function list(path: string): Promise<string[]>;
+declare function listRecursively(p: string, options?: {
+    excludeDirectories?: boolean;
+}): Promise<string[]>;
+declare function writeFileSyncIfChanged(path: string, content: string): void;
+
+export { list, listRecursively, writeFileSyncIfChanged };

package/dist/utils/fs.d.ts

@@ -1,5 +1,7 @@
-export declare function list(path: string): Promise<string[]>;
-export declare function listRecursively(p: string, options?: {
+declare function list(path: string): Promise<string[]>;
+declare function listRecursively(p: string, options?: {
     excludeDirectories?: boolean;
 }): Promise<string[]>;
-export declare function writeFileSyncIfChanged(path: string, content: string): void;
+declare function writeFileSyncIfChanged(path: string, content: string): void;
+
+export { list, listRecursively, writeFileSyncIfChanged };