@wener/utils 1.1.50 → 1.1.53

package/src/crypto/pem/pem.test.ts

@@ -5,7 +5,7 @@ import { PEM } from './pem';
 const { decode, encode } = PEM;
 
 test('pem', () => {
-  const pem = `-----BEGIN RSA PRIVATE KEY-----
+	const pem = `-----BEGIN RSA PRIVATE KEY-----
 Proc-Type: 4,ENCRYPTED
 DEK-Info: DES-EDE3-CBC,ABC
 
@@ -13,48 +13,32 @@ MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw
 MDAwMDAwMDAwMDAwMDAwMA==
 -----END RSA PRIVATE KEY-----
 `;
-  const input = `Nice\n${pem}Hello
+	const input = `Nice\n${pem}Hello
 `;
-  const out = {
-    block: {
-      type: 'RSA PRIVATE KEY',
-      header: {
-        'Proc-Type': '4,ENCRYPTED',
-        'DEK-Info': 'DES-EDE3-CBC,ABC',
-      },
-      bytes: ArrayBuffers.from('0'.repeat(64)),
-    },
-    head: 'Nice\n',
-    tail: 'Hello\n',
-  };
-  expect(decode(input)).toEqual(out);
-  expect(encode(out.block)).toBe(pem);
+	const out = {
+		block: {
+			type: 'RSA PRIVATE KEY',
+			header: { 'Proc-Type': '4,ENCRYPTED', 'DEK-Info': 'DES-EDE3-CBC,ABC' },
+			bytes: ArrayBuffers.from('0'.repeat(64)),
+		},
+		head: 'Nice\n',
+		tail: 'Hello\n',
+	};
+	expect(decode(input)).toEqual(out);
+	expect(encode(out.block)).toBe(pem);
 });
 test('cases', () => {
-  for (const b of [
-    {
-      type: 'RSA PRIVATE KEY',
-      bytes: 'Hello',
-    },
-    {
-      type: 'RSA PRIVATE KEY',
-      header: {
-        Name: 'N-:1/=',
-        Age: '1234',
-      },
-      bytes: ArrayBuffers.from('Nice'),
-    },
-  ]) {
-    const s = encode(b);
-    const act = decode(s);
-    expect({
-      ...act.block,
-      bytes: ArrayBuffers.toString(act.block.bytes),
-    }).toStrictEqual({
-      header: {},
-      ...b,
-      bytes: ArrayBuffers.toString(b.bytes),
-    });
-    expect(s).matchSnapshot();
-  }
+	for (const b of [
+		{ type: 'RSA PRIVATE KEY', bytes: 'Hello' },
+		{ type: 'RSA PRIVATE KEY', header: { Name: 'N-:1/=', Age: '1234' }, bytes: ArrayBuffers.from('Nice') },
+	]) {
+		const s = encode(b);
+		const act = decode(s);
+		expect({ ...act.block, bytes: ArrayBuffers.toString(act.block.bytes) }).toStrictEqual({
+			header: {},
+			...b,
+			bytes: ArrayBuffers.toString(b.bytes),
+		});
+		expect(s).matchSnapshot();
+	}
 });

package/src/crypto/pem/pem.ts

@@ -1,74 +1,74 @@
 import { ArrayBuffers } from '../../io/ArrayBuffers';
 
 export interface Block {
-  /**
-   * @see https://github.com/openssl/openssl/blob/master/include/openssl/pem.h#L35-L60 openssl/pem.h
-   */
-  type:
-    | string
-    | `${'RSA' | 'DSA'} ${'PRIVATE' | 'PUBLIC'} KEY`
-    | `${'X509' | 'TRUSTED'} CERTIFICATE`
-    | 'CERTIFICATE'
-    | 'X509 CRL'
-    | 'CERTIFICATE REQUEST'
-    | 'NEW CERTIFICATE REQUEST'
-    | 'ANY PRIVATE KEY'
-    | 'PUBLIC KEY'
-    | 'PKCS7'
-    | 'PKCS #7 SIGNED DATA'
-    | 'ENCRYPTED PRIVATE KEY'
-    | 'PRIVATE KEY'
-    | 'DH PARAMETERS'
-    | 'X9.42 DH PARAMETERS'
-    | 'SSL SESSION PARAMETERS'
-    | 'DSA PARAMETERS'
-    | 'ECDSA PUBLIC KEY'
-    | 'EC PARAMETERS'
-    | 'EC PRIVATE KEY'
-    | 'PARAMETERS'
-    | 'CMS'
-    | 'SM2 PARAMETERS';
+	/**
+	 * @see https://github.com/openssl/openssl/blob/master/include/openssl/pem.h#L35-L60 openssl/pem.h
+	 */
+	type:
+		| string
+		| `${'RSA' | 'DSA'} ${'PRIVATE' | 'PUBLIC'} KEY`
+		| `${'X509' | 'TRUSTED'} CERTIFICATE`
+		| 'CERTIFICATE'
+		| 'X509 CRL'
+		| 'CERTIFICATE REQUEST'
+		| 'NEW CERTIFICATE REQUEST'
+		| 'ANY PRIVATE KEY'
+		| 'PUBLIC KEY'
+		| 'PKCS7'
+		| 'PKCS #7 SIGNED DATA'
+		| 'ENCRYPTED PRIVATE KEY'
+		| 'PRIVATE KEY'
+		| 'DH PARAMETERS'
+		| 'X9.42 DH PARAMETERS'
+		| 'SSL SESSION PARAMETERS'
+		| 'DSA PARAMETERS'
+		| 'ECDSA PUBLIC KEY'
+		| 'EC PARAMETERS'
+		| 'EC PRIVATE KEY'
+		| 'PARAMETERS'
+		| 'CMS'
+		| 'SM2 PARAMETERS';
 
-  header: Record<string, string>;
-  bytes: BufferSource;
+	header: Record<string, string>;
+	bytes: BufferSource;
 }
 
 export class PEM {
-  static decode(data: string): { block: Block; tail: string; head: string } {
-    const match = data.match(
-      /^-----BEGIN (?<type>[^\r\n-]+)-----$\r?\n(?<headers>(^[^:\r\n]+:[^\n\r]+\r?\n)+\r?\n)?(?<data>[a-zA-Z0-9/_=\n\r+]+?)^-----END \1-----$\r?\n?/ms,
-    );
-    if (!match?.groups) throw new Error('Invalid PEM data');
-    const { type, headers = '', data: b64 } = match.groups;
-    const header = headers
-      .split('\n')
-      .filter((v) => v.trim())
-      .map((h) => {
-        const [k, ...v] = h.split(':');
-        return [k.trim(), v.join(':').trim()];
-      })
-      .reduce((a, [k, v]) => ({ ...a, [k]: v }), {});
-    return {
-      block: {
-        type,
-        header,
-        //  avoid replaceAll
-        bytes: ArrayBuffers.from(b64.replace(/[\r\n]/g, ''), 'base64'),
-      },
-      head: data.slice(0, match.index || 0),
-      tail: data.slice((match.index || 0) + match[0].length),
-    };
-  }
+	static decode(data: string): { block: Block; tail: string; head: string } {
+		const match = data.match(
+			/^-----BEGIN (?<type>[^\r\n-]+)-----$\r?\n(?<headers>(^[^:\r\n]+:[^\n\r]+\r?\n)+\r?\n)?(?<data>[a-zA-Z0-9/_=\n\r+]+?)^-----END \1-----$\r?\n?/ms,
+		);
+		if (!match?.groups) throw new Error('Invalid PEM data');
+		const { type, headers = '', data: b64 } = match.groups;
+		const header = headers
+			.split('\n')
+			.filter((v) => v.trim())
+			.map((h) => {
+				const [k, ...v] = h.split(':');
+				return [k.trim(), v.join(':').trim()];
+			})
+			.reduce((a, [k, v]) => ({ ...a, [k]: v }), {});
+		return {
+			block: {
+				type,
+				header,
+				//  avoid replaceAll
+				bytes: ArrayBuffers.from(b64.replace(/[\r\n]/g, ''), 'base64'),
+			},
+			head: data.slice(0, match.index || 0),
+			tail: data.slice((match.index || 0) + match[0].length),
+		};
+	}
 
-  static encode(block: { type: string; bytes: string | BufferSource; header?: Record<string, string> }): string {
-    const { type, header, bytes } = block;
-    const headers = Object.entries(header || {})
-      .map(([k, v]) => `${k}: ${v}`)
-      .join('\n');
-    return `-----BEGIN ${type}-----\n${headers}${headers.length ? '\n\n' : ''}${
-      ArrayBuffers.toString(bytes, 'base64')
-        .match(/.{1,64}/g)
-        ?.join('\n') || ''
-    }\n-----END ${type}-----\n`;
-  }
+	static encode(block: { type: string; bytes: string | BufferSource; header?: Record<string, string> }): string {
+		const { type, header, bytes } = block;
+		const headers = Object.entries(header || {})
+			.map(([k, v]) => `${k}: ${v}`)
+			.join('\n');
+		return `-----BEGIN ${type}-----\n${headers}${headers.length ? '\n\n' : ''}${
+			ArrayBuffers.toString(bytes, 'base64')
+				.match(/.{1,64}/g)
+				?.join('\n') || ''
+		}\n-----END ${type}-----\n`;
+	}
 }

package/src/crypto/ulid.test.ts

@@ -1,43 +1,43 @@
 import { expect, test } from 'vitest';
-import { randomUUID } from './randomUUID';
+import { randomUUID } from '../web/randomUUID';
 import { createULID, isULID, parseULID, ulid } from './ulid';
 
 test('isULID', () => {
-  for (const [a, b] of [
-    [undefined, false],
-    [null, false],
-    ['', false],
-    [randomUUID(), false],
-    [ulid(), true],
-  ] as const) {
-    expect(isULID(a), `${a} -> ${b}`).toEqual(b);
-  }
+	for (const [a, b] of [
+		[undefined, false],
+		[null, false],
+		['', false],
+		[randomUUID(), false],
+		[ulid(), true],
+	] as const) {
+		expect(isULID(a), `${a} -> ${b}`).toEqual(b);
+	}
 });
 
 test('ulid', () => {
-  // monotonic
-  {
-    let lastTime = 0;
-    const ulid = createULID({
-      now: () => {
-        lastTime ||= Date.now();
-        return lastTime;
-      },
-    });
+	// monotonic
+	{
+		let lastTime = 0;
+		const ulid = createULID({
+			now: () => {
+				lastTime ||= Date.now();
+				return lastTime;
+			},
+		});
 
-    const ulid1 = ulid();
-    expect(parseULID(ulid1).timestamp).toBe(lastTime);
-    expect(isULID(ulid1), ulid1).toBeTruthy();
+		const ulid1 = ulid();
+		expect(parseULID(ulid1).timestamp).toBe(lastTime);
+		expect(isULID(ulid1), ulid1).toBeTruthy();
 
-    const ulid2 = ulid();
-    expect(ulid1 < ulid2).toBeTruthy();
-    expect(isULID(ulid2), ulid2).toBeTruthy();
-    expect(parseULID(ulid2).timestamp).toBe(lastTime);
-  }
+		const ulid2 = ulid();
+		expect(ulid1 < ulid2).toBeTruthy();
+		expect(isULID(ulid2), ulid2).toBeTruthy();
+		expect(parseULID(ulid2).timestamp).toBe(lastTime);
+	}
 
-  {
-    const next = createULID();
-    expect(isULID(next().toLowerCase())).toBeTruthy();
-    expect(isULID('ttttttttttrrrrrrrrrrrrrrrr')).toBeTruthy();
-  }
+	{
+		const next = createULID();
+		expect(isULID(next().toLowerCase())).toBeTruthy();
+		expect(isULID('ttttttttttrrrrrrrrrrrrrrrr')).toBeTruthy();
+	}
 });

package/src/crypto/ulid.ts

@@ -1,4 +1,4 @@
-import { getRandomValues } from './getRandomValues';
+import { getRandomValues } from '../web/getRandomValues';
 
 type PRNG = () => number;
 
@@ -10,13 +10,13 @@ type PRNG = () => number;
 export type ULID = (seedTime?: number) => string;
 
 export interface ULIDError extends Error {
-  source: string;
+	source: string;
 }
 
 function createError(message: string): ULIDError {
-  const err = new Error(message) as ULIDError;
-  err.source = 'ulid';
-  return err;
+	const err = new Error(message) as ULIDError;
+	err.source = 'ulid';
+	return err;
 }
 
 // These values should NEVER change. If
@@ -31,81 +31,81 @@ const RANDOM_LEN = 16;
  * check give {@link str} is a valid ulid
  */
 export function isULID(str: string | undefined | null): boolean {
-  if (!str) {
-    return false;
-  }
-  // ttttttttttrrrrrrrrrrrrrrrr
-  return str.length === 26 && /^[0-9A-HJKMNP-TV-Z]{26}$/i.test(str);
+	if (!str) {
+		return false;
+	}
+	// ttttttttttrrrrrrrrrrrrrrrr
+	return str.length === 26 && /^[0-9A-HJKMNP-TV-Z]{26}$/i.test(str);
 }
 
 function replaceCharAt(str: string, index: number, char: string) {
-  if (index > str.length - 1) {
-    return str;
-  }
-  return str.substr(0, index) + char + str.substr(index + 1);
+	if (index > str.length - 1) {
+		return str;
+	}
+	return str.substr(0, index) + char + str.substr(index + 1);
 }
 
 function incrementBase32(str: string): string {
-  let done;
-  let index = str.length;
-  let char;
-  let charIndex;
-  const maxCharIndex = ENCODING_LEN - 1;
-  while (!done && index-- >= 0) {
-    char = str[index];
-    charIndex = ENCODING.indexOf(char);
-    if (charIndex === -1) {
-      throw createError('incorrectly encoded string');
-    }
-    if (charIndex === maxCharIndex) {
-      str = replaceCharAt(str, index, ENCODING[0]);
-      continue;
-    }
-    done = replaceCharAt(str, index, ENCODING[charIndex + 1]);
-  }
-  if (typeof done === 'string') {
-    return done;
-  }
-  throw createError('cannot increment this string');
+	let done;
+	let index = str.length;
+	let char;
+	let charIndex;
+	const maxCharIndex = ENCODING_LEN - 1;
+	while (!done && index-- >= 0) {
+		char = str[index];
+		charIndex = ENCODING.indexOf(char);
+		if (charIndex === -1) {
+			throw createError('incorrectly encoded string');
+		}
+		if (charIndex === maxCharIndex) {
+			str = replaceCharAt(str, index, ENCODING[0]);
+			continue;
+		}
+		done = replaceCharAt(str, index, ENCODING[charIndex + 1]);
+	}
+	if (typeof done === 'string') {
+		return done;
+	}
+	throw createError('cannot increment this string');
 }
 
 function randomChar(prng: PRNG): string {
-  let rand = Math.floor(prng() * ENCODING_LEN);
-  if (rand === ENCODING_LEN) {
-    rand = ENCODING_LEN - 1;
-  }
-  return ENCODING.charAt(rand);
+	let rand = Math.floor(prng() * ENCODING_LEN);
+	if (rand === ENCODING_LEN) {
+		rand = ENCODING_LEN - 1;
+	}
+	return ENCODING.charAt(rand);
 }
 
 function encodeTime(now: number, len: number): string {
-  if (isNaN(now)) {
-    throw new Error(`${now} must be a number`);
-  }
-  if (now > TIME_MAX) {
-    throw createError(`cannot encode time greater than ${TIME_MAX}`);
-  }
-  if (now < 0) {
-    throw createError('time must be positive');
-  }
-  if (!Number.isInteger(now)) {
-    throw createError('time must be an integer');
-  }
-  let mod;
-  let str = '';
-  for (; len > 0; len--) {
-    mod = now % ENCODING_LEN;
-    str = ENCODING.charAt(mod) + str;
-    now = (now - mod) / ENCODING_LEN;
-  }
-  return str;
+	if (isNaN(now)) {
+		throw new Error(`${now} must be a number`);
+	}
+	if (now > TIME_MAX) {
+		throw createError(`cannot encode time greater than ${TIME_MAX}`);
+	}
+	if (now < 0) {
+		throw createError('time must be positive');
+	}
+	if (!Number.isInteger(now)) {
+		throw createError('time must be an integer');
+	}
+	let mod;
+	let str = '';
+	for (; len > 0; len--) {
+		mod = now % ENCODING_LEN;
+		str = ENCODING.charAt(mod) + str;
+		now = (now - mod) / ENCODING_LEN;
+	}
+	return str;
 }
 
 function encodeRandom(len: number, prng: PRNG): string {
-  let str = '';
-  for (; len > 0; len--) {
-    str = randomChar(prng) + str;
-  }
-  return str;
+	let str = '';
+	for (; len > 0; len--) {
+		str = randomChar(prng) + str;
+	}
+	return str;
 }
 
 /**
@@ -114,73 +114,73 @@ function encodeRandom(len: number, prng: PRNG): string {
  * @throws ULIDError
  */
 export function parseULID(id: string): { timestamp: number; random: string } {
-  if (id.length !== TIME_LEN + RANDOM_LEN) {
-    throw createError('malformed ulid');
-  }
-  const time = id
-    .substr(0, TIME_LEN)
-    .split('')
-    .reverse()
-    .reduce((carry, char, index) => {
-      const encodingIndex = ENCODING.indexOf(char);
-      if (encodingIndex === -1) {
-        throw createError('invalid character found: ' + char);
-      }
-      return (carry += encodingIndex * Math.pow(ENCODING_LEN, index));
-    }, 0);
-  if (time > TIME_MAX) {
-    throw createError('malformed ulid, timestamp too large');
-  }
-  return { timestamp: time, random: id.substring(TIME_LEN) };
+	if (id.length !== TIME_LEN + RANDOM_LEN) {
+		throw createError('malformed ulid');
+	}
+	const time = id
+		.substr(0, TIME_LEN)
+		.split('')
+		.reverse()
+		.reduce((carry, char, index) => {
+			const encodingIndex = ENCODING.indexOf(char);
+			if (encodingIndex === -1) {
+				throw createError('invalid character found: ' + char);
+			}
+			return (carry += encodingIndex * Math.pow(ENCODING_LEN, index));
+		}, 0);
+	if (time > TIME_MAX) {
+		throw createError('malformed ulid, timestamp too large');
+	}
+	return { timestamp: time, random: id.substring(TIME_LEN) };
 }
 
 function createPrng(): PRNG {
-  return () => {
-    const buffer = new Uint8Array(1);
-    getRandomValues(buffer);
-    return buffer[0] / 0xff;
-  };
+	return () => {
+		const buffer = new Uint8Array(1);
+		getRandomValues(buffer);
+		return buffer[0] / 0xff;
+	};
 }
 
 /**
  * create a ulid generator
  */
 export function createULID({
-  monotonic = true,
-  random = createPrng(),
-  now = Date.now,
+	monotonic = true,
+	random = createPrng(),
+	now = Date.now,
 }: { monotonic?: boolean; now?: () => number; random?: () => number } = {}) {
-  if (!monotonic) {
-    return function ulid(seedTime?: number): string {
-      seedTime ||= now();
-      return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN, random);
-    };
-  }
-
-  let lastTime: number = 0;
-  let lastRandom: string;
-  return function ulid(seedTime?: number): string {
-    seedTime ||= now();
-    if (seedTime <= lastTime && lastRandom) {
-      const incrementedRandom = (lastRandom = incrementBase32(lastRandom));
-      return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
-    }
-    lastTime = seedTime;
-    const newRandom = (lastRandom = encodeRandom(RANDOM_LEN, random));
-    return encodeTime(seedTime, TIME_LEN) + newRandom;
-  };
+	if (!monotonic) {
+		return function ulid(seedTime?: number): string {
+			seedTime ||= now();
+			return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN, random);
+		};
+	}
+
+	let lastTime: number = 0;
+	let lastRandom: string;
+	return function ulid(seedTime?: number): string {
+		seedTime ||= now();
+		if (seedTime <= lastTime && lastRandom) {
+			const incrementedRandom = (lastRandom = incrementBase32(lastRandom));
+			return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
+		}
+		lastTime = seedTime;
+		const newRandom = (lastRandom = encodeRandom(RANDOM_LEN, random));
+		return encodeTime(seedTime, TIME_LEN) + newRandom;
+	};
 }
 
 /**
  * default monotonic ulid generator
  */
 export let ulid: ULID = (...args) => {
-  if (_real) {
-    return _real(...args);
-  }
-  // delay initialize crypto
-  _real = createULID();
-  ulid = _real;
-  return _real(...args);
+	if (_real) {
+		return _real(...args);
+	}
+	// delay initialize crypto
+	_real = createULID();
+	ulid = _real;
+	return _real(...args);
 };
 let _real: ULID;

package/src/emitter/types.ts

@@ -4,15 +4,15 @@ export type Handler<E extends keyof T, T = Record<string, unknown>> = (evt: { ty
 export type WildcardHandler<T = Record<string, unknown>> = <E extends keyof T>(evt: { type: E; payload: T[E] }) => void;
 
 export interface Emitter<Events extends Record<EventType, unknown>> {
-  on<Key extends keyof Events>(type: Key, handler: Handler<Key, Events>): void;
+	on<Key extends keyof Events>(type: Key, handler: Handler<Key, Events>): void;
 
-  on(type: '*', handler: WildcardHandler<Events>): void;
+	on(type: '*', handler: WildcardHandler<Events>): void;
 
-  off<Key extends keyof Events>(type: Key, handler?: Handler<Key, Events>): void;
+	off<Key extends keyof Events>(type: Key, handler?: Handler<Key, Events>): void;
 
-  off(type: '*', handler: WildcardHandler<Events>): void;
+	off(type: '*', handler: WildcardHandler<Events>): void;
 
-  emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+	emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
 
-  emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+	emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
 }