@wener/utils 1.1.5 → 1.1.7

package/src/i18n/createTranslate.test.ts

@@ -0,0 +1,155 @@
+import test from 'ava';
+import { createTranslate } from './createTranslate';
+
+test('exports', (t) => {
+  const out = createTranslate();
+  t.is(typeof out, 'object', 'returns an object');
+  t.is(typeof out.t, 'function', '~> has "t" function');
+  t.is(typeof out.dict, 'function', '~> has "set" function');
+  t.is(typeof out.locale, 'function', '~> has "locale" function');
+});
+
+test('usage', (t) => {
+  const ctx = createTranslate({
+    en: { hello: 'Hello, {{name}}!' },
+    es: { hello: 'Hola {{name}}!' },
+    pt: { foo: 'foo {{name}}~!' },
+  });
+
+  t.deepEqual(ctx.dict('en'), { hello: 'Hello, {{name}}!' });
+
+  t.true(ctx.dict('foobar') === undefined);
+
+  const foo = ctx.t('hello');
+  t.is(foo, '', '~> "" w/o locale');
+
+  t.is(ctx.locale('en'), 'en', '>>> ctx.locale()');
+
+  t.is(ctx.locale(), 'en');
+
+  const bar = ctx.t('hello');
+  t.not(bar, '', '(en) found "hello" key');
+  t.is(bar, 'Hello, !', '~> interpolations empty if missing param');
+
+  const baz = ctx.t('hello', { name: 'world' });
+  t.is(baz, 'Hello, world!', '~> interpolations successful');
+
+  const bat = ctx.t('hello', { name: 'world' }, 'es');
+  t.not(bat, '', '(es) found "hello" key');
+  t.is(bat, 'Hola world!', '~> success');
+
+  t.is(ctx.t('hello', { name: 'world' }, 'pt'), '', '(pt) did NOT find "hello" key');
+
+  t.is(ctx.dict('pt', { hello: 'Oí {{name}}!' }), undefined, '>>> ctx.dict()');
+
+  const quz = ctx.t('hello', { name: 'world' }, 'pt');
+  t.not(quz, '', '(pt) found "hello" key');
+  t.is(quz, 'Oí world!', '~> success');
+
+  const qut = ctx.t('foo', { name: 'bar' }, 'pt');
+  t.not(qut, '', '(pt) found "foo" key');
+  t.is(qut, 'foo bar~!', '~> success');
+
+  t.is(ctx.locale('es'), 'es', '>>> ctx.locale()');
+
+  t.is(ctx.locale(), 'es');
+  t.is(ctx.locale(''), 'es');
+  t.is(ctx.locale(false as any), 'es');
+  t.is(ctx.locale(null as any), 'es');
+  t.is(ctx.locale(0 as any), 'es');
+
+  const qux = ctx.t('hello', { name: 'default' });
+  t.not(qux, '', '(es) found "hello" key');
+  t.is(qux, 'Hola default!', '~> success');
+
+  t.is(ctx.t('hello', { name: 'world' }, 'de'), '', '(de) did NOT find "hello" key');
+
+  t.is(ctx.dict('de', { hello: 'Hallo {{name}}!' }), undefined, '>>> ctx.dict(de)');
+
+  const qar = ctx.t('hello', { name: 'world' }, 'de');
+  t.not(qar, '', '(de) found "hello" key');
+  t.is(qar, 'Hallo world!', '~> success');
+});
+
+test('functional', (t) => {
+  const ctx = createTranslate({
+    en: {
+      hello(value: any) {
+        return `hello ${value || 'stranger'}~!`;
+      },
+    },
+  });
+
+  ctx.locale('en');
+
+  const foo = ctx.t('hello');
+  t.is(foo, 'hello stranger~!', '~> called function w/o param');
+
+  const bar = ctx.t('hello', 'world' as any);
+  t.is(bar, 'hello world~!', '~> called function w/ param (string)');
+
+  const baz = ctx.t('hello', [1, 2, 3]);
+  t.is(baz, 'hello 1,2,3~!', '~> called function w/ param (array)');
+});
+
+test('nested', (t) => {
+  const ctx = createTranslate({
+    en: {
+      fruits: {
+        apple: 'apple',
+        orange: 'orange',
+        grape: 'grape',
+      },
+    },
+    es: {
+      fruits: {
+        apple: 'manzana',
+        orange: 'naranja',
+        grape: 'uva',
+      },
+    },
+  });
+
+  ctx.locale('en');
+  t.is(ctx.t('fruits.apple'), 'apple', '(en) fruits.apple');
+  t.is(ctx.t('fruits.orange'), 'orange', '(en) fruits.orange');
+  t.is(ctx.t(['fruits', 'grape']), 'grape', '(en) ["fruits","grape"]');
+  t.is(ctx.t('fruits.404'), '', '(en) fruits.404 ~> ""');
+  t.is(ctx.t('error.404'), '', '(en) error.404 ~> ""');
+
+  ctx.locale('es');
+  t.is(ctx.t('fruits.apple'), 'manzana', '(es) fruits.apple');
+  t.is(ctx.t('fruits.orange'), 'naranja', '(es) fruits.orange');
+  t.is(ctx.t(['fruits', 'grape']), 'uva', '(es) ["fruits","grape"]');
+  t.is(ctx.t('fruits.404'), '', '(es) fruits.404 ~> ""');
+  t.is(ctx.t('error.404'), '', '(es) error.404 ~> ""');
+});
+
+test('arrays', (t) => {
+  const ctx = createTranslate({
+    en: {
+      foo: '{{0}} + {{1}} = {{2}}',
+      bar: [
+        {
+          baz: 'roses are {{colors.0}}, violets are {{colors.1}}',
+        },
+      ],
+    },
+  });
+
+  ctx.locale('en');
+
+  t.is(ctx.t('foo', [1, 2, 3]), '1 + 2 = 3', '~> foo');
+
+  t.is(ctx.t('bar.0.baz', { colors: ['red', 'blue'] }), 'roses are red, violets are blue', '~> bar.0.baz');
+});
+
+test('invalid value', (t) => {
+  const ctx = createTranslate({
+    en: {
+      foo: ['bar'],
+    },
+  });
+
+  t.deepEqual(ctx.t('foo', null as any, 'en'), ['bar']);
+});

package/src/i18n/createTranslate.ts

@@ -0,0 +1,52 @@
+import { get } from '../objects/get';
+import { ObjectPathLike } from '../objects/parseObjectPath';
+import { renderTemplate } from '../strings/renderTemplate';
+
+export interface Translate<T extends object> {
+  /** Get/Set the language key */
+  locale(lang?: string): string;
+
+  /** Define the dict of translations for a language */
+  dict(lang: string, dict: T): void;
+
+  /** Get the dict of translations for a language */
+  dict(lang: string): T;
+
+  /** Retrieve a translation segment for the current language */
+  t<X extends Record<string, any> | any[]>(key: ObjectPathLike, params?: X, lang?: string): string;
+}
+
+export function createTranslate<T extends object>(obj?: Record<string, T>): Translate<T> {
+  let locale = '';
+  const tree = obj || {};
+
+  return {
+    locale(lang) {
+      return (locale = lang || locale);
+    },
+
+    dict: ((lang, dict?) => {
+      if (dict) {
+        tree[lang] = Object.assign(tree[lang] || {}, dict);
+        return;
+      }
+      return tree[lang];
+    }) as Translate<T>['dict'],
+
+    t(key, params, lang) {
+      const val = get(tree[lang || locale], key, '') as any;
+      if (process.env.NODE_ENV === 'development') {
+        if (val == null) {
+          return console.error(
+            `[Translate] Missing the "${[].concat(key as any).join('.')}" key within the "${
+              lang || locale
+            }" dictionary`,
+          );
+        }
+      }
+      if (typeof val === 'function') return val(params);
+      if (typeof val === 'string') return renderTemplate(val, params, 'common');
+      return val;
+    },
+  };
+}

package/src/index.ts

@@ -13,7 +13,7 @@ export { set } from './objects/set';
 export { parseObjectPath } from './objects/parseObjectPath';
 
 // async
-export { createLazyPromise, type LazyPromise } from './asyncs/LazyPromise';
+export { createLazyPromise, type LazyPromise } from './asyncs/createLazyPromise';
 export { setAsyncInterval, clearAsyncInterval } from './asyncs/AsyncInterval';
 export { type MaybePromise } from './asyncs/MaybePromise';
 
@@ -26,12 +26,15 @@ export { isPromise } from './asyncs/isPromise';
 export { isClass } from './validations/isClass';
 export { isDefined } from './validations/isDefined';
 export { isEmptyObject } from './validations/isEmptyObject';
-export { shallow } from './validations/shallow';
-export { dequal } from './validations/dequal';
+export { shallowEqual } from './langs/shallowEqual';
+export { deepEqual } from './langs/deepEqual';
+export { isUUID } from './validations/isUUID';
+
+export { classOf } from './langs/classOf';
 
 // modules
 export { parseModuleId, type ParsedModuleId } from './modules/parseModuleId';
-export { isModule } from './modules/isModule';
+export { isModule, type Module } from './modules/isModule';
 
 // logging
 export { type Logger, type LogLevel } from './logging/Logger';
@@ -42,21 +45,31 @@ export { createChildLogger } from './logging/createChildLogger';
 // strings
 export { pascalCase, camelCase } from './strings/camelCase';
 export { renderTemplate } from './strings/renderTemplate';
+export { formatBytes } from './strings/formatBytes';
 
-export { createRandom } from './maths/random';
+// i18n
+export { createTranslate } from './i18n/createTranslate';
+
+// io
 export { isBuffer } from './io/isBuffer';
+export { isTransferable } from './io/isTransferable';
+export { ArrayBuffers } from './io/ArrayBuffers';
+export type { AbstractEncoding } from './io/AbstractEncoding';
 
+// browser
 export { copy } from './browsers/copy';
 export { download } from './browsers/download';
 export { loadScripts, loadStyles } from './browsers/loaders';
 export { getFileFromDataTransfer } from './browsers/getFileFromDataTransfer';
 
+// polyfills
 export { getGlobalThis } from './isomorphics/getGlobalThis';
-
-export { formatBytes } from './formats/formatBytes';
-export { urljoin } from './shim/urljoin';
+export { structuredClone } from './isomorphics/structuredClone';
 
 // crypto
 export { randomUUID } from './crypto/randomUUID';
 export { sha1, sha256, sha384, sha512 } from './crypto/hashing';
-export { hex } from './crypto/hex';
+export { hex } from './crypto/base';
+
+// misc
+export { createRandom } from './maths/random';

package/src/io/AbstractEncoding.ts

@@ -0,0 +1,21 @@
+/**
+ * AbstractEncoding contract
+ *
+ * @see https://github.com/mafintosh/abstract-encoding
+ */
+export interface AbstractEncoding<T> {
+  /**
+   * encode a value to a buffer
+   */
+  encode(data: T, buffer?: ArrayBuffer, offset?: number): BufferSource;
+
+  /**
+   * decode data from buffer
+   */
+  decode(buffer: BufferSource, start?: number, end?: number): T;
+
+  /**
+   * byteLength of data
+   */
+  byteLength?: (data: T) => number;
+}

package/src/io/ArrayBuffer.test-d.ts

@@ -0,0 +1,4 @@
+import { expectType } from 'tsd';
+import { ArrayBuffers } from './ArrayBuffers';
+
+expectType<Buffer>(ArrayBuffers.asView(Buffer, new Uint8Array()));

package/src/io/ArrayBuffers.base64.test.ts

@@ -0,0 +1,61 @@
+import test from 'ava';
+import { ArrayBuffers } from './ArrayBuffers';
+
+test.before(() => {
+  ArrayBuffers._allowedBuffer = false;
+});
+
+test('base64: ignore whitespace', function (t) {
+  const text = '\n   YW9ldQ==  ';
+  const buf = ArrayBuffers.from(text, 'base64');
+  t.is(ArrayBuffers.toString(buf), 'aoeu');
+});
+
+test('base64: strings without padding', function (t) {
+  t.is(ArrayBuffers.toString(ArrayBuffers.from('YW9ldQ', 'base64')), 'aoeu');
+});
+
+test('base64: newline in utf8 -- should not be an issue', function (t) {
+  t.is(
+    ArrayBuffers.toString(
+      ArrayBuffers.from('LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK', 'base64'),
+      'utf8',
+    ),
+    '---\ntitle: Three dashes marks the spot\ntags:\n',
+  );
+});
+
+test('base64: newline in base64 -- should get stripped', function (t) {
+  t.is(
+    ArrayBuffers.toString(
+      ArrayBuffers.from(
+        'LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\nICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt',
+        'base64',
+      ),
+      'utf8',
+    ),
+    '---\ntitle: Three dashes marks the spot\ntags:\n  - yaml\n  - front-matter\n  - dashes\nexpaned-',
+  );
+});
+
+test('base64: tab characters in base64 - should get stripped', function (t) {
+  t.is(
+    ArrayBuffers.toString(
+      ArrayBuffers.from(
+        'LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\t\t\t\tICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt',
+        'base64',
+      ),
+      'utf8',
+    ),
+    '---\ntitle: Three dashes marks the spot\ntags:\n  - yaml\n  - front-matter\n  - dashes\nexpaned-',
+  );
+});
+
+test('base64: invalid non-alphanumeric characters -- should be stripped', function (t) {
+  t.is(ArrayBuffers.toString(ArrayBuffers.from('!"#$%&\'()*,.:;<=>?@[\\]^`{|}~', 'base64'), 'utf8'), '');
+});
+
+test('base64: high byte', function (t) {
+  const highByte = ArrayBuffers.from([128]);
+  t.deepEqual(ArrayBuffers.alloc(1, ArrayBuffers.toString(highByte, 'base64'), 'base64'), highByte);
+});

package/src/io/ArrayBuffers.test.ts

@@ -0,0 +1,23 @@
+import test from 'ava';
+import { ArrayBuffers } from './ArrayBuffers';
+
+test('concat', (t) => {
+  const check = (Type: any = Uint8Array, va = [1, 2, 3], vb = [4, 5, 6]) => {
+    const a = new Type(va);
+    const b = new Type(vb);
+    t.deepEqual(ArrayBuffers.concat([a, b]), new Type([...va, ...vb]).buffer, `should concat ${Type}`);
+  };
+  check(Uint8Array);
+  check(Uint16Array, [0xff, 0xffff]);
+  check(Uint32Array, [0xfffffff]);
+});
+
+test('asView for Buffer', (t) => {
+  const buf = Buffer.from([1, 2, 3, 4, 5]);
+  t.is(ArrayBuffers.asView(Buffer, buf), buf);
+  const uint8 = ArrayBuffers.asView(Uint8Array, buf);
+  t.is(ArrayBuffers.asView(Buffer, uint8).buffer, buf.buffer);
+
+  t.deepEqual(uint8, buf);
+  t.deepEqual(ArrayBuffers.asView(Buffer, uint8), buf);
+});

package/src/io/ArrayBuffers.ts

@@ -0,0 +1,272 @@
+import { classOf } from '../langs/classOf';
+import { isBuffer } from './isBuffer';
+
+/**
+ * Various utils to work with {@link ArrayBuffer}
+ */
+export interface ArrayBuffers {
+  /**
+   * isArrayBuffer check if the given value is an {@link ArrayBuffer}
+   */
+  isArrayBuffer(v: any): v is ArrayBuffer;
+
+  /**
+   * slice the given view with the given offset and length, will handle the {@link Buffer} as well
+   *
+   * @see {@link https://nodejs.org/api/buffer.html#bufslicestart-end Buffer.slice}
+   */
+  slice<T extends ArrayBufferView>(o: T, start?: number, end?: number): T;
+
+  /**
+   * asView convert the given value to given {@link TypedArray} view
+   *
+   * TypedArray can be {@link Buffer}, will avoid copy
+   */
+  asView<C extends ArrayBufferViewConstructor<unknown>>(
+    TypedArray: C,
+    v: BufferSource,
+    byteOffset?: number,
+    byteLength?: number,
+  ): InstanceType<C>;
+
+  /**
+   * toString convert the given {@link BufferSource} to string
+   */
+  toString(v: BufferSource | string, encoding?: ToStringEncoding): string;
+
+  /**
+   * Returns true if encoding is the name of a supported character encoding, or false otherwise.
+   */
+  isEncoding(v?: string): v is ToStringEncoding;
+
+  toJSON<T = any>(v: BufferSource | string, reviver?: (this: any, key: string, value: any) => any): T;
+
+  /**
+   * from convert the given value to {@link ArrayBuffer}
+   */
+  from(v: string | BufferSource, encoding?: ToStringEncoding): ArrayBuffer;
+
+  /**
+   * concat the given {@link BufferSource} to a new {@link ArrayBuffer}
+   */
+  concat(buffers: Array<BufferSource>, result?: ArrayBuffer, offset?: number): ArrayBuffer;
+}
+
+type ToStringEncoding =
+  | 'ascii'
+  | 'utf16le'
+  // | 'utf-16le'
+  | 'ucs2'
+  | 'ucs-2'
+  | 'base64'
+  | 'base64url'
+  | 'latin1'
+  | 'binary'
+  | 'utf8'
+  | 'utf-8'
+  | 'hex';
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const ArrayBuffers = {
+  _allowedBuffer: true,
+  isArrayBuffer: (v: any): v is ArrayBuffer => {
+    return v instanceof ArrayBuffer;
+  },
+  slice: (o: TypedArray, start?: number, end?: number) => {
+    // NodeJS Buffer slice is not the same as UInt8Array slice
+    // https://nodejs.org/api/buffer.html#bufslicestart-end
+    if (isBuffer(o)) {
+      return Uint8Array.prototype.slice.call(o, start, end);
+    }
+    return o.slice(start, end);
+  },
+  asView: <C extends ArrayBufferViewConstructor<unknown>, I extends InstanceType<C>>(
+    TypedArray: C,
+    v: BufferSource,
+    byteOffset?: number,
+    byteLength?: number,
+  ): I => {
+    if (v instanceof TypedArray && (byteOffset ?? 0) === 0 && byteLength === undefined) {
+      return v as I;
+    }
+    if (ArrayBuffer.isView(v) || isBuffer(v)) {
+      if (ArrayBuffers._allowedBuffer && typeof Buffer !== 'undefined' && (TypedArray as any) === Buffer) {
+        // new Buffer() is deprecated
+        return Buffer.from(v.buffer, byteOffset, byteLength) as I;
+      }
+      return new TypedArray(v.buffer, v.byteOffset + (byteOffset ?? 0), byteLength ?? v.byteLength) as I;
+    }
+    return new TypedArray(v, byteOffset, byteLength) as I;
+  },
+  toString: (buf: BufferSource | string, encoding: ToStringEncoding = 'utf8') => {
+    // 'ascii'  'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'
+    if (typeof buf === 'string') {
+      return buf;
+    }
+    if (typeof Buffer !== 'undefined' && ArrayBuffers._allowedBuffer) {
+      return Buffer.from(ArrayBuffers.asView(Uint8Array, buf)).toString(encoding);
+    }
+    // reference
+    // https://github.com/feross/buffer/blob/master/index.js
+    switch (encoding) {
+      case 'hex': {
+        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);
+        return [...view].map((b) => hexLookupTable[b]).join('');
+      }
+      case 'base64': {
+        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);
+        return btoa(String.fromCharCode(...view));
+      }
+      case 'utf8':
+      // falls through
+      case 'utf-8':
+        return new TextDecoder().decode(buf as any);
+      case 'ascii': {
+        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);
+        return String.fromCharCode(...view.map((v) => v & 0x7f));
+      }
+      case 'latin1':
+      // falls through
+      case 'binary': {
+        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);
+        return String.fromCharCode(...view);
+      }
+      case 'ucs2':
+      // falls through
+      case 'ucs-2':
+      // case 'utf-16le':
+      // falls through
+      case 'utf16le': {
+        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);
+        let res = '';
+        // If length is odd, the last 8 bits must be ignored (same as node.js)
+        for (let i = 0; i < view.length - 1; i += 2) {
+          res += String.fromCharCode(view[i] + view[i + 1] * 256);
+        }
+        return res;
+      }
+      default:
+        throw new Error(`[ArrayBuffers.toString] Unknown encoding: ${encoding}`);
+    }
+  },
+  toJSON: (v: BufferSource | string, reviver?: (this: any, key: string, value: any) => any) => {
+    return JSON.parse(ArrayBuffers.toString(v), reviver);
+  },
+  alloc: (size: number, fill?: string | number, encoding?: ToStringEncoding) => {
+    if (fill !== undefined) {
+      if (typeof fill === 'number') {
+        return new Uint8Array(size).fill(fill);
+      }
+      // as cast
+      // https://stackoverflow.com/questions/73994091
+      return ArrayBuffers.asView(Uint8Array, ArrayBuffers.from(fill, encoding)).slice(0, size);
+    }
+    return new ArrayBuffer(size);
+  },
+  from: (
+    v: string | BufferSource | ArrayLike<number> | Iterable<number>,
+    encoding: ToStringEncoding = 'utf8',
+  ): BufferSource => {
+    if (!v) {
+      return new ArrayBuffer(0);
+    }
+    if (typeof v === 'string') {
+      if (typeof Buffer !== 'undefined' && ArrayBuffers._allowedBuffer) {
+        return Buffer.from(v, encoding);
+      }
+
+      switch (encoding) {
+        case 'utf-8':
+        // falls through
+        case 'utf8':
+          return new TextEncoder().encode(v).buffer;
+        case 'base64':
+          // replaceAll
+          return Uint8Array.from(atob(v.replace(/[^0-9a-zA-Z=+/_ \r\n]/g, '')), (c) => c.charCodeAt(0));
+        default:
+          throw new Error(`[ArrayBuffers.from] Unknown encoding: ${encoding}`);
+      }
+    }
+    if (v instanceof ArrayBuffer) {
+      return v;
+    }
+    // lost length
+    if (ArrayBuffer.isView(v) || isBuffer(v)) {
+      if (v.byteOffset !== 0) {
+        // return v.buffer.slice(v.byteOffset, v.byteOffset + v.byteLength)
+        throw new Error('ArrayBuffers.from do not support view with offset');
+      }
+      return v.buffer;
+    }
+    if (Array.isArray(v)) {
+      return new Uint8Array(v);
+    }
+    const type = classOf(v);
+    throw new TypeError(`ArrayBuffers.from unsupported type ${type}`);
+  },
+  isEncoding: (encoding?: string) => {
+    switch (String(encoding).toLowerCase()) {
+      case 'hex':
+      case 'utf8':
+      case 'utf-8':
+      case 'ascii':
+      case 'latin1':
+      case 'binary':
+      case 'base64':
+      case 'ucs2':
+      case 'ucs-2':
+      case 'utf16le':
+        // case 'utf-16le':
+        return true;
+      default:
+        return false;
+    }
+  },
+  concat: (buffers: Array<BufferSource>, result?: ArrayBuffer, offset = 0) => {
+    // https://stackoverflow.com/questions/10786128/appending-arraybuffers
+
+    const length = buffers.reduce((a, b) => a + b.byteLength, 0);
+    const r = result ? new Uint8Array(result) : new Uint8Array(length);
+    for (const buffer of buffers) {
+      if (!buffer || !buffer.byteLength) continue;
+      let n: Uint8Array;
+      if (buffer instanceof ArrayBuffer) {
+        n = new Uint8Array(buffer);
+      } else if (ArrayBuffer.isView(buffer)) {
+        n = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      } else {
+        throw new Error(`ArrayBuffers.concat unsupported type ${classOf(buffer)}`);
+      }
+      r.set(n, offset);
+      offset += buffer.byteLength;
+    }
+    return r.buffer;
+  },
+};
+
+export type TypedArray =
+  | Uint8Array
+  | Uint8ClampedArray
+  | Uint16Array
+  | Uint32Array
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | BigUint64Array
+  | BigInt64Array
+  | Float32Array
+  | Float64Array;
+
+type ArrayBufferViewConstructor<T> = new (buffer: ArrayBufferLike, byteOffset?: number, byteLength?: number) => T;
+
+const hexLookupTable = (function () {
+  const alphabet = '0123456789abcdef';
+  const table = new Array(256);
+  for (let i = 0; i < 16; ++i) {
+    const i16 = i * 16;
+    for (let j = 0; j < 16; ++j) {
+      table[i16 + j] = alphabet[i] + alphabet[j];
+    }
+  }
+  return table;
+})();

package/src/io/Buffer.ts

@@ -0,0 +1,16 @@
+import { ArrayBuffers } from './ArrayBuffers';
+
+export class Buffer extends Uint8Array {
+  // constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number) {
+  //   super(buffer, byteOffset, length);
+  // }
+
+  static from(array: string | BufferSource | ArrayLike<number> | Iterable<number>, arg2?: any): Buffer {
+    // todo mapfn
+    return new Buffer(ArrayBuffers.from(array, arg2) as ArrayBuffer);
+  }
+
+  toString(encoding?: string): string {
+    return ArrayBuffers.toString(this, encoding as any);
+  }
+}

package/src/io/isBuffer.test.ts

@@ -0,0 +1,9 @@
+import test from 'ava';
+import { Buffer } from 'node:buffer';
+import { classOf } from '../langs/classOf';
+import { isBuffer } from './isBuffer';
+
+test('isBuffer', (t) => {
+  t.true(isBuffer(Buffer.from('')));
+  t.is(classOf(Buffer), 'Function');
+});