@stackframe/stack-shared 2.8.8 → 2.8.11

package/dist/utils/fs.js

@@ -1,31 +1,74 @@
-import * as stackFs from "fs";
-import * as path from "path";
-export async function list(path) {
-    return await stackFs.promises.readdir(path);
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/fs.tsx
+var fs_exports = {};
+__export(fs_exports, {
+  list: () => list,
+  listRecursively: () => listRecursively,
+  writeFileSyncIfChanged: () => writeFileSyncIfChanged
+});
+module.exports = __toCommonJS(fs_exports);
+var stackFs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+async function list(path2) {
+  return await stackFs.promises.readdir(path2);
 }
-export 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(),
-    ];
+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()
+  ];
 }
-export function writeFileSyncIfChanged(path, content) {
-    if (stackFs.existsSync(path)) {
-        const existingContent = stackFs.readFileSync(path, "utf-8");
-        if (existingContent === content) {
-            return;
-        }
+function writeFileSyncIfChanged(path2, content) {
+  if (stackFs.existsSync(path2)) {
+    const existingContent = stackFs.readFileSync(path2, "utf-8");
+    if (existingContent === content) {
+      return;
     }
-    stackFs.writeFileSync(path, content);
+  }
+  stackFs.writeFileSync(path2, content);
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  list,
+  listRecursively,
+  writeFileSyncIfChanged
+});
+//# sourceMappingURL=fs.js.map

package/dist/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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,cAAyB;AACzB,WAAsB;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/utils/functions.d.cts

@@ -0,0 +1,4 @@
+declare function identity<T>(t: T): T;
+declare function identityArgs<T extends any[]>(...args: T): T;
+
+export { identity, identityArgs };

package/dist/utils/functions.d.ts

@@ -1,2 +1,4 @@
-export declare function identity<T>(t: T): T;
-export declare function identityArgs<T extends any[]>(...args: T): T;
+declare function identity<T>(t: T): T;
+declare function identityArgs<T extends any[]>(...args: T): T;
+
+export { identity, identityArgs };

package/dist/utils/functions.js

@@ -1,21 +1,38 @@
-export function identity(t) {
-    return t;
-}
-import.meta.vitest?.test("identity", ({ expect }) => {
-    expect(identity(1)).toBe(1);
-    expect(identity("test")).toBe("test");
-    expect(identity(null)).toBe(null);
-    expect(identity(undefined)).toBe(undefined);
-    const obj = { a: 1 };
-    expect(identity(obj)).toBe(obj);
+"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/functions.tsx
+var functions_exports = {};
+__export(functions_exports, {
+  identity: () => identity,
+  identityArgs: () => identityArgs
 });
-export function identityArgs(...args) {
-    return args;
+module.exports = __toCommonJS(functions_exports);
+function identity(t) {
+  return t;
+}
+function identityArgs(...args) {
+  return args;
 }
-import.meta.vitest?.test("identityArgs", ({ expect }) => {
-    expect(identityArgs()).toEqual([]);
-    expect(identityArgs(1)).toEqual([1]);
-    expect(identityArgs(1, 2, 3)).toEqual([1, 2, 3]);
-    expect(identityArgs("a", "b", "c")).toEqual(["a", "b", "c"]);
-    expect(identityArgs(null, undefined)).toEqual([null, undefined]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  identity,
+  identityArgs
 });
+//# sourceMappingURL=functions.js.map

package/dist/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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,SAAS,SAAY,GAAS;AACnC,SAAO;AACT;AAUO,SAAS,gBAAiC,MAAY;AAC3D,SAAO;AACT;","names":[]}

package/dist/utils/geo.d.cts

@@ -0,0 +1,22 @@
+import * as yup from 'yup';
+
+declare const geoInfoSchema: yup.ObjectSchema<{
+    ip: string;
+    countryCode: string | null | undefined;
+    regionCode: string | null | undefined;
+    cityName: string | null | undefined;
+    latitude: number | null | undefined;
+    longitude: number | null | undefined;
+    tzIdentifier: string | null | undefined;
+}, yup.AnyObject, {
+    ip: undefined;
+    countryCode: undefined;
+    regionCode: undefined;
+    cityName: undefined;
+    latitude: undefined;
+    longitude: undefined;
+    tzIdentifier: undefined;
+}, "">;
+type GeoInfo = yup.InferType<typeof geoInfoSchema>;
+
+export { type GeoInfo, geoInfoSchema };

package/dist/utils/geo.d.ts

@@ -1,5 +1,6 @@
-import * as yup from "yup";
-export declare const geoInfoSchema: yup.ObjectSchema<{
+import * as yup from 'yup';
+
+declare const geoInfoSchema: yup.ObjectSchema<{
     ip: string;
     countryCode: string | null | undefined;
     regionCode: string | null | undefined;
@@ -16,4 +17,6 @@ export declare const geoInfoSchema: yup.ObjectSchema<{
     longitude: undefined;
     tzIdentifier: undefined;
 }, "">;
-export type GeoInfo = yup.InferType<typeof geoInfoSchema>;
+type GeoInfo = yup.InferType<typeof geoInfoSchema>;
+
+export { type GeoInfo, geoInfoSchema };

package/dist/utils/geo.js

@@ -1,10 +1,40 @@
-import { yupNumber, yupObject, yupString } from "../schema-fields";
-export const geoInfoSchema = yupObject({
-    ip: yupString().defined(),
-    countryCode: yupString().nullable(),
-    regionCode: yupString().nullable(),
-    cityName: yupString().nullable(),
-    latitude: yupNumber().nullable(),
-    longitude: yupNumber().nullable(),
-    tzIdentifier: yupString().nullable(),
+"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/geo.tsx
+var geo_exports = {};
+__export(geo_exports, {
+  geoInfoSchema: () => geoInfoSchema
 });
+module.exports = __toCommonJS(geo_exports);
+var import_schema_fields = require("../schema-fields");
+var geoInfoSchema = (0, import_schema_fields.yupObject)({
+  ip: (0, import_schema_fields.yupString)().defined(),
+  countryCode: (0, import_schema_fields.yupString)().nullable(),
+  regionCode: (0, import_schema_fields.yupString)().nullable(),
+  cityName: (0, import_schema_fields.yupString)().nullable(),
+  latitude: (0, import_schema_fields.yupNumber)().nullable(),
+  longitude: (0, import_schema_fields.yupNumber)().nullable(),
+  tzIdentifier: (0, import_schema_fields.yupString)().nullable()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  geoInfoSchema
+});
+//# sourceMappingURL=geo.js.map

package/dist/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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,2BAAgD;AAEzC,IAAM,oBAAgB,gCAAU;AAAA,EACrC,QAAI,gCAAU,EAAE,QAAQ;AAAA,EACxB,iBAAa,gCAAU,EAAE,SAAS;AAAA,EAClC,gBAAY,gCAAU,EAAE,SAAS;AAAA,EACjC,cAAU,gCAAU,EAAE,SAAS;AAAA,EAC/B,cAAU,gCAAU,EAAE,SAAS;AAAA,EAC/B,eAAW,gCAAU,EAAE,SAAS;AAAA,EAChC,kBAAc,gCAAU,EAAE,SAAS;AACrC,CAAC;","names":[]}

package/dist/utils/globals.d.cts

@@ -0,0 +1,5 @@
+declare const globalVar: any;
+
+declare function createGlobal<T>(key: string, init: () => T): T;
+
+export { createGlobal, globalVar };

package/dist/utils/globals.d.ts

@@ -1,3 +1,5 @@
 declare const globalVar: any;
-export { globalVar, };
-export declare function createGlobal<T>(key: string, init: () => T): T;
+
+declare function createGlobal<T>(key: string, init: () => T): T;
+
+export { createGlobal, globalVar };

package/dist/utils/globals.js

@@ -1,17 +1,44 @@
-const globalVar = typeof globalThis !== 'undefined' ? globalThis :
-    typeof global !== 'undefined' ? global :
-        typeof window !== 'undefined' ? window :
-            typeof self !== 'undefined' ? self :
-                {};
-export { globalVar, };
-if (typeof globalThis === 'undefined') {
-    globalVar.globalThis = globalVar;
+"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/globals.tsx
+var globals_exports = {};
+__export(globals_exports, {
+  createGlobal: () => createGlobal,
+  globalVar: () => globalVar
+});
+module.exports = __toCommonJS(globals_exports);
+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;
 }
-const stackGlobalsSymbol = Symbol.for('__stack-globals');
+var stackGlobalsSymbol = Symbol.for("__stack-globals");
 globalVar[stackGlobalsSymbol] ??= {};
-export function createGlobal(key, init) {
-    if (!globalVar[stackGlobalsSymbol][key]) {
-        globalVar[stackGlobalsSymbol][key] = init();
-    }
-    return globalVar[stackGlobalsSymbol][key];
+function createGlobal(key, init) {
+  if (!globalVar[stackGlobalsSymbol][key]) {
+    globalVar[stackGlobalsSymbol][key] = init();
+  }
+  return globalVar[stackGlobalsSymbol][key];
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGlobal,
+  globalVar
+});
+//# sourceMappingURL=globals.js.map

package/dist/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;AAAA;AAAA;AAAA;AAAA;AAAA;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/utils/hashes.d.cts

@@ -0,0 +1,7 @@
+declare function sha512(input: Uint8Array | string): Promise<Uint8Array>;
+declare function hashPassword(password: string): Promise<string>;
+declare function comparePassword(password: string, hash: string): Promise<boolean>;
+declare function isPasswordHashValid(hash: string): Promise<boolean>;
+declare function getPasswordHashAlgorithm(hash: string): Promise<"bcrypt" | undefined>;
+
+export { comparePassword, getPasswordHashAlgorithm, hashPassword, isPasswordHashValid, sha512 };

package/dist/utils/hashes.d.ts

@@ -1,5 +1,7 @@
-export declare function sha512(input: Uint8Array | string): Promise<Uint8Array>;
-export declare function hashPassword(password: string): Promise<string>;
-export declare function comparePassword(password: string, hash: string): Promise<boolean>;
-export declare function isPasswordHashValid(hash: string): Promise<boolean>;
-export declare function getPasswordHashAlgorithm(hash: string): Promise<"bcrypt" | undefined>;
+declare function sha512(input: Uint8Array | string): Promise<Uint8Array>;
+declare function hashPassword(password: string): Promise<string>;
+declare function comparePassword(password: string, hash: string): Promise<boolean>;
+declare function isPasswordHashValid(hash: string): Promise<boolean>;
+declare function getPasswordHashAlgorithm(hash: string): Promise<"bcrypt" | undefined>;
+
+export { comparePassword, getPasswordHashAlgorithm, hashPassword, isPasswordHashValid, sha512 };

package/dist/utils/hashes.js

@@ -1,48 +1,94 @@
-import bcrypt from 'bcrypt';
-import { StackAssertionError } from './errors';
-export async function sha512(input) {
-    const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
-    return new Uint8Array(await crypto.subtle.digest("SHA-512", bytes));
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/hashes.tsx
+var hashes_exports = {};
+__export(hashes_exports, {
+  comparePassword: () => comparePassword,
+  getPasswordHashAlgorithm: () => getPasswordHashAlgorithm,
+  hashPassword: () => hashPassword,
+  isPasswordHashValid: () => isPasswordHashValid,
+  sha512: () => sha512
+});
+module.exports = __toCommonJS(hashes_exports);
+var import_bcrypt = __toESM(require("bcrypt"), 1);
+var import_errors = require("./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));
 }
-export 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 hashPassword(password) {
+  const passwordBytes = new TextEncoder().encode(password);
+  if (passwordBytes.length >= 72) {
+    throw new import_errors.StackAssertionError(`Password is too long for bcrypt`, { len: passwordBytes.length });
+  }
+  const salt = await import_bcrypt.default.genSalt(10);
+  return await import_bcrypt.default.hash(password, salt);
 }
-export async function comparePassword(password, hash) {
-    switch (await getPasswordHashAlgorithm(hash)) {
-        case "bcrypt": {
-            return await bcrypt.compare(password, hash);
-        }
-        default: {
-            return false;
-        }
+async function comparePassword(password, hash) {
+  switch (await getPasswordHashAlgorithm(hash)) {
+    case "bcrypt": {
+      return await import_bcrypt.default.compare(password, hash);
+    }
+    default: {
+      return false;
     }
+  }
 }
-export async function isPasswordHashValid(hash) {
-    return !!(await getPasswordHashAlgorithm(hash));
+async function isPasswordHashValid(hash) {
+  return !!await getPasswordHashAlgorithm(hash);
 }
-export 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 undefined;
-            }
-            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 undefined;
-        }
-    }
-    else {
-        return undefined;
+async function getPasswordHashAlgorithm(hash) {
+  if (typeof hash !== "string") {
+    throw new import_errors.StackAssertionError(`Passed non-string value to getPasswordHashAlgorithm`, { hash });
+  }
+  if (hash.match(/^\$2[ayb]\$.{56}$/)) {
+    try {
+      if (import_bcrypt.default.getRounds(hash) > 16) {
+        return void 0;
+      }
+      await import_bcrypt.default.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;
+  }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  comparePassword,
+  getPasswordHashAlgorithm,
+  hashPassword,
+  isPasswordHashValid,
+  sha512
+});
+//# sourceMappingURL=hashes.js.map

package/dist/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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAmB;AACnB,oBAAoC;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,kCAAoB,mCAAmC,EAAE,KAAK,cAAc,OAAO,CAAC;AAAA,EAChG;AACA,QAAM,OAAO,MAAM,cAAAA,QAAO,QAAQ,EAAE;AACpC,SAAO,MAAM,cAAAA,QAAO,KAAK,UAAU,IAAI;AACzC;AAEA,eAAsB,gBAAgB,UAAkB,MAAgC;AACtF,UAAQ,MAAM,yBAAyB,IAAI,GAAG;AAAA,IAC5C,KAAK,UAAU;AACb,aAAO,MAAM,cAAAA,QAAO,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,kCAAoB,uDAAuD,EAAE,KAAK,CAAC;AAAA,EAC/F;AACA,MAAI,KAAK,MAAM,mBAAmB,GAAG;AACnC,QAAI;AACF,UAAI,cAAAA,QAAO,UAAU,IAAI,IAAI,IAAI;AAC/B,eAAO;AAAA,MACT;AACA,YAAM,cAAAA,QAAO,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":["bcrypt"]}

package/dist/utils/html.d.cts

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

package/dist/utils/html.d.ts

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

package/dist/utils/html.js

@@ -1,40 +1,39 @@
-import { templateIdentity } from "./strings";
-export function escapeHtml(unsafe) {
-    return `${unsafe}`
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, "&quot;")
-        .replace(/'/g, "&#039;");
-}
-import.meta.vitest?.test("escapeHtml", ({ expect }) => {
-    // Test with empty string
-    expect(escapeHtml("")).toBe("");
-    // Test with string without special characters
-    expect(escapeHtml("hello world")).toBe("hello world");
-    // Test with special characters
-    expect(escapeHtml("<div>")).toBe("&lt;div&gt;");
-    expect(escapeHtml("a & b")).toBe("a &amp; b");
-    expect(escapeHtml('a "quoted" string')).toBe("a &quot;quoted&quot; string");
-    expect(escapeHtml("it's a test")).toBe("it&#039;s a test");
-    // Test with multiple special characters
-    expect(escapeHtml("<a href=\"test\">It's a link</a>")).toBe("&lt;a href=&quot;test&quot;&gt;It&#039;s a link&lt;/a&gt;");
+"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/html.tsx
+var html_exports = {};
+__export(html_exports, {
+  escapeHtml: () => escapeHtml,
+  html: () => html
 });
-export function html(strings, ...values) {
-    return templateIdentity(strings, ...values.map(v => escapeHtml(`${v}`)));
+module.exports = __toCommonJS(html_exports);
+var import_strings = require("./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 (0, import_strings.templateIdentity)(strings, ...values.map((v) => escapeHtml(`${v}`)));
 }
-import.meta.vitest?.test("html", ({ expect }) => {
-    // Test with no interpolation
-    expect(html `simple string`).toBe("simple string");
-    // Test with string interpolation
-    expect(html `Hello, ${"world"}!`).toBe("Hello, world!");
-    // Test with number interpolation
-    expect(html `Count: ${42}`).toBe("Count: 42");
-    // Test with HTML special characters in interpolated values
-    expect(html `<div>${"<script>"}</div>`).toBe("<div>&lt;script&gt;</div>");
-    // Test with multiple interpolations
-    expect(html `${1} + ${2} = ${"<3"}`).toBe("1 + 2 = &lt;3");
-    // Test with object interpolation
-    const obj = { toString: () => "<object>" };
-    expect(html `Object: ${obj}`).toBe("Object: &lt;object&gt;");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  escapeHtml,
+  html
 });
+//# sourceMappingURL=html.js.map

package/dist/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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAiC;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,aAAO,iCAAiB,SAAS,GAAG,OAAO,IAAI,OAAK,WAAW,GAAG,CAAC,EAAE,CAAC,CAAC;AACzE;","names":[]}