@wener/common 1.0.2 → 1.0.4

package/src/password/Password.ts

@@ -3,111 +3,89 @@ import { createPBKDF2PasswordAlgorithm } from './createPBKDF2PasswordAlgorithm';
 import { PHC } from './PHC';
 
 export namespace Password {
-  export interface ParsedPassword {
-    id: string;
-    version?: number;
-    params?: Record<string, string | number>;
-    salt?: Uint8Array;
-    hash?: Uint8Array;
-  }
+	export interface ParsedPassword {
+		id: string;
+		version?: number;
+		params?: Record<string, string | number>;
+		salt?: Uint8Array;
+		hash?: Uint8Array;
+	}
 
-  type PasswordAlgorithmHashOptions = {
-    rounds?: number;
-    salt?: Uint8Array;
-    id?: string;
-  };
-  type PasswordAlgorithmVerifyOptions = ParsedPassword;
-  export type PasswordAlgorithm = {
-    readonly name: string;
-    readonly ids?: string[];
-    hash(password: string, opts?: PasswordAlgorithmHashOptions): Promise<string>;
-    verify(password: string, hash: string, opts: PasswordAlgorithmVerifyOptions): Promise<boolean>;
-  };
+	type PasswordAlgorithmHashOptions = { rounds?: number; salt?: Uint8Array; id?: string };
+	type PasswordAlgorithmVerifyOptions = ParsedPassword;
+	export type PasswordAlgorithm = {
+		readonly name: string;
+		readonly ids?: string[];
+		hash(password: string, opts?: PasswordAlgorithmHashOptions): Promise<string>;
+		verify(password: string, hash: string, opts: PasswordAlgorithmVerifyOptions): Promise<boolean>;
+	};
 
-  const Algorithms: Record<string, string | PasswordAlgorithm> = {
-    1: 'md5',
-    '2a': 'bcrypt', // original
-    '2b': 'bcrypt', // February 2014
-    '2x': 'bcrypt', // June 2011
-    '2y': 'bcrypt', // June 2011
-    5: 'sha256',
-    6: 'sha512',
-    7: 'scrypt',
-  };
-  let DefaultAlgorithm: string = '6';
+	const Algorithms: Record<string, string | PasswordAlgorithm> = {
+		1: 'md5',
+		'2a': 'bcrypt', // original
+		'2b': 'bcrypt', // February 2014
+		'2x': 'bcrypt', // June 2011
+		'2y': 'bcrypt', // June 2011
+		5: 'sha256',
+		6: 'sha512',
+		7: 'scrypt',
+	};
+	let DefaultAlgorithm: string = '6';
 
-  export function setDefaultAlgorithm(algorithm: string) {
-    Errors.BadRequest.check(Algorithms[algorithm], `Unknown algorithm ${algorithm}`);
-    DefaultAlgorithm = algorithm;
-  }
+	export function setDefaultAlgorithm(algorithm: string) {
+		Errors.BadRequest.check(Algorithms[algorithm], `Unknown algorithm ${algorithm}`);
+		DefaultAlgorithm = algorithm;
+	}
 
-  export function getDefaultAlgorithm() {
-    return DefaultAlgorithm;
-  }
+	export function getDefaultAlgorithm() {
+		return DefaultAlgorithm;
+	}
 
-  export function addAlgorithm(algorithm: PasswordAlgorithm) {
-    Algorithms[algorithm.name] = algorithm;
-    if (algorithm.ids) {
-      for (const id of algorithm.ids) {
-        Algorithms[id] = algorithm;
-      }
-    }
-  }
+	export function addAlgorithm(algorithm: PasswordAlgorithm) {
+		Algorithms[algorithm.name] = algorithm;
+		if (algorithm.ids) {
+			for (const id of algorithm.ids) {
+				Algorithms[id] = algorithm;
+			}
+		}
+	}
 
-  addAlgorithm(
-    createPBKDF2PasswordAlgorithm({
-      id: 'sha256',
-      digest: 'SHA-256',
-    }),
-  );
-  addAlgorithm(
-    createPBKDF2PasswordAlgorithm({
-      id: 'sha512',
-      digest: 'SHA-512',
-    }),
-  );
+	addAlgorithm(createPBKDF2PasswordAlgorithm({ id: 'sha256', digest: 'SHA-256' }));
+	addAlgorithm(createPBKDF2PasswordAlgorithm({ id: 'sha512', digest: 'SHA-512' }));
 
-  export async function parse(hash: string) {
-    return PHC.deserialize(hash);
-  }
+	export async function parse(hash: string) {
+		return PHC.deserialize(hash);
+	}
 
-  function resolveAlgorithm(id: string | PasswordAlgorithm): PasswordAlgorithm {
-    let f = id;
-    while (typeof f === 'string') {
-      f = Algorithms[f];
-    }
-    if (!f) {
-      throw new Error(`Unknown algorithm ${id}`);
-    }
-    return f;
-  }
+	function resolveAlgorithm(id: string | PasswordAlgorithm): PasswordAlgorithm {
+		let f = id;
+		while (typeof f === 'string') {
+			f = Algorithms[f];
+		}
+		if (!f) {
+			throw new Error(`Unknown algorithm ${id}`);
+		}
+		return f;
+	}
 
-  export async function check(password: string, hash: string) {
-    let res = await parse(hash);
-    let f = resolveAlgorithm(res.id);
-    return {
-      result: f.verify(password, hash, res),
-      parsed: res,
-    };
-  }
+	export async function check(password: string, hash: string) {
+		let res = await parse(hash);
+		let f = resolveAlgorithm(res.id);
+		return { result: f.verify(password, hash, res), parsed: res };
+	}
 
-  export async function verify(password: string, hash: string) {
-    let res = await parse(hash);
-    let f = resolveAlgorithm(res.id);
-    return f.verify(password, hash, res);
-  }
+	export async function verify(password: string, hash: string) {
+		let res = await parse(hash);
+		let f = resolveAlgorithm(res.id);
+		return f.verify(password, hash, res);
+	}
 
-  export type PasswordHashOptions = PasswordAlgorithmHashOptions & {
-    algorithm?: string | PasswordAlgorithm;
-  };
+	export type PasswordHashOptions = PasswordAlgorithmHashOptions & { algorithm?: string | PasswordAlgorithm };
 
-  export async function hash(password: string, { algorithm, ...opts }: PasswordHashOptions = {}) {
-    let f = resolveAlgorithm(algorithm ?? DefaultAlgorithm);
-    let id = algorithm ?? DefaultAlgorithm;
-    typeof id !== 'string' && (id = f.name);
-    return f.hash(password, {
-      id,
-      ...opts,
-    });
-  }
+	export async function hash(password: string, { algorithm, ...opts }: PasswordHashOptions = {}) {
+		let f = resolveAlgorithm(algorithm ?? DefaultAlgorithm);
+		let id = algorithm ?? DefaultAlgorithm;
+		typeof id !== 'string' && (id = f.name);
+		return f.hash(password, { id, ...opts });
+	}
 }

package/src/password/createArgon2PasswordAlgorithm.ts

@@ -2,79 +2,75 @@ import { maybeFunction, type MaybeFunction, type MaybePromise } from '@wener/uti
 import { Password } from './Password';
 
 type Provide = {
-  hash: (password: string, options: { salt?: Buffer; raw?: boolean; type?: 0 | 1 | 2 }) => Promise<string>;
-  verify: (hash: string, password: string) => Promise<boolean>;
+	hash: (password: string, options: { salt?: Buffer; raw?: boolean; type?: 0 | 1 | 2 }) => Promise<string>;
+	verify: (hash: string, password: string) => Promise<boolean>;
 };
 
 export function createArgon2PasswordAlgorithm({
-  type,
-  provide = async () => {
-    throw new Error('Please provide argon2');
-    // const { default: wasm } = await import('argon2-browser/dist/argon2.wasm');
-    // const argon2 = await WebAssembly.instantiateStreaming(fetch(wasm), {
-    //   env: {
-    //     memoryBase: 0,
-    //     tableBase: 0,
-    //     memory: new WebAssembly.Memory({ initial: 256 }),
-    //     table: new WebAssembly.Table({ initial: 0, element: 'anyfunc' }),
-    //     __memory_base: 0,
-    //     __table_base: 0,
-    //   },
-    // });
-    // console.log(argon2.instance.exports);
-    // const { hash } = argon2.instance.exports as any as typeof import('argon2-browser');
-  },
-  // argon2-browser/dist/argon2-bundled.min.js
-  // import('argon2-browser').then(({ default: { hash, verify } }) => {
-  //   return {
-  //     hash(password, options) {
-  //       return hash({
-  //         pass: password,
-  //       });
-  //     },
-  //     verify(hash, password) {
-  //       return verify({
-  //         pass: password,
-  //         hash: hash,
-  //       })
-  //         .then(() => true)
-  //         .catch(() => false);
-  //     },
-  //   };
-  // }),
-  // provide = () => import('argon2'),
+	type,
+	provide = async () => {
+		throw new Error('Please provide argon2');
+		// const { default: wasm } = await import('argon2-browser/dist/argon2.wasm');
+		// const argon2 = await WebAssembly.instantiateStreaming(fetch(wasm), {
+		//   env: {
+		//     memoryBase: 0,
+		//     tableBase: 0,
+		//     memory: new WebAssembly.Memory({ initial: 256 }),
+		//     table: new WebAssembly.Table({ initial: 0, element: 'anyfunc' }),
+		//     __memory_base: 0,
+		//     __table_base: 0,
+		//   },
+		// });
+		// console.log(argon2.instance.exports);
+		// const { hash } = argon2.instance.exports as any as typeof import('argon2-browser');
+	},
+	// argon2-browser/dist/argon2-bundled.min.js
+	// import('argon2-browser').then(({ default: { hash, verify } }) => {
+	//   return {
+	//     hash(password, options) {
+	//       return hash({
+	//         pass: password,
+	//       });
+	//     },
+	//     verify(hash, password) {
+	//       return verify({
+	//         pass: password,
+	//         hash: hash,
+	//       })
+	//         .then(() => true)
+	//         .catch(() => false);
+	//     },
+	//   };
+	// }),
+	// provide = () => import('argon2'),
 }: {
-  type?: 'argon2d' | 'argon2i' | 'argon2id';
-  provide?: MaybeFunction<MaybePromise<Provide>>;
+	type?: 'argon2d' | 'argon2i' | 'argon2id';
+	provide?: MaybeFunction<MaybePromise<Provide>>;
 } = {}): Password.PasswordAlgorithm {
-  // 0=Argon2d, 1=Argon2i, 2=Argon2id
-  const toType: Record<string, 0 | 1 | 2 | undefined> = {
-    argon2d: 0,
-    argon2i: 1,
-    argon2id: 2,
-  } as const;
+	// 0=Argon2d, 1=Argon2i, 2=Argon2id
+	const toType: Record<string, 0 | 1 | 2 | undefined> = { argon2d: 0, argon2i: 1, argon2id: 2 } as const;
 
-  let mod: Provide;
-  const resolve = () => {
-    if (mod) return mod;
-    return Promise.resolve(maybeFunction(provide)).then((v) => (mod = v));
-  };
-  return {
-    name: 'argon2',
-    ids: ['argon2i', 'argon2d', 'argon2id'],
-    async hash(password: string, opts) {
-      // const { hash } = await import('argon2');
-      const { hash } = await resolve();
-      const id = opts?.id;
-      return hash(password, {
-        salt: opts?.salt ? Buffer.from(opts.salt) : undefined,
-        raw: false,
-        type: toType[id || ''] ?? toType[type || ''],
-      });
-    },
-    async verify(password: string, hash: string) {
-      const { verify } = await resolve();
-      return verify(hash, password);
-    },
-  };
+	let mod: Provide;
+	const resolve = () => {
+		if (mod) return mod;
+		return Promise.resolve(maybeFunction(provide)).then((v) => (mod = v));
+	};
+	return {
+		name: 'argon2',
+		ids: ['argon2i', 'argon2d', 'argon2id'],
+		async hash(password: string, opts) {
+			// const { hash } = await import('argon2');
+			const { hash } = await resolve();
+			const id = opts?.id;
+			return hash(password, {
+				salt: opts?.salt ? Buffer.from(opts.salt) : undefined,
+				raw: false,
+				type: toType[id || ''] ?? toType[type || ''],
+			});
+		},
+		async verify(password: string, hash: string) {
+			const { verify } = await resolve();
+			return verify(hash, password);
+		},
+	};
 }

package/src/password/createBase64PasswordAlgorithm.ts

@@ -2,13 +2,13 @@ import { ArrayBuffers } from '@wener/utils';
 import { Password } from './Password';
 
 export function createBase64PasswordAlgorithm({ id = 'base64' }: { id?: string } = {}): Password.PasswordAlgorithm {
-  return {
-    name: id,
-    async hash(password: string) {
-      return `$${id}$$${ArrayBuffers.toBase64(password).replace(/=/g, '')}`;
-    },
-    async verify(password: string, hash: string, opts) {
-      return Boolean(opts.hash) && ArrayBuffers.toString(opts.hash!) === password;
-    },
-  };
+	return {
+		name: id,
+		async hash(password: string) {
+			return `$${id}$$${ArrayBuffers.toBase64(password).replace(/=/g, '')}`;
+		},
+		async verify(password: string, hash: string, opts) {
+			return Boolean(opts.hash) && ArrayBuffers.toString(opts.hash!) === password;
+		},
+	};
 }

package/src/password/createBcryptPasswordAlgorithm.ts

@@ -2,29 +2,27 @@ import type { MaybePromise } from '@wener/utils';
 import { Password } from './Password';
 
 type ProviderType = () => MaybePromise<{
-  hash: (password: string, rounds: number | string) => Promise<string>;
-  compare: (password: string, hash: string) => Promise<boolean>;
+	hash: (password: string, rounds: number | string) => Promise<string>;
+	compare: (password: string, hash: string) => Promise<boolean>;
 }>;
 
 export function createBcryptPasswordAlgorithm({
-  // provider = () => import('bcrypt').then((v) => v.default),
-  provider = () => import('bcryptjs').then((v) => v.default),
-}: {
-  provider?: ProviderType;
-} = {}): Password.PasswordAlgorithm {
-  // bcrypt or bcryptjs
-  return {
-    name: 'bcrypt',
-    async hash(password: string, opts) {
-      const { hash } = await provider();
-      return hash(password, opts?.rounds ?? 10);
-    },
-    async verify(password: string, hash: string) {
-      const { compare } = await provider();
-      if (hash.startsWith('$2y$')) {
-        hash = hash.replace(/^\$2y\$/, '$2a$');
-      }
-      return compare(password, hash);
-    },
-  };
+	// provider = () => import('bcrypt').then((v) => v.default),
+	provider = () => import('bcryptjs').then((v) => v.default),
+}: { provider?: ProviderType } = {}): Password.PasswordAlgorithm {
+	// bcrypt or bcryptjs
+	return {
+		name: 'bcrypt',
+		async hash(password: string, opts) {
+			const { hash } = await provider();
+			return hash(password, opts?.rounds ?? 10);
+		},
+		async verify(password: string, hash: string) {
+			const { compare } = await provider();
+			if (hash.startsWith('$2y$')) {
+				hash = hash.replace(/^\$2y\$/, '$2a$');
+			}
+			return compare(password, hash);
+		},
+	};
 }

package/src/password/createPBKDF2PasswordAlgorithm.ts

@@ -3,71 +3,59 @@ import { Password } from './Password';
 import { PHC } from './PHC';
 
 export function createPBKDF2PasswordAlgorithm({
-  id,
-  digest,
-  iterations = 100000,
-  saltlen = 16,
-  keylen = digest === 'SHA-256' ? 32 : 64,
+	id,
+	digest,
+	iterations = 100000,
+	saltlen = 16,
+	keylen = digest === 'SHA-256' ? 32 : 64,
 }: {
-  id: string;
-  digest: 'SHA-256' | 'SHA-512';
-  iterations?: number;
-  keylen?: number;
-  saltlen?: number;
+	id: string;
+	digest: 'SHA-256' | 'SHA-512';
+	iterations?: number;
+	keylen?: number;
+	saltlen?: number;
 }): Password.PasswordAlgorithm {
-  return {
-    name: id,
-    async hash(password: string, opts) {
-      let salt: Uint8Array;
+	return {
+		name: id,
+		async hash(password: string, opts) {
+			let salt: Uint8Array;
 
-      if (opts?.salt) {
-        salt = opts.salt;
-      } else {
-        salt = new Uint8Array(saltlen);
-        crypto.getRandomValues(salt);
-      }
+			if (opts?.salt) {
+				salt = opts.salt;
+			} else {
+				salt = new Uint8Array(saltlen);
+				crypto.getRandomValues(salt);
+			}
 
-      const rounds = opts?.rounds ?? iterations;
+			const rounds = opts?.rounds ?? iterations;
 
-      let key = await crypto.subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, [
-        'deriveBits',
-      ]);
-      let hash = await crypto.subtle.deriveBits(
-        { name: 'PBKDF2', iterations: rounds, salt, hash: digest },
-        key,
-        keylen * 8,
-      );
-      return PHC.serialize({
-        id: opts?.id ?? id,
-        params: {
-          rounds,
-        },
-        salt,
-        hash: new Uint8Array(hash),
-      });
-    },
-    async verify(password: string, _: string, opts) {
-      const rounds = opts?.params?.rounds ?? iterations;
-      const salt = opts.salt;
-      const storedHash = opts.hash;
-      Errors.BadRequest.check(typeof rounds === 'number', 'Invalid rounds');
-      Errors.BadRequest.check(salt instanceof Uint8Array, 'Invalid salt');
-      Errors.BadRequest.check(storedHash instanceof Uint8Array, 'Invalid hash');
+			let key = await crypto.subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, [
+				'deriveBits',
+			]);
+			let hash = await crypto.subtle.deriveBits(
+				{ name: 'PBKDF2', iterations: rounds, salt, hash: digest },
+				key,
+				keylen * 8,
+			);
+			return PHC.serialize({ id: opts?.id ?? id, params: { rounds }, salt, hash: new Uint8Array(hash) });
+		},
+		async verify(password: string, _: string, opts) {
+			const rounds = opts?.params?.rounds ?? iterations;
+			const salt = opts.salt;
+			const storedHash = opts.hash;
+			Errors.BadRequest.check(typeof rounds === 'number', 'Invalid rounds');
+			Errors.BadRequest.check(salt instanceof Uint8Array, 'Invalid salt');
+			Errors.BadRequest.check(storedHash instanceof Uint8Array, 'Invalid hash');
 
-      let key = await crypto.subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, [
-        'deriveBits',
-      ]);
-      let hash = await crypto.subtle.deriveBits(
-        {
-          name: 'PBKDF2',
-          iterations: rounds,
-          salt,
-          hash: digest,
-        },
-        key,
-        storedHash.length * 8,
-      );
-      return new Uint8Array(hash).every((v, i) => v === storedHash![i]);
-    },
-  };
+			let key = await crypto.subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, [
+				'deriveBits',
+			]);
+			let hash = await crypto.subtle.deriveBits(
+				{ name: 'PBKDF2', iterations: rounds, salt, hash: digest },
+				key,
+				storedHash.length * 8,
+			);
+			return new Uint8Array(hash).every((v, i) => v === storedHash![i]);
+		},
+	};
 }

package/src/password/createScryptPasswordAlgorithm.ts

@@ -4,69 +4,58 @@ import { Password } from './Password';
 import { PHC } from './PHC';
 
 export function createScryptPasswordAlgorithm(
-  options: {
-    id?: string;
-    cost?: number;
-    blocksize?: number;
-    parallelism?: number;
-    saltlen?: number;
-    keylen?: number;
-  } = {},
+	options: {
+		id?: string;
+		cost?: number;
+		blocksize?: number;
+		parallelism?: number;
+		saltlen?: number;
+		keylen?: number;
+	} = {},
 ): Password.PasswordAlgorithm {
-  let id = options.id || 'scrypt';
-  options.cost ||= Math.pow(2, 14);
-  options.blocksize ||= 8;
-  options.parallelism ||= 1;
-  options.saltlen ||= 16;
-  options.keylen ||= 32;
-  return {
-    name: id,
-    async hash(password: string, opts): Promise<string> {
-      const salt = opts?.salt || randomBytes(options.saltlen!);
-      return new Promise((resolve, reject) => {
-        let N = options.cost!;
-        let r = options.blocksize!;
-        let p = options.parallelism!;
-        scrypt(password, salt, options.keylen!, { N, r, p }, (err, derivedKey) => {
-          if (err) return reject(err);
+	let id = options.id || 'scrypt';
+	options.cost ||= Math.pow(2, 14);
+	options.blocksize ||= 8;
+	options.parallelism ||= 1;
+	options.saltlen ||= 16;
+	options.keylen ||= 32;
+	return {
+		name: id,
+		async hash(password: string, opts): Promise<string> {
+			const salt = opts?.salt || randomBytes(options.saltlen!);
+			return new Promise((resolve, reject) => {
+				let N = options.cost!;
+				let r = options.blocksize!;
+				let p = options.parallelism!;
+				scrypt(password, salt, options.keylen!, { N, r, p }, (err, derivedKey) => {
+					if (err) return reject(err);
 
-          resolve(
-            PHC.serialize({
-              id: opts?.id ?? id,
-              params: {
-                ln: N!,
-                r: r!,
-                p: p!,
-              },
-              salt,
-              hash: derivedKey,
-            }),
-          );
-        });
-      });
-    },
+					resolve(PHC.serialize({ id: opts?.id ?? id, params: { ln: N!, r: r!, p: p! }, salt, hash: derivedKey }));
+				});
+			});
+		},
 
-    async verify(password: string, hash: string, opts): Promise<boolean> {
-      try {
-        const salt = Errors.BadRequest.require(opts.salt);
-        const storedHash = Errors.BadRequest.require(opts.hash);
+		async verify(password: string, hash: string, opts): Promise<boolean> {
+			try {
+				const salt = Errors.BadRequest.require(opts.salt);
+				const storedHash = Errors.BadRequest.require(opts.hash);
 
-        const N = parseInt(opts.params?.ln as string, 10);
-        const r = parseInt(opts.params?.r as string, 10);
-        const p = parseInt(opts.params?.p as string, 10);
-        const keylen = storedHash.length;
+				const N = parseInt(opts.params?.ln as string, 10);
+				const r = parseInt(opts.params?.r as string, 10);
+				const p = parseInt(opts.params?.p as string, 10);
+				const keylen = storedHash.length;
 
-        return new Promise((resolve, reject) => {
-          scrypt(password, salt, keylen, { N, r, p }, (err, derivedKey) => {
-            if (err) return reject(err);
+				return new Promise((resolve, reject) => {
+					scrypt(password, salt, keylen, { N, r, p }, (err, derivedKey) => {
+						if (err) return reject(err);
 
-            const isMatch = timingSafeEqual(derivedKey, storedHash);
-            resolve(isMatch);
-          });
-        });
-      } catch (error) {
-        return Promise.resolve(false);
-      }
-    },
-  };
+						const isMatch = timingSafeEqual(derivedKey, storedHash);
+						resolve(isMatch);
+					});
+				});
+			} catch (error) {
+				return Promise.resolve(false);
+			}
+		},
+	};
 }