@wener/utils 1.1.8 → 1.1.10

package/lib/validations/parseTimestamp.js

@@ -0,0 +1,25 @@
+function parseTimestamp(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  if (raw instanceof Date) {
+    return raw;
+  }
+  if (typeof raw === "string" && /^[0-9.]+$/.test(raw)) {
+    let n = parseFloat(raw);
+    const len = Math.floor(n).toString().length;
+    if (len <= 11) {
+      n *= 1e3;
+    }
+    return new Date(n);
+  } else if (typeof raw === "string") {
+    const date = new Date(raw);
+    if (!isNaN(+date)) {
+      return date;
+    }
+  }
+  throw new Error(`parseTimestamp: invalid "${raw}"`);
+}
+
+export { parseTimestamp };
+//# sourceMappingURL=parseTimestamp.js.map

package/lib/validations/parseTimestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseTimestamp.js","sources":["../../src/validations/parseTimestamp.ts"],"sourcesContent":["export function parseTimestamp(raw?: string | number | Date): Date | undefined {\n  if (!raw) {\n    return undefined;\n  }\n  if (raw instanceof Date) {\n    return raw;\n  }\n\n  if (typeof raw === 'string' && /^[0-9.]+$/.test(raw)) {\n    let n = parseFloat(raw);\n    const len = Math.floor(n).toString().length;\n    /*\n    最常见的是 10 位和 13 位\n    9999999999 - 10*9 - 1970-04-26\n    99999999999 - 11*9 - 1973\n    999999999999 - 12*9 - 2001\n     */\n    if (len <= 11) {\n      n *= 1000;\n    }\n    return new Date(n);\n  } else if (typeof raw === 'string') {\n    const date = new Date(raw);\n    if (!isNaN(+date)) {\n      return date;\n    }\n  }\n  throw new Error(`parseTimestamp: invalid \"${raw}\"`);\n}\n"],"names":[],"mappings":"AAAO,SAAS,eAAe,GAAgD,EAAA;AAC7E,EAAA,IAAI,CAAC,GAAK,EAAA;AACR,IAAO,OAAA,KAAA,CAAA,CAAA;AAAA,GACT;AACA,EAAA,IAAI,eAAe,IAAM,EAAA;AACvB,IAAO,OAAA,GAAA,CAAA;AAAA,GACT;AAEA,EAAA,IAAI,OAAO,GAAQ,KAAA,QAAA,IAAY,WAAY,CAAA,IAAA,CAAK,GAAG,CAAG,EAAA;AACpD,IAAI,IAAA,CAAA,GAAI,WAAW,GAAG,CAAA,CAAA;AACtB,IAAA,MAAM,MAAM,IAAK,CAAA,KAAA,CAAM,CAAC,CAAA,CAAE,UAAW,CAAA,MAAA,CAAA;AAOrC,IAAA,IAAI,OAAO,EAAI,EAAA;AACb,MAAK,CAAA,IAAA,GAAA,CAAA;AAAA,KACP;AACA,IAAO,OAAA,IAAI,KAAK,CAAC,CAAA,CAAA;AAAA,GACnB,MAAA,IAAW,OAAO,GAAA,KAAQ,QAAU,EAAA;AAClC,IAAM,MAAA,IAAA,GAAO,IAAI,IAAA,CAAK,GAAG,CAAA,CAAA;AACzB,IAAA,IAAI,CAAC,KAAA,CAAM,CAAC,IAAI,CAAG,EAAA;AACjB,MAAO,OAAA,IAAA,CAAA;AAAA,KACT;AAAA,GACF;AACA,EAAM,MAAA,IAAI,KAAM,CAAA,CAAA,yBAAA,EAA4B,GAAM,CAAA,CAAA,CAAA,CAAA,CAAA;AACpD;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wener/utils",
-  "version": "1.1.8",
+  "version": "1.1.10",
   "type": "module",
   "description": "Utils for daily use",
   "repository": {
@@ -10,10 +10,6 @@
   "homepage": "https://github.com/wenerme/wode#readme",
   "author": "wener",
   "license": "MIT",
-  "engines": {
-    "node": "16",
-    "npm": "8"
-  },
   "main": "dist/cjs/index.cjs",
   "module": "lib/index.js",
   "exports": {
@@ -61,10 +57,11 @@
     "lodash"
   ],
   "devDependencies": {
-    "@types/lodash": "^4.14.186",
-    "ava": "^5.0.1",
-    "lodash": "^4",
-    "tsd": "^0.24.1"
+    "@types/lodash": "^4.14.191",
+    "ava": "^5.1.1",
+    "https-proxy-agent": "^5.0.1",
+    "lodash": "^4.17.21",
+    "tsd": "^0.25.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
@@ -77,6 +74,7 @@
     },
     "nodeArguments": [
       "--conditions=typescript",
+      "--experimental-import-meta-resolve",
       "--require=@wener/wode/suppress-experimental.cjs",
       "--loader=tsx"
     ]

package/src/arrays/arrayFromAsync.ts

@@ -0,0 +1,5 @@
+export async function arrayFromAsync<T>(asyncIterable: AsyncIterable<T>): Promise<T[]> {
+  const array = [];
+  for await (const i of asyncIterable) array.push(i);
+  return array;
+}

package/src/asyncs/createLazyPromise.ts

@@ -1,4 +1,5 @@
 import type { MaybePromise } from './MaybePromise';
+import { isPromise } from './isPromise';
 
 export type LazyPromise<T> = Promise<T> & {
   reject(reason?: any): void;
@@ -51,7 +52,7 @@ export function createLazyPromise<T = any>(
           // kind of bad
           const result = executor(holder.resolve, holder.reject);
           // ensure resolve/reject is called
-          if (result && 'then' in result) {
+          if (isPromise(result)) {
             result.then(holder.resolve, holder.reject);
           } else if (result !== undefined) {
             holder.resolve(result);

package/src/asyncs/isThenable.ts

@@ -0,0 +1,4 @@
+export function isThenable(v: any): v is PromiseLike<any> {
+  // we are at Promise era now, so we can use Promise instead of PromiseLike
+  return v && typeof v.then === 'function';
+}

package/src/crypto/getRandomValues.ts

@@ -1,10 +1,13 @@
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import type { TypedArray } from '../io/ArrayBuffers';
+
 let nodeCrypto: Awaited<typeof import('node:crypto')>;
 // globalThis.process?.release?.name
 
-// typedoc error
-if (!(process as any).browser) {
+// avoid process.browser
+if (typeof window === 'undefined') {
   try {
+    // UnhandledSchemeError https://github.com/vercel/next.js/issues/28774
     if (typeof require === 'undefined') {
       void import('node:crypto').then((v) => (nodeCrypto = v.default));
     } else {
@@ -13,12 +16,14 @@ if (!(process as any).browser) {
   } catch (e) {}
 }
 
-export let getRandomValues: <T extends Exclude<NodeJS.TypedArray, Float32Array | Float64Array>>(typedArray: T) => T =
-  globalThis.crypto?.getRandomValues || (globalThis as any).msCrypto?.getRandomValues || _getRandomValues;
+export let getRandomValues: <T extends Exclude<TypedArray, Float32Array | Float64Array>>(typedArray: T) => T =
+  globalThis.crypto?.getRandomValues?.bind(globalThis.crypto) ||
+  (globalThis as any).msCrypto?.getRandomValues?.bind((globalThis as any).msCrypto) ||
+  _getRandomValues;
 
-function _getRandomValues<T extends Exclude<NodeJS.TypedArray, Float32Array | Float64Array>>(buf: T) {
+function _getRandomValues<T extends Exclude<TypedArray, Float32Array | Float64Array>>(buf: T) {
   if (nodeCrypto?.webcrypto?.getRandomValues) {
-    getRandomValues = nodeCrypto?.webcrypto?.getRandomValues;
+    getRandomValues = nodeCrypto?.webcrypto?.getRandomValues?.bind(nodeCrypto?.webcrypto);
     return nodeCrypto.webcrypto.getRandomValues(buf);
   }
   if (nodeCrypto?.randomBytes) {
@@ -36,5 +41,5 @@ function _getRandomValues<T extends Exclude<NodeJS.TypedArray, Float32Array | Fl
     buf.set(bytes);
     return buf;
   }
-  throw new Error('No secure random number generator available.');
+  throw new Error('[getRandomValues]: No secure random number generator available.');
 }

package/src/crypto/hashing.test.ts

@@ -1,8 +1,8 @@
 import test from 'ava';
-import { polyfillCrypto } from '../server/polyfillCrypto';
+import { polyfillCrypto } from '../servers/polyfillCrypto';
 import { isUUID } from '../validations/isUUID';
-import { sha1, sha256, sha384, sha512 } from './hashing';
 import { hex } from './base';
+import { sha1, sha256, sha384, sha512 } from './hashing';
 import { _randomUUID } from './randomUUID';
 
 test.before(async () => {

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

@@ -0,0 +1,63 @@
+import test from 'ava';
+import { ArrayBuffers } from '../../io/ArrayBuffers';
+import { PEM } from './pem';
+
+const { decode, encode } = PEM;
+
+test('pem', (t) => {
+  const pem = `-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: DES-EDE3-CBC,ABC
+
+MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw
+MDAwMDAwMDAwMDAwMDAwMA==
+-----END RSA PRIVATE KEY-----
+`;
+  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',
+  };
+  t.deepEqual(decode(input), out);
+  t.is(encode(out.block), pem);
+});
+test('cases', (t) => {
+  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);
+    t.deepEqual(
+      {
+        ...act.block,
+        bytes: ArrayBuffers.toString(act.block.bytes),
+      },
+      {
+        header: {},
+        ...b,
+        bytes: ArrayBuffers.toString(b.bytes),
+      },
+    );
+    t.snapshot(s);
+  }
+});

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

@@ -0,0 +1,24 @@
+# Snapshot report for `packages/utils/src/crypto/pem.test.ts`
+
+The actual snapshot is saved in `pem.test.ts.snap`.
+
+Generated by [AVA](https://avajs.dev).
+
+## cases
+
+> Snapshot 1
+
+    `-----BEGIN RSA PRIVATE KEY-----␊
+    SGVsbG8=␊
+    -----END RSA PRIVATE KEY-----␊
+    `
+
+> Snapshot 2
+
+    `-----BEGIN RSA PRIVATE KEY-----␊
+    Name: N-:1/=␊
+    Age: 1234␊
+    ␊
+    TmljZQ==␊
+    -----END RSA PRIVATE KEY-----␊
+    `

package/src/crypto/pem/pem.ts

@@ -0,0 +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';
+
+  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 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/randomUUID.ts

@@ -1,7 +1,7 @@
 /**
  * generate random UUIDv4
  */
-export const randomUUID: () => string = globalThis.crypto?.randomUUID || _randomUUID;
+export const randomUUID: () => string = globalThis.crypto?.randomUUID?.bind(globalThis.crypto) || _randomUUID;
 
 /**
  * @internal

package/src/crypto/ulid.test.ts

@@ -1,5 +1,5 @@
 import test from 'ava';
-import { createULID, parseULID } from './ulid';
+import { createULID, isULID, parseULID } from './ulid';
 
 test('ulid', (t) => {
   // monotonic
@@ -13,10 +13,18 @@ test('ulid', (t) => {
     });
 
     const ulid1 = ulid();
-    t.is(parseULID(ulid1).time, lastTime);
+    t.is(parseULID(ulid1).timestamp, lastTime);
+    t.true(isULID(ulid1), ulid1);
 
     const ulid2 = ulid();
     t.true(ulid1 < ulid2);
-    t.is(parseULID(ulid2).time, lastTime);
+    t.true(isULID(ulid2), ulid2);
+    t.is(parseULID(ulid2).timestamp, lastTime);
+  }
+
+  {
+    const next = createULID();
+    t.true(isULID(next().toLowerCase()));
+    t.true(isULID('ttttttttttrrrrrrrrrrrrrrrr'));
   }
 });

package/src/crypto/ulid.ts

@@ -31,7 +31,8 @@ const RANDOM_LEN = 16;
  * check give {@link str} is a valid ulid
  */
 export function isULID(str: string): boolean {
-  return str?.length === 26 && /^[0-9A-HJKMNP-TV-Z]{26}$/.test(str);
+  // ttttttttttrrrrrrrrrrrrrrrr
+  return str?.length === 26 && /^[0-9A-HJKMNP-TV-Z]{26}$/i.test(str);
 }
 
 function replaceCharAt(str: string, index: number, char: string) {
@@ -109,7 +110,7 @@ function encodeRandom(len: number, prng: PRNG): string {
  *
  * @throws ULIDError
  */
-export function parseULID(id: string): { time: number; random: string } {
+export function parseULID(id: string): { timestamp: number; random: string } {
   if (id.length !== TIME_LEN + RANDOM_LEN) {
     throw createError('malformed ulid');
   }
@@ -127,7 +128,7 @@ export function parseULID(id: string): { time: number; random: string } {
   if (time > TIME_MAX) {
     throw createError('malformed ulid, timestamp too large');
   }
-  return { time, random: id.substring(TIME_LEN) };
+  return { timestamp: time, random: id.substring(TIME_LEN) };
 }
 
 function createPrng(): PRNG {
@@ -157,7 +158,7 @@ export function createULID({
   let lastRandom: string;
   return function ulid(seedTime?: number): string {
     seedTime ||= now();
-    if (seedTime <= lastTime) {
+    if (seedTime <= lastTime && lastRandom) {
       const incrementedRandom = (lastRandom = incrementBase32(lastRandom));
       return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
     }

package/src/fetch/index.ts

@@ -0,0 +1 @@
+export type FetchLike = (url: string | Request, init?: RequestInit) => Promise<Response>;

package/src/index.ts

@@ -6,6 +6,7 @@ export {
   objectOfMaybeArray,
   type MaybeArray,
 } from './arrays/MaybeArray';
+export { arrayFromAsync } from './arrays/arrayFromAsync';
 
 // object
 export { get } from './objects/get';
@@ -27,13 +28,16 @@ export { shallowEqual } from './langs/shallowEqual';
 export { deepEqual } from './langs/deepEqual';
 export { classOf } from './langs/classOf';
 export { shallowClone } from './langs/shallowClone';
+export { isClass } from './langs/isClass';
+export { isDefined } from './langs/isDefined';
+export { isEmptyObject } from './langs/isEmptyObject';
+export { isPlainObject } from './langs/isPlainObject';
+export { parseBoolean } from './langs/parseBoolean';
+export { maybeFunction, type MaybeFunction } from './langs/MaybeFunction';
+export { memoize } from './langs/memoize';
 
-// assertions
-export { isClass } from './validations/isClass';
-export { isDefined } from './validations/isDefined';
-export { isEmptyObject } from './validations/isEmptyObject';
 export { isUUID } from './validations/isUUID';
-export { isPlainObject } from './validations/isPlainObject';
+export { parseTimestamp } from './validations/parseTimestamp';
 
 // modules
 export { parseModuleId, type ParsedModuleId } from './modules/parseModuleId';
@@ -41,7 +45,7 @@ export { isModule, type Module } from './modules/isModule';
 
 // logging
 export { type Logger, type LogLevel } from './logging/Logger';
-export { createWriteLogger } from './logging/createWriteLogger';
+export { createLogger } from './logging/createLogger';
 export { createNoopLogger } from './logging/createNoopLogger';
 export { createChildLogger } from './logging/createChildLogger';
 
@@ -76,6 +80,9 @@ export { getRandomValues } from './crypto/getRandomValues';
 export { sha1, sha256, sha384, sha512 } from './crypto/hashing';
 export { hex } from './crypto/base';
 export { isULID, createULID, ulid, parseULID } from './crypto/ulid';
+export { PEM } from './crypto/pem/pem';
 
 // misc
 export { createRandom } from './maths/random';
+
+export { type FetchLike } from './fetch';

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

@@ -1,8 +1,9 @@
 import test from 'ava';
 import { ArrayBuffers } from './ArrayBuffers';
 
-test.before(() => {
-  ArrayBuffers.setAllowedNativeBuffer(false);
+test.before((t) => {
+  t.true(ArrayBuffers.isNativeBufferAvailable());
+  ArrayBuffers.setNativeBufferAllowed(false);
 });
 
 test('base64: ignore whitespace', function (t) {

package/src/io/ArrayBuffers.ts

@@ -1,4 +1,5 @@
 import { classOf } from '../langs/classOf';
+import { decodeBase64ToArrayBuffer, encodeArrayBufferToBase64 } from './base64';
 import { isBuffer } from './isBuffer';
 
 /**
@@ -67,14 +68,20 @@ type ToStringEncoding =
   | 'hex';
 
 export class ArrayBuffers {
-  static #_allowedNativeBuffer: boolean = true;
+  static #nativeBufferAllowed: boolean = true;
+  static #isBufferAvailable: undefined | boolean;
 
-  static #isNativeBufferValid() {
-    return this.#_allowedNativeBuffer && !(globalThis.Buffer as any)?.isPollyfill?.();
+  static isNativeBufferAvailable() {
+    // eslint-disable-next-line no-return-assign
+    return (this.#isBufferAvailable ??= !(globalThis.Buffer as any)?.isPollyfill?.());
   }
 
-  static setAllowedNativeBuffer(v: boolean) {
-    this.#_allowedNativeBuffer = v;
+  static isNativeBufferAllowed() {
+    return this.#nativeBufferAllowed && this.#isBufferAvailable;
+  }
+
+  static setNativeBufferAllowed(v: boolean) {
+    this.#nativeBufferAllowed = v;
   }
 
   static isArrayBuffer = (v: any): v is ArrayBuffer => {
@@ -100,7 +107,7 @@ export class ArrayBuffers {
       return v as I;
     }
     if (ArrayBuffer.isView(v) || isBuffer(v)) {
-      if (ArrayBuffers.#isNativeBufferValid() && (TypedArray as any) === Buffer) {
+      if (ArrayBuffers.isNativeBufferAllowed() && (TypedArray as any) === Buffer) {
         // new Buffer() is deprecated
         return Buffer.from(v.buffer, byteOffset, byteLength) as I;
       }
@@ -112,9 +119,17 @@ export class ArrayBuffers {
   static toString = (buf: BufferSource | string, encoding: ToStringEncoding = 'utf8') => {
     // 'ascii'  'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'
     if (typeof buf === 'string') {
-      return buf;
+      switch (encoding) {
+        case 'base64':
+          return btoa(buf);
+        case 'utf-8':
+        case 'utf8':
+          return buf;
+        default:
+          throw new Error(`[ArrayBuffers.toString] Unsupported encoding for string: ${encoding}`);
+      }
     }
-    if (ArrayBuffers.#isNativeBufferValid()) {
+    if (ArrayBuffers.isNativeBufferAllowed()) {
       return Buffer.from(ArrayBuffers.asView(Uint8Array, buf)).toString(encoding);
     }
     // reference
@@ -125,8 +140,7 @@ export class ArrayBuffers {
         return [...view].map((b) => hexLookupTable[b]).join('');
       }
       case 'base64': {
-        const view: Uint8Array = ArrayBuffers.asView(Uint8Array, buf);
-        return btoa(String.fromCharCode(...view));
+        return encodeArrayBufferToBase64(ArrayBuffers.asView(Uint8Array, buf));
       }
       case 'utf8':
       // falls through
@@ -185,7 +199,7 @@ export class ArrayBuffers {
       return new ArrayBuffer(0);
     }
     if (typeof v === 'string') {
-      if (ArrayBuffers.#isNativeBufferValid()) {
+      if (ArrayBuffers.isNativeBufferAllowed()) {
         return Buffer.from(v, encoding);
       }
 
@@ -195,8 +209,10 @@ export class ArrayBuffers {
         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));
+          // replaceAll need higher version of nodejs
+          return decodeBase64ToArrayBuffer(v.replace(/[^0-9a-zA-Z=+/_]/g, ''));
+        // error in nodejs 18
+        // 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}`);
       }
@@ -244,7 +260,7 @@ export class 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;
+      if (!buffer?.byteLength) continue;
       let n: Uint8Array;
       if (buffer instanceof ArrayBuffer) {
         n = new Uint8Array(buffer);

package/src/io/base64.ts

@@ -0,0 +1,64 @@
+// https://github.com/niklasvh/base64-arraybuffer/blob/master/src/index.ts
+
+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;
+}
+
+export function encodeArrayBufferToBase64(arraybuffer: ArrayBuffer): 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];
+  }
+
+  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;
+}
+
+export function decodeBase64ToArrayBuffer(base64: string): ArrayBuffer {
+  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--;
+    }
+  }
+
+  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)];
+
+    bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
+    bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+    bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+  }
+
+  return arraybuffer;
+}

package/src/langs/MaybeFunction.ts

@@ -0,0 +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;
+}

package/src/langs/README.md

@@ -0,0 +1,4 @@
+# Core
+
+- https://github.com/angus-c/just
+- lodash

package/src/{validations → langs}/isPlainObject.ts

@@ -1,4 +1,4 @@
-import { classOf } from '../langs/classOf';
+import { classOf } from './classOf';
 
 // see: https://github.com/mesqueeb/is-what/blob/88d6e4ca92fb2baab6003c54e02eedf4e729e5ab/src/index.ts