@stackframe/stack-shared 1.0.0

package/dist/utils/caches.d.ts

@@ -0,0 +1,76 @@
+import { RateLimitOptions, ReactPromise } from "./promises";
+import { ReadonlyAsyncStore } from "./stores";
+export declare class AsyncCache<K extends object, T> {
+    private readonly _fetcher;
+    private readonly _rateLimitOptions;
+    private _map;
+    constructor(_fetcher: (key: K, isFirst: boolean) => Promise<T>, _rateLimitOptions?: Omit<RateLimitOptions, "batchCalls">);
+    private _createKeyed;
+    getValueCache(key: K): AsyncValueCache<T>;
+    isAvailable: (key: K) => boolean;
+    setUnavailable: (key: K) => void;
+    get: (key: K) => ({
+        status: "pending";
+    } & {
+        progress: void;
+    } & {
+        status: "pending";
+    }) | ({
+        status: "error";
+        error: unknown;
+    } & {
+        status: "error";
+    }) | ({
+        status: "ok";
+        data: T;
+    } & {
+        status: "ok";
+    });
+    getOrWait: (key: K) => ReactPromise<T>;
+    refresh: (key: K) => Promise<T>;
+    invalidate: (key: K) => Promise<T>;
+    onChange: (key: K, callback: (value: T, oldValue: T | undefined) => void) => {
+        unsubscribe: () => void;
+    };
+    onceChange: (key: K, callback: (value: T, oldValue: T | undefined) => void) => {
+        unsubscribe: () => void;
+    };
+}
+export declare class AsyncValueCache<T> implements ReadonlyAsyncStore<T> {
+    private readonly _rateLimitOptions;
+    private _store;
+    private _firstFetcher;
+    private _laterFetcher;
+    constructor(fetcher: (isFirst: boolean) => Promise<T>, _rateLimitOptions?: Omit<RateLimitOptions, "batchCalls">);
+    isAvailable(): boolean;
+    setUnavailable(): void;
+    get(): ({
+        status: "pending";
+    } & {
+        progress: void;
+    } & {
+        status: "pending";
+    }) | ({
+        status: "error";
+        error: unknown;
+    } & {
+        status: "error";
+    }) | ({
+        status: "ok";
+        data: T;
+    } & {
+        status: "ok";
+    });
+    getOrWait(): ReactPromise<T>;
+    private _set;
+    private _setAsync;
+    private _refetch;
+    refresh(): Promise<T>;
+    invalidate(): Promise<T>;
+    onChange(callback: (value: T, oldValue: T | undefined) => void): {
+        unsubscribe: () => void;
+    };
+    onceChange(callback: (value: T, oldValue: T | undefined) => void): {
+        unsubscribe: () => void;
+    };
+}

package/dist/utils/caches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caches.d.ts","sourceRoot":"","sources":["../../src/utils/caches.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAe,MAAM,YAAY,CAAC;AACzE,OAAO,EAAc,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE1D,qBAAa,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC;IAIvC,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAJpC,OAAO,CAAC,IAAI,CAA6C;gBAGtC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,EAClD,iBAAiB,GAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAoC;IAK7G,OAAO,CAAC,YAAY;IASpB,aAAa,CAAC,GAAG,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC;IAWzC,WAAW,QAlBF,CAAC,aAkBqC;IAC/C,cAAc,QAnBL,CAAC,UAmB2C;IACrD,GAAG,QApBM,CAAC;;;;;;;;;;;;;;;;OAoBqB;IAC/B,SAAS,QArBA,CAAC,qBAqBiC;IAC3C,OAAO,QAtBE,CAAC,gBAsB6B;IACvC,UAAU,QAvBD,CAAC,gBAuBmC;IAC7C,QAAQ,QAxBC,CAAC;;MAwB+B;IACzC,UAAU,QAzBD,CAAC;;MAyBmC;CAC9C;AAED,qBAAa,eAAe,CAAC,CAAC,CAAE,YAAW,kBAAkB,CAAC,CAAC,CAAC;IAO5D,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IANpC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,aAAa,CAAmB;IACxC,OAAO,CAAC,aAAa,CAAmB;gBAGtC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,EACxB,iBAAiB,GAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAyC;IAmBlH,WAAW,IAAI,OAAO;IAItB,cAAc,IAAI,IAAI;IAItB,GAAG;;;;;;;;;;;;;;;;;IAIH,SAAS,IAAI,YAAY,CAAC,CAAC,CAAC;IAI5B,OAAO,CAAC,IAAI;YAIE,SAAS;YAIT,QAAQ;IAWhB,OAAO,IAAI,OAAO,CAAC,CAAC,CAAC;IAIrB,UAAU,IAAI,OAAO,CAAC,CAAC,CAAC;IAK9B,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,GAAG;QAAE,WAAW,EAAE,MAAM,IAAI,CAAA;KAAE;IAI5F,UAAU,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,GAAG;QAAE,WAAW,EAAE,MAAM,IAAI,CAAA;KAAE;CAG/F"}

package/dist/utils/caches.js

@@ -0,0 +1,100 @@
+import { rateLimited } from "./promises";
+import { AsyncStore } from "./stores";
+export class AsyncCache {
+    _fetcher;
+    _rateLimitOptions;
+    _map = new Map();
+    constructor(_fetcher, _rateLimitOptions = { concurrency: 1, gapMs: 3_000 }) {
+        this._fetcher = _fetcher;
+        this._rateLimitOptions = _rateLimitOptions;
+        // nothing here yet
+    }
+    _createKeyed(functionName) {
+        return (key, ...args) => {
+            const valueCache = this.getValueCache(key);
+            return valueCache[functionName].apply(valueCache, args);
+        };
+    }
+    getValueCache(key) {
+        let cache = this._map.get(key);
+        if (!cache) {
+            cache = new AsyncValueCache(async (isFirst) => {
+                return await this._fetcher(key, isFirst);
+            }, this._rateLimitOptions);
+            this._map.set(key, cache);
+        }
+        return cache;
+    }
+    isAvailable = this._createKeyed("isAvailable");
+    setUnavailable = this._createKeyed("setUnavailable");
+    get = this._createKeyed("get");
+    getOrWait = this._createKeyed("getOrWait");
+    refresh = this._createKeyed("refresh");
+    invalidate = this._createKeyed("invalidate");
+    onChange = this._createKeyed("onChange");
+    onceChange = this._createKeyed("onceChange");
+}
+export class AsyncValueCache {
+    _rateLimitOptions;
+    _store;
+    _firstFetcher;
+    _laterFetcher;
+    constructor(fetcher, _rateLimitOptions = { concurrency: 1, debounceMs: 3_000 }) {
+        this._rateLimitOptions = _rateLimitOptions;
+        this._store = new AsyncStore();
+        this._firstFetcher = async () => {
+            return await fetcher(true);
+        };
+        this._laterFetcher = rateLimited(async () => {
+            return await fetcher(false);
+        }, {
+            ...this._rateLimitOptions,
+            batchCalls: true,
+        });
+        this._refetch(true).catch(() => {
+            this._store.setRejected(new Error("unavailable"));
+        });
+    }
+    isAvailable() {
+        return this._store.isAvailable();
+    }
+    setUnavailable() {
+        this._store.setUnavailable();
+    }
+    get() {
+        return this._store.get();
+    }
+    getOrWait() {
+        return this._store.getOrWait();
+    }
+    _set(value) {
+        this._store.set(value);
+    }
+    async _setAsync(value) {
+        return await this._store.setAsync(value);
+    }
+    async _refetch(isFirst) {
+        try {
+            const res = isFirst ? this._firstFetcher() : this._laterFetcher();
+            await this._setAsync(res);
+            return await res;
+        }
+        catch (e) {
+            this._store.setRejected(e);
+            throw e;
+        }
+    }
+    async refresh() {
+        return await this._refetch(false);
+    }
+    async invalidate() {
+        this.setUnavailable();
+        return await this._refetch(false);
+    }
+    onChange(callback) {
+        return this._store.onChange(callback);
+    }
+    onceChange(callback) {
+        return this._store.onceChange(callback);
+    }
+}

package/dist/utils/crypto.d.ts

@@ -0,0 +1 @@
+export declare function generateSecureRandomString(minBitsOfEntropy?: number): string;

package/dist/utils/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/utils/crypto.tsx"],"names":[],"mappings":"AAEA,wBAAgB,0BAA0B,CAAC,gBAAgB,GAAE,MAAY,UAGxE"}

package/dist/utils/crypto.js

@@ -0,0 +1,5 @@
+import crypto from "node:crypto";
+export function generateSecureRandomString(minBitsOfEntropy = 196) {
+    const randomBytes = crypto.randomBytes(Math.ceil(minBitsOfEntropy / 8));
+    return randomBytes.toString("hex");
+}

package/dist/utils/dates.d.ts

@@ -0,0 +1,12 @@
+export declare function fromNow(date: Date): string;
+export declare function fromNowDetailed(date: Date): {
+    result: string;
+    /**
+     * May be Infinity if the result will never change.
+     */
+    secondsUntilChange: number;
+};
+/**
+ * Returns a string representation of the given date in the format expected by the `datetime-local` input type.
+ */
+export declare function getInputDatetimeLocalString(date: Date): string;

package/dist/utils/dates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dates.d.ts","sourceRoot":"","sources":["../../src/utils/dates.tsx"],"names":[],"mappings":"AAUA,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE1C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAuCA;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAI9D"}

package/dist/utils/dates.js

@@ -0,0 +1,57 @@
+import { remainder } from "./math";
+const agoUnits = [
+    [60, 'second'],
+    [60, 'minute'],
+    [24, 'hour'],
+    [7, 'day'],
+    [5, 'week'],
+];
+export function fromNow(date) {
+    return fromNowDetailed(date).result;
+}
+export function fromNowDetailed(date) {
+    if (!(date instanceof Date)) {
+        throw new Error(`fromNow only accepts Date objects (received: ${date})`);
+    }
+    const now = new Date();
+    const elapsed = now.getTime() - date.getTime();
+    let remainingInUnit = Math.abs(elapsed) / 1000;
+    if (remainingInUnit < 15) {
+        return {
+            result: 'just now',
+            secondsUntilChange: 15 - remainingInUnit,
+        };
+    }
+    let unitInSeconds = 1;
+    for (const [nextUnitSize, unitName] of agoUnits) {
+        const rounded = Math.round(remainingInUnit);
+        if (rounded < nextUnitSize) {
+            if (elapsed < 0) {
+                return {
+                    result: `in ${rounded} ${unitName}${rounded === 1 ? '' : 's'}`,
+                    secondsUntilChange: remainder((remainingInUnit - rounded + 0.5) * unitInSeconds, unitInSeconds),
+                };
+            }
+            else {
+                return {
+                    result: `${rounded} ${unitName}${rounded === 1 ? '' : 's'} ago`,
+                    secondsUntilChange: remainder((rounded - remainingInUnit - 0.5) * unitInSeconds, unitInSeconds),
+                };
+            }
+        }
+        unitInSeconds *= nextUnitSize;
+        remainingInUnit /= nextUnitSize;
+    }
+    return {
+        result: date.toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' }),
+        secondsUntilChange: Infinity,
+    };
+}
+/**
+ * Returns a string representation of the given date in the format expected by the `datetime-local` input type.
+ */
+export function getInputDatetimeLocalString(date) {
+    date = new Date(date);
+    date.setMinutes(date.getMinutes() - date.getTimezoneOffset());
+    return date.toISOString().slice(0, 19);
+}

package/dist/utils/dom.d.ts

@@ -0,0 +1,4 @@
+/**
+ * https://n2d4.github.io/frontend-starter/guides/advanced-concepts#clickable-parents
+ */
+export declare function hasClickableParent(element: HTMLElement): boolean;

package/dist/utils/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../src/utils/dom.tsx"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAMhE"}

package/dist/utils/dom.js

@@ -0,0 +1,11 @@
+/**
+ * https://n2d4.github.io/frontend-starter/guides/advanced-concepts#clickable-parents
+ */
+export function hasClickableParent(element) {
+    const parent = element.parentElement;
+    if (!parent)
+        return false;
+    if (parent.dataset.n2Clickable)
+        return true;
+    return !!element.parentElement && hasClickableParent(element.parentElement);
+}

package/dist/utils/env.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns the environment variable with the given name, throwing an error if it's undefined or the empty string.
+ */
+export declare function getEnvVariable(name: string): string;

package/dist/utils/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/utils/env.tsx"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/utils/env.js

@@ -0,0 +1,7 @@
+import { throwErr } from "./errors";
+/**
+ * Returns the environment variable with the given name, throwing an error if it's undefined or the empty string.
+ */
+export function getEnvVariable(name) {
+    return (process.env[name] ?? throwErr(`Missing environment variable: ${name}`)) || throwErr(`Empty environment variable: ${name}`);
+}

package/dist/utils/errors.d.ts

@@ -0,0 +1,184 @@
+export declare function throwErr(errorMessage: string): never;
+export declare function throwErr(error: Error): never;
+export declare function throwErr(...args: StatusErrorConstructorParameters): never;
+type Status = {
+    statusCode: number;
+    message: string;
+};
+type StatusErrorConstructorParameters = [
+    statusCode: number | Status,
+    message?: string,
+    options?: {
+        headers: Record<string, string>;
+    }
+];
+export declare class StatusError extends Error {
+    readonly options?: {
+        headers: Record<string, string>;
+    } | undefined;
+    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;
+}
+export {};

package/dist/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/utils/errors.tsx"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,KAAK,CAAC;AACtD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC;AAC9C,wBAAgB,QAAQ,CAAC,GAAG,IAAI,EAAE,gCAAgC,GAAG,KAAK,CAAC;AAY3E,KAAK,MAAM,GAAG;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,KAAK,gCAAgC,GAAG;IACtC,UAAU,EAAE,MAAM,GAAG,MAAM;IAC3B,OAAO,CAAC,EAAE,MAAM;IAChB,OAAO,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE;CAC9C,CAAC;AAEF,qBAAa,WAAY,SAAQ,KAAK;aA+CmC,OAAO,CAAC;iBAAa,OAAO,MAAM,EAAE,MAAM,CAAC;;IA9ClH,SAAgB,UAAU,EAAE,MAAM,CAAC;IAEnC,OAAc,UAAU;;;MAA+C;IACvE,OAAc,YAAY;;;MAAgD;IAC1E,OAAc,eAAe;;;MAAoD;IACjF,OAAc,SAAS;;;MAA6C;IACpE,OAAc,QAAQ;;;MAA6C;IACnE,OAAc,gBAAgB;;;MAAsD;IACpF,OAAc,aAAa;;;MAAkD;IAC7E,OAAc,2BAA2B;;;MAAiE;IAC1G,OAAc,cAAc;;;MAAmD;IAC/E,OAAc,QAAQ;;;MAA4C;IAClE,OAAc,IAAI;;;MAAwC;IAC1D,OAAc,cAAc;;;MAAmD;IAC/E,OAAc,kBAAkB;;;MAAuD;IACvF,OAAc,eAAe;;;MAAqD;IAClF,OAAc,UAAU;;;MAAgD;IACxE,OAAc,oBAAoB;;;MAA0D;IAC5F,OAAc,mBAAmB;;;MAAyD;IAC1F,OAAc,iBAAiB;;;MAAsD;IACrF,OAAc,SAAS;;;MAAgD;IACvE,OAAc,kBAAkB;;;MAAuD;IACvF,OAAc,mBAAmB;;;MAAwD;IACzF,OAAc,MAAM;;;MAA0C;IAC9D,OAAc,gBAAgB;;;MAAqD;IACnF,OAAc,QAAQ;;;MAA6C;IACnE,OAAc,eAAe;;;MAAoD;IACjF,OAAc,oBAAoB;;;MAAyD;IAC3F,OAAc,eAAe;;;MAAqD;IAClF,OAAc,2BAA2B;;;MAAmE;IAC5G,OAAc,0BAA0B;;;MAAiE;IAEzG,OAAc,mBAAmB;;;MAAyD;IAC1F,OAAc,cAAc;;;MAAmD;IAC/E,OAAc,UAAU;;;MAA+C;IACvE,OAAc,kBAAkB;;;MAAuD;IACvF,OAAc,cAAc;;;MAAmD;IAC/E,OAAc,uBAAuB;;;MAA8D;IACnG,OAAc,qBAAqB;;;MAA2D;IAC9F,OAAc,mBAAmB;;;MAAwD;IACzF,OAAc,YAAY;;;MAAiD;IAC3E,OAAc,WAAW;;;MAAgD;IACzE,OAAc,6BAA6B;;;MAAmE;gBAGlG,GAAG,IAAI,EAAE,gCAAgC;IAW9C,aAAa;IAIb,aAAa;CAGrB"}

package/dist/utils/errors.js

@@ -0,0 +1,72 @@
+export function throwErr(...args) {
+    if (typeof args[0] === "string") {
+        throw new Error(args[0]);
+    }
+    else if (args[0] instanceof Error) {
+        throw args[0];
+    }
+    else {
+        // @ts-expect-error
+        throw new StatusError(...args);
+    }
+}
+export class StatusError extends Error {
+    options;
+    statusCode;
+    static BadRequest = { statusCode: 400, message: "Bad Request" };
+    static Unauthorized = { statusCode: 401, message: "Unauthorized" };
+    static PaymentRequired = { statusCode: 402, message: "Payment Required" };
+    static Forbidden = { statusCode: 403, message: "Forbidden" };
+    static NotFound = { statusCode: 404, message: "Not Found" };
+    static MethodNotAllowed = { statusCode: 405, message: "Method Not Allowed" };
+    static NotAcceptable = { statusCode: 406, message: "Not Acceptable" };
+    static ProxyAuthenticationRequired = { statusCode: 407, message: "Proxy Authentication Required" };
+    static RequestTimeout = { statusCode: 408, message: "Request Timeout" };
+    static Conflict = { statusCode: 409, message: "Conflict" };
+    static Gone = { statusCode: 410, message: "Gone" };
+    static LengthRequired = { statusCode: 411, message: "Length Required" };
+    static PreconditionFailed = { statusCode: 412, message: "Precondition Failed" };
+    static PayloadTooLarge = { statusCode: 413, message: "Payload Too Large" };
+    static URITooLong = { statusCode: 414, message: "URI Too Long" };
+    static UnsupportedMediaType = { statusCode: 415, message: "Unsupported Media Type" };
+    static RangeNotSatisfiable = { statusCode: 416, message: "Range Not Satisfiable" };
+    static ExpectationFailed = { statusCode: 417, message: "Expectation Failed" };
+    static ImATeapot = { statusCode: 418, message: "I'm a teapot" };
+    static MisdirectedRequest = { statusCode: 421, message: "Misdirected Request" };
+    static UnprocessableEntity = { statusCode: 422, message: "Unprocessable Entity" };
+    static Locked = { statusCode: 423, message: "Locked" };
+    static FailedDependency = { statusCode: 424, message: "Failed Dependency" };
+    static TooEarly = { statusCode: 425, message: "Too Early" };
+    static UpgradeRequired = { statusCode: 426, message: "Upgrade Required" };
+    static PreconditionRequired = { statusCode: 428, message: "Precondition Required" };
+    static TooManyRequests = { statusCode: 429, message: "Too Many Requests" };
+    static RequestHeaderFieldsTooLarge = { statusCode: 431, message: "Request Header Fields Too Large" };
+    static UnavailableForLegalReasons = { statusCode: 451, message: "Unavailable For Legal Reasons" };
+    static InternalServerError = { statusCode: 500, message: "Internal Server Error" };
+    static NotImplemented = { statusCode: 501, message: "Not Implemented" };
+    static BadGateway = { statusCode: 502, message: "Bad Gateway" };
+    static ServiceUnavailable = { statusCode: 503, message: "Service Unavailable" };
+    static GatewayTimeout = { statusCode: 504, message: "Gateway Timeout" };
+    static HTTPVersionNotSupported = { statusCode: 505, message: "HTTP Version Not Supported" };
+    static VariantAlsoNegotiates = { statusCode: 506, message: "Variant Also Negotiates" };
+    static InsufficientStorage = { statusCode: 507, message: "Insufficient Storage" };
+    static LoopDetected = { statusCode: 508, message: "Loop Detected" };
+    static NotExtended = { statusCode: 510, message: "Not Extended" };
+    static NetworkAuthenticationRequired = { statusCode: 511, message: "Network Authentication Required" };
+    constructor(status, message, options) {
+        if (typeof status === "object") {
+            message ??= status.message;
+            status = status.statusCode;
+        }
+        message ??= "Server Error";
+        super(message);
+        this.options = options;
+        this.statusCode = status;
+    }
+    isClientError() {
+        return this.statusCode >= 400 && this.statusCode < 500;
+    }
+    isServerError() {
+        return !this.isClientError();
+    }
+}

package/dist/utils/html.d.ts

@@ -0,0 +1,2 @@
+export declare function escapeHtml(unsafe: string): string;
+export declare function html(strings: TemplateStringsArray, ...values: any[]): string;

package/dist/utils/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../src/utils/html.tsx"],"names":[],"mappings":"AAEA,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAOjD;AAED,wBAAgB,IAAI,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,GAAG,MAAM,CAE5E"}

package/dist/utils/html.js

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

package/dist/utils/json.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "./results";
+export type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+export type ReadonlyJson = null | boolean | number | string | readonly ReadonlyJson[] | {
+    readonly [key: string]: ReadonlyJson;
+};
+export declare function isJson(value: unknown): value is Json;
+export declare function parseJson(json: string): Result<Json>;
+export declare function stringifyJson(json: Json): Result<string>;

package/dist/utils/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/utils/json.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC,MAAM,MAAM,IAAI,GACZ,IAAI,GACJ,OAAO,GACP,MAAM,GACN,MAAM,GACN,IAAI,EAAE,GACN;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAE5B,MAAM,MAAM,YAAY,GACpB,IAAI,GACJ,OAAO,GACP,MAAM,GACN,MAAM,GACN,SAAS,YAAY,EAAE,GACvB;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,CAAC;AAE7C,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,CAgBpD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAEpD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAExD"}

package/dist/utils/json.js

@@ -0,0 +1,26 @@
+import { Result } from "./results";
+export 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;
+        }
+    }
+}
+export function parseJson(json) {
+    return Result.fromThrowing(() => JSON.parse(json));
+}
+export function stringifyJson(json) {
+    return Result.fromThrowing(() => JSON.stringify(json));
+}

package/dist/utils/jwt.d.ts

@@ -0,0 +1,3 @@
+import * as jose from "jose";
+export declare function encryptJWT(payload: any, expirationTime?: string): Promise<string>;
+export declare function decryptJWT(jwt: string): Promise<jose.JWTPayload>;

package/dist/utils/jwt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt.d.ts","sourceRoot":"","sources":["../../src/utils/jwt.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAK7B,wBAAsB,UAAU,CAAC,OAAO,EAAE,GAAG,EAAE,cAAc,SAAO,mBAMnE;AAED,wBAAsB,UAAU,CAAC,GAAG,EAAE,MAAM,4BAK3C"}

package/dist/utils/jwt.js

@@ -0,0 +1,16 @@
+import * as jose from "jose";
+import { getEnvVariable } from "./env";
+const SERVER_SECRET = jose.base64url.decode(getEnvVariable("SERVER_SECRET"));
+export async function encryptJWT(payload, expirationTime = "5m") {
+    return await new jose.EncryptJWT(payload)
+        .setProtectedHeader({ alg: "dir", enc: "A128CBC-HS256" })
+        .setIssuedAt()
+        .setExpirationTime(expirationTime)
+        .encrypt(SERVER_SECRET);
+}
+export async function decryptJWT(jwt) {
+    if (!jwt) {
+        throw new Error("Provided JWT is empty");
+    }
+    return (await jose.jwtDecrypt(jwt, SERVER_SECRET)).payload;
+}

package/dist/utils/math.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Similar to the modulo operator, but always returns a positive number (even when the input is negative).
+ */
+export declare function remainder(n: number, d: number): number;