@wener/utils 1.1.6 → 1.1.8

package/src/browsers/loaders.ts

@@ -26,21 +26,16 @@ export function loadScripts(
   options?: { attributes: Record<string, string> },
 ): Promise<HTMLScriptElement | HTMLScriptElement[]> {
   if (Array.isArray(src)) {
-    return new Promise(async (resolve, reject) => {
+    return Promise.resolve().then(async () => {
       const all = [];
-      try {
-        for (let s of src) {
-          all.push(await loadScripts(s));
-        }
-      } catch (e) {
-        reject(e);
-        return;
+      for (const s of src) {
+        all.push(await loadScripts(s));
       }
-      resolve(all);
+      return all;
     });
   }
   // todo quote ?
-  let $ele = document.querySelector(`script[src="${src}"]`) as HTMLScriptElement;
+  const $ele = document.querySelector(`script[src="${src}"]`) as HTMLScriptElement;
   if ($ele) {
     return Promise.resolve($ele);
   }
@@ -52,7 +47,7 @@ export function loadScripts(
 }
 
 export function loadStyles(href: string, options?: { attributes: Record<string, string> }): Promise<HTMLLinkElement> {
-  let $ele = document.querySelector(`link[href="${href}"]`) as HTMLLinkElement;
+  const $ele = document.querySelector(`link[href="${href}"]`) as HTMLLinkElement;
   if ($ele) {
     return Promise.resolve($ele);
   }

package/src/crypto/{hex.ts → base.ts}

@@ -1,3 +1,6 @@
+/**
+ * hex string
+ */
 export function hex(s: Uint8Array | ArrayBuffer) {
   return Array.from(new Uint8Array(s))
     .map((v) => v.toString(16).padStart(2, '0'))

package/src/crypto/getRandomValues.ts

@@ -0,0 +1,40 @@
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+let nodeCrypto: Awaited<typeof import('node:crypto')>;
+// globalThis.process?.release?.name
+
+// typedoc error
+if (!(process as any).browser) {
+  try {
+    if (typeof require === 'undefined') {
+      void import('node:crypto').then((v) => (nodeCrypto = v.default));
+    } else {
+      nodeCrypto = require('node:crypto');
+    }
+  } catch (e) {}
+}
+
+export let getRandomValues: <T extends Exclude<NodeJS.TypedArray, Float32Array | Float64Array>>(typedArray: T) => T =
+  globalThis.crypto?.getRandomValues || (globalThis as any).msCrypto?.getRandomValues || _getRandomValues;
+
+function _getRandomValues<T extends Exclude<NodeJS.TypedArray, Float32Array | Float64Array>>(buf: T) {
+  if (nodeCrypto?.webcrypto?.getRandomValues) {
+    getRandomValues = nodeCrypto?.webcrypto?.getRandomValues;
+    return nodeCrypto.webcrypto.getRandomValues(buf);
+  }
+  if (nodeCrypto?.randomBytes) {
+    if (!(buf instanceof Uint8Array)) {
+      throw new TypeError('expected Uint8Array');
+    }
+    if (buf.length > 65536) {
+      const e: any = new Error();
+      e.code = 22;
+      e.message = `Failed to execute 'getRandomValues' on 'Crypto': The ArrayBufferView's byte length (${buf.length}) exceeds the number of bytes of entropy available via this API (65536).`;
+      e.name = 'QuotaExceededError';
+      throw e;
+    }
+    const bytes = nodeCrypto.randomBytes(buf.length);
+    buf.set(bytes);
+    return buf;
+  }
+  throw new Error('No secure random number generator available.');
+}

package/src/crypto/hashing.test.ts

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

package/src/crypto/hashing.ts

@@ -1,16 +1,16 @@
-export async function sha1(s: string | BufferSource) {
+export function sha1(s: string | BufferSource) {
   return digestOf('SHA-1', s);
 }
 
-export async function sha256(s: string | BufferSource) {
+export function sha256(s: string | BufferSource) {
   return digestOf('SHA-256', s);
 }
 
-export async function sha384(s: string | BufferSource) {
+export function sha384(s: string | BufferSource) {
   return digestOf('SHA-384', s);
 }
 
-export async function sha512(s: string | BufferSource) {
+export function sha512(s: string | BufferSource) {
   return digestOf('SHA-512', s);
 }
 

package/src/crypto/randomUUID.ts

@@ -3,6 +3,9 @@
  */
 export const randomUUID: () => string = globalThis.crypto?.randomUUID || _randomUUID;
 
+/**
+ * @internal
+ */
 export function _randomUUID() {
   return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
     const r = (Math.random() * 16) | 0;

package/src/crypto/ulid.test.ts

@@ -0,0 +1,22 @@
+import test from 'ava';
+import { createULID, parseULID } from './ulid';
+
+test('ulid', (t) => {
+  // monotonic
+  {
+    let lastTime = 0;
+    const ulid = createULID({
+      now: () => {
+        lastTime ||= Date.now();
+        return lastTime;
+      },
+    });
+
+    const ulid1 = ulid();
+    t.is(parseULID(ulid1).time, lastTime);
+
+    const ulid2 = ulid();
+    t.true(ulid1 < ulid2);
+    t.is(parseULID(ulid2).time, lastTime);
+  }
+});

package/src/crypto/ulid.ts

@@ -0,0 +1,182 @@
+import { getRandomValues } from './getRandomValues';
+
+type PRNG = () => number;
+
+/**
+ * Universally Unique Lexicographically Sortable Identifier
+ *
+ * @see https://github.com/ulid/spec ulid/spec
+ */
+export type ULID = (seedTime?: number) => string;
+
+export interface ULIDError extends Error {
+  source: string;
+}
+
+function createError(message: string): ULIDError {
+  const err = new Error(message) as ULIDError;
+  err.source = 'ulid';
+  return err;
+}
+
+// These values should NEVER change. If
+// they do, we're no longer making ulids!
+const ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'; // Crockford's Base32
+const ENCODING_LEN = ENCODING.length;
+const TIME_MAX = Math.pow(2, 48) - 1;
+const TIME_LEN = 10;
+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);
+}
+
+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);
+}
+
+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');
+}
+
+function randomChar(prng: PRNG): string {
+  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;
+}
+
+function encodeRandom(len: number, prng: PRNG): string {
+  let str = '';
+  for (; len > 0; len--) {
+    str = randomChar(prng) + str;
+  }
+  return str;
+}
+
+/**
+ * extract time & random from ulid
+ *
+ * @throws ULIDError
+ */
+export function parseULID(id: string): { time: 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 { time, random: id.substring(TIME_LEN) };
+}
+
+function createPrng(): PRNG {
+  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?: 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) {
+      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);
+};
+let _real: ULID;

package/src/i18n/createTranslate.test.ts

@@ -2,7 +2,7 @@ import test from 'ava';
 import { createTranslate } from './createTranslate';
 
 test('exports', (t) => {
-  let out = createTranslate();
+  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');
@@ -10,7 +10,7 @@ test('exports', (t) => {
 });
 
 test('usage', (t) => {
-  let ctx = createTranslate({
+  const ctx = createTranslate({
     en: { hello: 'Hello, {{name}}!' },
     es: { hello: 'Hola {{name}}!' },
     pt: { foo: 'foo {{name}}~!' },
@@ -18,23 +18,23 @@ test('usage', (t) => {
 
   t.deepEqual(ctx.dict('en'), { hello: 'Hello, {{name}}!' });
 
-  t.is(ctx.dict('foobar'), undefined);
+  t.true(ctx.dict('foobar') === undefined);
 
-  let foo = ctx.t('hello');
+  const foo = ctx.t('hello');
   t.is(foo, '', '~> "" w/o locale');
 
   t.is(ctx.locale('en'), 'en', '>>> ctx.locale()');
 
   t.is(ctx.locale(), 'en');
 
-  let bar = ctx.t('hello');
+  const bar = ctx.t('hello');
   t.not(bar, '', '(en) found "hello" key');
   t.is(bar, 'Hello, !', '~> interpolations empty if missing param');
 
-  let baz = ctx.t('hello', { name: 'world' });
+  const baz = ctx.t('hello', { name: 'world' });
   t.is(baz, 'Hello, world!', '~> interpolations successful');
 
-  let bat = ctx.t('hello', { name: 'world' }, 'es');
+  const bat = ctx.t('hello', { name: 'world' }, 'es');
   t.not(bat, '', '(es) found "hello" key');
   t.is(bat, 'Hola world!', '~> success');
 
@@ -42,11 +42,11 @@ test('usage', (t) => {
 
   t.is(ctx.dict('pt', { hello: 'Oí {{name}}!' }), undefined, '>>> ctx.dict()');
 
-  let quz = ctx.t('hello', { name: 'world' }, 'pt');
+  const quz = ctx.t('hello', { name: 'world' }, 'pt');
   t.not(quz, '', '(pt) found "hello" key');
   t.is(quz, 'Oí world!', '~> success');
 
-  let qut = ctx.t('foo', { name: 'bar' }, 'pt');
+  const qut = ctx.t('foo', { name: 'bar' }, 'pt');
   t.not(qut, '', '(pt) found "foo" key');
   t.is(qut, 'foo bar~!', '~> success');
 
@@ -58,7 +58,7 @@ test('usage', (t) => {
   t.is(ctx.locale(null as any), 'es');
   t.is(ctx.locale(0 as any), 'es');
 
-  let qux = ctx.t('hello', { name: 'default' });
+  const qux = ctx.t('hello', { name: 'default' });
   t.not(qux, '', '(es) found "hello" key');
   t.is(qux, 'Hola default!', '~> success');
 
@@ -66,13 +66,13 @@ test('usage', (t) => {
 
   t.is(ctx.dict('de', { hello: 'Hallo {{name}}!' }), undefined, '>>> ctx.dict(de)');
 
-  let qar = ctx.t('hello', { name: 'world' }, '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) => {
-  let ctx = createTranslate({
+  const ctx = createTranslate({
     en: {
       hello(value: any) {
         return `hello ${value || 'stranger'}~!`;
@@ -82,18 +82,18 @@ test('functional', (t) => {
 
   ctx.locale('en');
 
-  let foo = ctx.t('hello');
+  const foo = ctx.t('hello');
   t.is(foo, 'hello stranger~!', '~> called function w/o param');
 
-  let bar = ctx.t('hello', 'world' as any);
+  const bar = ctx.t('hello', 'world' as any);
   t.is(bar, 'hello world~!', '~> called function w/ param (string)');
 
-  let baz = ctx.t('hello', [1, 2, 3]);
+  const baz = ctx.t('hello', [1, 2, 3]);
   t.is(baz, 'hello 1,2,3~!', '~> called function w/ param (array)');
 });
 
 test('nested', (t) => {
-  let ctx = createTranslate({
+  const ctx = createTranslate({
     en: {
       fruits: {
         apple: 'apple',
@@ -126,7 +126,7 @@ test('nested', (t) => {
 });
 
 test('arrays', (t) => {
-  let ctx = createTranslate({
+  const ctx = createTranslate({
     en: {
       foo: '{{0}} + {{1}} = {{2}}',
       bar: [
@@ -145,7 +145,7 @@ test('arrays', (t) => {
 });
 
 test('invalid value', (t) => {
-  let ctx = createTranslate({
+  const ctx = createTranslate({
     en: {
       foo: ['bar'],
     },
@@ -153,3 +153,18 @@ test('invalid value', (t) => {
 
   t.deepEqual(ctx.t('foo', null as any, 'en'), ['bar']);
 });
+
+test('fallback', (t) => {
+  const ctx = createTranslate({
+    en: {
+      a: 'a',
+    },
+    'en-US': {
+      a: 'a-US',
+    },
+  });
+
+  // t.deepEqual(ctx.t('a', undefined, 'en'), 'a');
+  // t.deepEqual(ctx.t('a', undefined, 'en-US'), 'a-US');
+  t.deepEqual(ctx.t('a', undefined, 'en-UK'), 'a');
+});

package/src/i18n/createTranslate.ts

@@ -1,5 +1,5 @@
 import { get } from '../objects/get';
-import { ObjectPathLike } from '../objects/parseObjectPath';
+import type { ObjectPathLike } from '../objects/parseObjectPath';
 import { renderTemplate } from '../strings/renderTemplate';
 
 export interface Translate<T extends object> {
@@ -19,7 +19,17 @@ export interface Translate<T extends object> {
 export function createTranslate<T extends object>(obj?: Record<string, T>): Translate<T> {
   let locale = '';
   const tree = obj || {};
-
+  // en-US -> en-US,en
+  const keyOfDict = (s: string | string[]) => {
+    if (Array.isArray(s)) {
+      return s;
+    }
+    const sp = s.split(/[_-]/);
+    if (sp.length > 1) {
+      return [s, sp[0]];
+    }
+    return [s];
+  };
   return {
     locale(lang) {
       return (locale = lang || locale);
@@ -34,7 +44,13 @@ export function createTranslate<T extends object>(obj?: Record<string, T>): Tran
     }) as Translate<T>['dict'],
 
     t(key, params, lang) {
-      const val = get(tree[lang || locale], key, '') as any;
+      let val: any;
+      for (const k of keyOfDict(lang || locale)) {
+        val = get(tree[k], key, '');
+        if (val) {
+          break;
+        }
+      }
       if (process.env.NODE_ENV === 'development') {
         if (val == null) {
           return console.error(
@@ -45,7 +61,7 @@ export function createTranslate<T extends object>(obj?: Record<string, T>): Tran
         }
       }
       if (typeof val === 'function') return val(params);
-      if (typeof val === 'string') return renderTemplate(val, params!, 'common');
+      if (typeof val === 'string') return renderTemplate(val, params, 'common');
       return val;
     },
   };

package/src/index.ts

@@ -22,15 +22,18 @@ export { timeout, TimeoutError } from './asyncs/timeout';
 export { isPromise } from './asyncs/isPromise';
 // export * from './async/promiseOfCallback';
 
-// validations
+// langs
+export { shallowEqual } from './langs/shallowEqual';
+export { deepEqual } from './langs/deepEqual';
+export { classOf } from './langs/classOf';
+export { shallowClone } from './langs/shallowClone';
+
+// assertions
 export { isClass } from './validations/isClass';
 export { isDefined } from './validations/isDefined';
 export { isEmptyObject } from './validations/isEmptyObject';
-export { shallowEqual } from './langs/shallowEqual';
-export { deepEqual } from './langs/deepEqual';
 export { isUUID } from './validations/isUUID';
-
-export { classOf } from './langs/classOf';
+export { isPlainObject } from './validations/isPlainObject';
 
 // modules
 export { parseModuleId, type ParsedModuleId } from './modules/parseModuleId';
@@ -53,6 +56,9 @@ export { createTranslate } from './i18n/createTranslate';
 // io
 export { isBuffer } from './io/isBuffer';
 export { isTransferable } from './io/isTransferable';
+export { ArrayBuffers } from './io/ArrayBuffers';
+export { Buffer } from './io/Buffer';
+export type { AbstractEncoding } from './io/AbstractEncoding';
 
 // browser
 export { copy } from './browsers/copy';
@@ -66,9 +72,10 @@ export { structuredClone } from './isomorphics/structuredClone';
 
 // crypto
 export { randomUUID } from './crypto/randomUUID';
+export { getRandomValues } from './crypto/getRandomValues';
 export { sha1, sha256, sha384, sha512 } from './crypto/hashing';
-export { hex } from './crypto/hex';
+export { hex } from './crypto/base';
+export { isULID, createULID, ulid, parseULID } from './crypto/ulid';
 
 // misc
 export { createRandom } from './maths/random';
-export { urljoin } from './shim/urljoin';

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.setAllowedNativeBuffer(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);
+});