@wener/utils 1.1.50 → 1.1.53

package/src/io/base64.ts

@@ -1,64 +1,66 @@
 // https://github.com/niklasvh/base64-arraybuffer/blob/master/src/index.ts
 
+import type { Bytes } from './types';
+
 const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 
 // Use a lookup table to find the index.
 const lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
 for (let i = 0; i < chars.length; i++) {
-  lookup[chars.charCodeAt(i)] = i;
+	lookup[chars.charCodeAt(i)] = i;
 }
 
-export function encodeArrayBufferToBase64(arraybuffer: ArrayBuffer): string {
-  const bytes = new Uint8Array(arraybuffer);
-  const len = bytes.length;
-  let base64 = '';
+export function encodeArrayBufferToBase64(arraybuffer: ArrayBuffer | ArrayLike<number>): string {
+	const bytes = new Uint8Array(arraybuffer);
+	const len = bytes.length;
+	let base64 = '';
 
-  for (let i = 0; i < len; i += 3) {
-    base64 += chars[bytes[i] >> 2];
-    base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
-    base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
-    base64 += chars[bytes[i + 2] & 63];
-  }
+	for (let i = 0; i < len; i += 3) {
+		base64 += chars[bytes[i] >> 2];
+		base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
+		base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
+		base64 += chars[bytes[i + 2] & 63];
+	}
 
-  if (len % 3 === 2) {
-    base64 = base64.substring(0, base64.length - 1) + '=';
-  } else if (len % 3 === 1) {
-    base64 = base64.substring(0, base64.length - 2) + '==';
-  }
+	if (len % 3 === 2) {
+		base64 = base64.substring(0, base64.length - 1) + '=';
+	} else if (len % 3 === 1) {
+		base64 = base64.substring(0, base64.length - 2) + '==';
+	}
 
-  return base64;
+	return base64;
 }
 
-export function decodeBase64ToUint8Array(base64: string): Uint8Array {
-  const len = base64.length;
-  let bufferLength = base64.length * 0.75;
-  let i;
-  let p = 0;
-  let encoded1;
-  let encoded2;
-  let encoded3;
-  let encoded4;
+export function decodeBase64ToUint8Array(base64: string): Bytes {
+	const len = base64.length;
+	let bufferLength = base64.length * 0.75;
+	let i;
+	let p = 0;
+	let encoded1;
+	let encoded2;
+	let encoded3;
+	let encoded4;
 
-  if (base64[base64.length - 1] === '=') {
-    bufferLength--;
-    if (base64[base64.length - 2] === '=') {
-      bufferLength--;
-    }
-  }
+	if (base64[base64.length - 1] === '=') {
+		bufferLength--;
+		if (base64[base64.length - 2] === '=') {
+			bufferLength--;
+		}
+	}
 
-  const arraybuffer = new ArrayBuffer(bufferLength);
-  const bytes = new Uint8Array(arraybuffer);
+	const arraybuffer = new ArrayBuffer(bufferLength);
+	const bytes = new Uint8Array(arraybuffer);
 
-  for (i = 0; i < len; i += 4) {
-    encoded1 = lookup[base64.charCodeAt(i)];
-    encoded2 = lookup[base64.charCodeAt(i + 1)];
-    encoded3 = lookup[base64.charCodeAt(i + 2)];
-    encoded4 = lookup[base64.charCodeAt(i + 3)];
+	for (i = 0; i < len; i += 4) {
+		encoded1 = lookup[base64.charCodeAt(i)];
+		encoded2 = lookup[base64.charCodeAt(i + 1)];
+		encoded3 = lookup[base64.charCodeAt(i + 2)];
+		encoded4 = lookup[base64.charCodeAt(i + 3)];
 
-    bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
-    bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
-    bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
-  }
+		bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
+		bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+		bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+	}
 
-  return bytes;
+	return bytes;
 }

package/src/io/dump.ts

@@ -1,20 +1,20 @@
 import { ArrayBuffers } from './ArrayBuffers';
 
 export function toHexDump(data: BufferSource) {
-  return Array.from(ArrayBuffers.toHex(data).match(/.{1,32}/g) ?? [])
-    .map((v, i) => {
-      let idxPrefix = `${i.toString(16).padStart(8, '0')}:`;
-      let content = Array.from(v.match(/.{4}/g) ?? []).join(' ');
-      let chars = Array.from(new Uint8Array(ArrayBuffers.fromHex(v).buffer)).map((v) => {
-        let c = String.fromCharCode(v);
-        if (v < 32 || v > 126) {
-          c = '.';
-        }
-        return c;
-      });
-      return [idxPrefix, content.padEnd(40, ' '), chars.join('')].join(' ');
-    })
-    .join('\n');
+	return Array.from(ArrayBuffers.toHex(data).match(/.{1,32}/g) ?? [])
+		.map((v, i) => {
+			let idxPrefix = `${i.toString(16).padStart(8, '0')}:`;
+			let content = Array.from(v.match(/.{4}/g) ?? []).join(' ');
+			let chars = Array.from(new Uint8Array(ArrayBuffers.fromHex(v).buffer)).map((v) => {
+				let c = String.fromCharCode(v);
+				if (v < 32 || v > 126) {
+					c = '.';
+				}
+				return c;
+			});
+			return [idxPrefix, content.padEnd(40, ' '), chars.join('')].join(' ');
+		})
+		.join('\n');
 }
 
 /**
@@ -24,12 +24,12 @@ export function toHexDump(data: BufferSource) {
  * ```
  */
 export function fromHexDump(dump: string) {
-  return ArrayBuffers.fromHex(
-    dump
-      .split('\n')
-      .map((v) => {
-        return v.substring(10, 10 + 41).replaceAll(' ', '');
-      })
-      .join(''),
-  );
+	return ArrayBuffers.fromHex(
+		dump
+			.split('\n')
+			.map((v) => {
+				return v.substring(10, 10 + 41).replaceAll(' ', '');
+			})
+			.join(''),
+	);
 }

package/src/io/isBuffer.test.ts

@@ -4,6 +4,6 @@ import { classOf } from '../langs/classOf';
 import { isBuffer } from './isBuffer';
 
 test('isBuffer', () => {
-  expect(isBuffer(Buffer.from(''))).toBeTruthy();
-  expect(classOf(Buffer)).toBe('Function');
+	expect(isBuffer(Buffer.from(''))).toBeTruthy();
+	expect(classOf(Buffer)).toBe('Function');
 });

package/src/io/isBuffer.ts

@@ -4,5 +4,5 @@
  * @see {@link https://github.com/feross/is-buffer feross/is-buffer}
  */
 export function isBuffer(obj: any): obj is Buffer {
-  return obj?.constructor?.isBuffer?.(obj);
+	return obj?.constructor?.isBuffer?.(obj);
 }

package/src/io/isTransferable.test.ts

@@ -3,9 +3,9 @@ import { expect, test } from 'vitest';
 import { isTransferable } from './isTransferable';
 
 test('isTransferable', () => {
-  expect(isTransferable(0)).toBeFalsy();
-  expect(isTransferable(Buffer.from(''))).toBeFalsy();
+	expect(isTransferable(0)).toBeFalsy();
+	expect(isTransferable(Buffer.from(''))).toBeFalsy();
 
-  expect(new ArrayBuffer(0) instanceof ArrayBuffer).toBeTruthy();
-  expect(isTransferable(new ArrayBuffer(0))).toBeTruthy();
+	expect(new ArrayBuffer(0) instanceof ArrayBuffer).toBeTruthy();
+	expect(isTransferable(new ArrayBuffer(0))).toBeTruthy();
 });

package/src/io/isTransferable.ts

@@ -1,4 +1,4 @@
-import { getGlobalThis } from '../runtime/getGlobalThis';
+import { getGlobalThis } from '../web/getGlobalThis';
 
 const globalThis = getGlobalThis();
 
@@ -10,45 +10,45 @@ const globalThis = getGlobalThis();
  * @see {@link https://developer.mozilla.org/en-US/docs/Glossary/Transferable_objects | Transferable objects}
  */
 export function isTransferable(v: any): v is TransferableObject {
-  _ctors ||= ctors();
-  return _ctors.some((ctor) => v instanceof ctor);
+	_ctors ||= ctors();
+	return _ctors.some((ctor) => v instanceof ctor);
 }
 
 let _ctors: any[];
 
 function ctors() {
-  const o: any = globalThis.window || globalThis || global;
-  return [
-    o.ArrayBuffer,
-    o.MessagePort,
-    o.ReadableStream,
-    o.WritableStream,
-    o.TransformStream,
-    o.AudioData,
-    o.ImageBitmap,
-    o.VideoFrame,
-    o.OffscreenCanvas,
-    o.RTCDataChannel,
-  ].filter(Boolean);
+	const o: any = globalThis.window || globalThis || global;
+	return [
+		o.ArrayBuffer,
+		o.MessagePort,
+		o.ReadableStream,
+		o.WritableStream,
+		o.TransformStream,
+		o.AudioData,
+		o.ImageBitmap,
+		o.VideoFrame,
+		o.OffscreenCanvas,
+		o.RTCDataChannel,
+	].filter(Boolean);
 }
 
 export type TransferableObject =
-  | Transferable
-  | ArrayBuffer
-  | MessagePort
-  | ReadableStream
-  | WritableStream
-  | TransformStream
-  | AudioData
-  | ImageBitmap
-  | VideoFrame
-  | OffscreenCanvas
-  | RTCDataChannel;
+	| Transferable
+	| ArrayBuffer
+	| MessagePort
+	| ReadableStream
+	| WritableStream
+	| TransformStream
+	| AudioData
+	| ImageBitmap
+	| VideoFrame
+	| OffscreenCanvas
+	| RTCDataChannel;
 
 declare global {
-  interface OffscreenCanvas {}
+	interface OffscreenCanvas {}
 
-  interface VideoFrame {}
+	interface VideoFrame {}
 
-  interface AudioData {}
+	interface AudioData {}
 }

package/src/io/parseDataUri.test.ts

@@ -3,32 +3,27 @@ import { ArrayBuffers } from './ArrayBuffers';
 import { parseDataUri } from './parseDataUri';
 
 test('parseDataUri', async () => {
-  {
-    let uri = 'data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==';
-    const { getData, ...out } = parseDataUri(uri)!;
-    assert.deepEqual(out, {
-      type: 'text/plain',
-      params: { base64: true },
-      content: 'SGVsbG8sIFdvcmxkIQ==',
-      base64: true,
-    });
-    assert.equal(await getData('utf-8'), await fetch(uri).then((v) => v.text()));
-    assert.equal(await getData('base64'), 'SGVsbG8sIFdvcmxkIQ==');
-  }
-  {
-    // text
-    let uri = 'data:text/plain,Hello%2C%20World!';
-    const { getData, ...out } = parseDataUri(uri)!;
-    assert.deepEqual(out, {
-      type: 'text/plain',
-      params: {},
-      content: 'Hello%2C%20World!',
-      base64: false,
-    });
+	{
+		let uri = 'data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==';
+		const { getData, ...out } = parseDataUri(uri)!;
+		assert.deepEqual(out, {
+			type: 'text/plain',
+			params: { base64: true },
+			content: 'SGVsbG8sIFdvcmxkIQ==',
+			base64: true,
+		});
+		assert.equal(await getData('utf-8'), await fetch(uri).then((v) => v.text()));
+		assert.equal(await getData('base64'), 'SGVsbG8sIFdvcmxkIQ==');
+	}
+	{
+		// text
+		let uri = 'data:text/plain,Hello%2C%20World!';
+		const { getData, ...out } = parseDataUri(uri)!;
+		assert.deepEqual(out, { type: 'text/plain', params: {}, content: 'Hello%2C%20World!', base64: false });
 
-    assert.equal(await getData('utf-8'), 'Hello, World!');
-    assert.deepEqual(ArrayBuffers.asView(Uint8Array, await getData()), new TextEncoder().encode('Hello, World!'));
-    assert.equal(await getData('utf-8'), await fetch(uri).then((v) => v.text()));
-    assert.equal(await getData('base64'), 'SGVsbG8sIFdvcmxkIQ==');
-  }
+		assert.equal(await getData('utf-8'), 'Hello, World!');
+		assert.deepEqual(ArrayBuffers.asView(Uint8Array, await getData()), new TextEncoder().encode('Hello, World!'));
+		assert.equal(await getData('utf-8'), await fetch(uri).then((v) => v.text()));
+		assert.equal(await getData('base64'), 'SGVsbG8sIFdvcmxkIQ==');
+	}
 });

package/src/io/parseDataUri.ts

@@ -1,66 +1,66 @@
 import { ArrayBuffers } from './ArrayBuffers';
 
 export interface ParsedDataUri {
-  type: string;
-  params: Record<string, string | boolean>;
-  content: string;
-  base64: boolean;
+	type: string;
+	params: Record<string, string | boolean>;
+	content: string;
+	base64: boolean;
 
-  getData(enc: 'utf-8' | 'base64'): Promise<string>;
+	getData(enc: 'utf-8' | 'base64'): Promise<string>;
 
-  getData(): Promise<ArrayBuffer>;
+	getData(): Promise<ArrayBuffer>;
 }
 
 export function parseDataUri(data: string): undefined | ParsedDataUri {
-  if (!data || !data.startsWith('data:')) {
-    return;
-  }
-  // https://en.wikipedia.org/wiki/Data_URI_scheme
-  // data:content/type;base64,
-  // data:content/type;a=b,content
-  const [header, body] = data.split(',');
-  const [type, ...paramsStr] = header.slice('data:'.length).split(';');
-  const content = body;
-  const params: Record<string, string | boolean> = Object.fromEntries(
-    paramsStr.map((s) => {
-      const [k, v] = s.trim().split('=');
-      return [k, v ?? true];
-    }),
-  );
-  // params charset=utf-8
-  // params base64
-  // params a=b
-  let base64 = Boolean(params['base64']);
-  return {
-    type,
-    params,
-    content,
-    base64,
-    getData: async (enc?: 'utf-8' | 'base64') => {
-      if (!enc) {
-        return await fetch(data).then((v) => v.arrayBuffer());
-      }
-      //
-      let buf: BufferSource;
-      if (base64) {
-        if (enc === 'base64') {
-          return content;
-        }
-        buf = await fetch(data).then((v) => v.arrayBuffer());
-      } else {
-        let raw = decodeURIComponent(content);
-        if (enc === 'utf-8') {
-          return raw;
-        }
-        buf = ArrayBuffers.from(raw, 'utf-8');
-      }
-      if (enc === 'utf-8') {
-        return new TextDecoder(enc).decode(buf);
-      }
-      if (enc === 'base64') {
-        return ArrayBuffers.toString(buf, 'base64');
-      }
-      return buf;
-    },
-  } as ParsedDataUri;
+	if (!data || !data.startsWith('data:')) {
+		return;
+	}
+	// https://en.wikipedia.org/wiki/Data_URI_scheme
+	// data:content/type;base64,
+	// data:content/type;a=b,content
+	const [header, body] = data.split(',');
+	const [type, ...paramsStr] = header.slice('data:'.length).split(';');
+	const content = body;
+	const params: Record<string, string | boolean> = Object.fromEntries(
+		paramsStr.map((s) => {
+			const [k, v] = s.trim().split('=');
+			return [k, v ?? true];
+		}),
+	);
+	// params charset=utf-8
+	// params base64
+	// params a=b
+	let base64 = Boolean(params['base64']);
+	return {
+		type,
+		params,
+		content,
+		base64,
+		getData: async (enc?: 'utf-8' | 'base64') => {
+			if (!enc) {
+				return await fetch(data).then((v) => v.arrayBuffer());
+			}
+			//
+			let buf: BufferSource;
+			if (base64) {
+				if (enc === 'base64') {
+					return content;
+				}
+				buf = await fetch(data).then((v) => v.arrayBuffer());
+			} else {
+				let raw = decodeURIComponent(content);
+				if (enc === 'utf-8') {
+					return raw;
+				}
+				buf = ArrayBuffers.from(raw, 'utf-8') as BufferSource;
+			}
+			if (enc === 'utf-8') {
+				return new TextDecoder(enc).decode(buf);
+			}
+			if (enc === 'base64') {
+				return ArrayBuffers.toString(buf, 'base64');
+			}
+			return buf;
+		},
+	} as ParsedDataUri;
 }

package/src/io/types.ts

@@ -0,0 +1,13 @@
+export type Bytes = Uint8Array<ArrayBuffer>;
+export type TypedArray =
+	| Uint8Array
+	| Uint8ClampedArray
+	| Uint16Array
+	| Uint32Array
+	| Int8Array
+	| Int16Array
+	| Int32Array
+	| BigUint64Array
+	| BigInt64Array
+	| Float32Array
+	| Float64Array;

package/src/langs/AsyncCloser.ts

@@ -0,0 +1,45 @@
+type AsyncClosable = { close(): void | Promise<void> } | (() => void | Promise<void>) | AsyncDisposable | Disposable;
+
+/**
+ * @see AsyncDisposableStack
+ */
+export class AsyncCloser implements AsyncDisposable {
+	closers: Array<AsyncClosable> = [];
+
+	defer(closer: AsyncClosable | null | undefined) {
+		if (!closer) {
+			return;
+		}
+		this.closers.push(closer);
+	}
+
+	add<T extends AsyncClosable | null | undefined>(closer: T): T {
+		if (!closer) {
+			return closer;
+		}
+		this.closers.push(closer);
+		return closer;
+	}
+
+	async [Symbol.asyncDispose]() {
+		for (let closer of this.closers) {
+			let o;
+			if (typeof closer === 'function') {
+				o = closer();
+			} else if (Symbol.asyncDispose in closer) {
+				o = closer[Symbol.asyncDispose]();
+			} else if (Symbol.dispose in closer) {
+				closer[Symbol.dispose]();
+			} else {
+				o = closer.close();
+			}
+			if (o && typeof o.then === 'function') {
+				await o;
+			}
+		}
+	}
+
+	close() {
+		return this[Symbol.asyncDispose]();
+	}
+}

package/src/langs/Closer.ts

@@ -0,0 +1,39 @@
+type Closable = { close(): void } | (() => void) | Disposable;
+
+/**
+ * @see DisposableStack
+ */
+export class Closer implements Disposable {
+	closers: Array<Closable> = [];
+
+	defer(closer: Closable | null | undefined) {
+		if (!closer) {
+			return;
+		}
+		this.closers.push(closer);
+	}
+
+	add<T extends Closable | null | undefined>(closer: T): T {
+		if (!closer) {
+			return closer;
+		}
+		this.closers.push(closer);
+		return closer;
+	}
+
+	[Symbol.dispose]() {
+		for (let closer of this.closers) {
+			if (typeof closer === 'function') {
+				closer();
+			} else if (Symbol.dispose in closer) {
+				closer[Symbol.dispose]();
+			} else {
+				closer.close();
+			}
+		}
+	}
+
+	close() {
+		this[Symbol.dispose]();
+	}
+}

package/src/langs/MaybeFunction.ts

@@ -1,9 +1,9 @@
 export type MaybeFunction<T, P extends any[] = any[]> = T | ((...args: P) => T);
 
 export function maybeFunction<T, P extends any[] = any[]>(v: MaybeFunction<T, P>, ...args: P): T {
-  // https://github.com/microsoft/TypeScript/issues/37663#issuecomment-759728342
-  if (v instanceof Function) {
-    return v(...args);
-  }
-  return v;
+	// https://github.com/microsoft/TypeScript/issues/37663#issuecomment-759728342
+	if (v instanceof Function) {
+		return v(...args);
+	}
+	return v;
 }

package/src/langs/classOf.ts

@@ -1,3 +1,3 @@
 export function classOf(o: any) {
-  return Object.prototype.toString.call(o).slice(8, -1);
+	return Object.prototype.toString.call(o).slice(8, -1);
 }

package/src/langs/deepEqual.test.ts

@@ -2,16 +2,5 @@ import { expect, test } from 'vitest';
 import { deepEqual } from './deepEqual';
 
 test('deep equal', () => {
-  expect(
-    deepEqual(
-      {
-        a: null,
-        b: Infinity,
-      },
-      {
-        a: null,
-        b: Infinity,
-      },
-    ),
-  ).toBeTruthy();
+	expect(deepEqual({ a: null, b: Infinity }, { a: null, b: Infinity })).toBeTruthy();
 });