@wener/utils 1.1.51 → 1.1.53

package/src/i18n/createTranslate.test.ts

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

package/src/i18n/createTranslate.ts

@@ -3,67 +3,67 @@ import type { ObjectPathLike } from '../objects/parseObjectPath';
 import { renderTemplate } from '../strings/renderTemplate';
 
 export interface Translate<T extends object> {
-  /** Get/Set the language key */
-  locale(lang?: string): string;
+	/** Get/Set the language key */
+	locale(lang?: string): string;
 
-  /** Define the dict of translations for a language */
-  dict(lang: string, dict: T): void;
+	/** 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;
+	/** 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;
+	/** 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 || {};
-  // 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);
-    },
+	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);
+		},
 
-    dict: ((lang, dict?) => {
-      if (dict) {
-        tree[lang] = Object.assign(tree[lang] || {}, dict);
-        return;
-      }
-      return tree[lang];
-    }) as Translate<T>['dict'],
+		dict: ((lang, dict?) => {
+			if (dict) {
+				tree[lang] = Object.assign(tree[lang] || {}, dict);
+				return;
+			}
+			return tree[lang];
+		}) as Translate<T>['dict'],
 
-    t(key, params, lang) {
-      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) {
-          console.error(
-            `[Translate] Missing the "${[].concat(key as any).join('.')}" key within the "${
-              lang || locale
-            }" dictionary`,
-          );
-          return;
-        }
-      }
-      if (typeof val === 'function') return val(params);
-      if (typeof val === 'string') return renderTemplate(val, params, 'common');
-      return val;
-    },
-  };
+		t(key, params, lang) {
+			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) {
+					console.error(
+						`[Translate] Missing the "${[].concat(key as any).join('.')}" key within the "${
+							lang || locale
+						}" dictionary`,
+					);
+					return;
+				}
+			}
+			if (typeof val === 'function') return val(params);
+			if (typeof val === 'string') return renderTemplate(val, params, 'common');
+			return val;
+		},
+	};
 }

package/src/index.ts

@@ -2,11 +2,11 @@ import { Promises } from './asyncs/Promises';
 
 // arrays
 export {
-  firstOfMaybeArray,
-  lastOfMaybeArray,
-  arrayOfMaybeArray,
-  objectOfMaybeArray,
-  type MaybeArray,
+	firstOfMaybeArray,
+	lastOfMaybeArray,
+	arrayOfMaybeArray,
+	objectOfMaybeArray,
+	type MaybeArray,
 } from './arrays/MaybeArray';
 export { arrayFromAsync } from './arrays/arrayFromAsync';
 
@@ -33,6 +33,7 @@ export const isPromise = Promises.isPromise;
 export { timeout, TimeoutError } from './asyncs/timeout';
 
 // langs
+export { isNil } from './langs/isNil';
 export { shallowEqual } from './langs/shallowEqual';
 export { deepEqual } from './langs/deepEqual';
 export { deepFreeze } from './langs/deepFreeze';
@@ -61,16 +62,11 @@ export { parseTimestamp } from './validations/parseTimestamp';
 export { parseModuleId, type ParsedModuleId } from './modules/parseModuleId';
 export { isModule, type Module } from './modules/isModule';
 
-// logging
-export { type Logger, type LogLevel } from './logging/Logger';
-export { createLogger } from './logging/createLogger';
-export { createNoopLogger } from './logging/createNoopLogger';
-export { createChildLogger } from './logging/createChildLogger';
-
 // strings
 export { pascalCase, camelCase } from './strings/camelCase';
 export { renderTemplate } from './strings/renderTemplate';
 export { formatBytes } from './strings/formatBytes';
+export { parseBytes } from './strings/parseBytes';
 
 // i18n
 export { createTranslate } from './i18n/createTranslate';
@@ -82,6 +78,7 @@ export { ArrayBuffers } from './io/ArrayBuffers';
 export { ByteBuffer } from './io/ByteBuffer';
 export { fromHexDump, toHexDump } from './io/dump';
 export { Buffer } from './io/Buffer';
+export { type Bytes } from './io/types';
 export { parseDataUri, type ParsedDataUri } from './io/parseDataUri';
 export type { AbstractEncoding } from './io/AbstractEncoding';
 
@@ -110,20 +107,21 @@ export { clamp } from './maths/clamp';
 
 // network
 export {
-  type FetchLike,
-  createFetchWith,
-  createFetchWithLogging,
-  dumpResponse,
-  dumpRequest,
-  createFetchWithRetry,
-  type FetchWithRetryOptions,
+	type FetchLike,
+	createFetchWith,
+	createFetchWithLogging,
+	dumpResponse,
+	dumpRequest,
+	createFetchWithRetry,
+	type FetchWithRetryOptions,
 } from './fetch';
 
 // bundled
 export { default as ms } from './libs/ms';
 
 // error
-export { Errors, DetailError, type ErrorDetail, type ErrorDetailInit } from './errors/Errors';
+export { Errors } from './errors/Errors';
+export { DetailError, type ErrorDetail, type ErrorDetailInit } from './errors/DetailError';
 // http
 export { getHttpStatusText, isRetryableHttpStatus } from './fetch/HttpStatus';
 

package/src/io/AbstractEncoding.ts

@@ -4,18 +4,18 @@
  * @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;
+	/**
+	 * 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;
+	/**
+	 * decode data from buffer
+	 */
+	decode(buffer: BufferSource, start?: number, end?: number): T;
 
-  /**
-   * byteLength of data
-   */
-  byteLength?: (data: T) => number;
+	/**
+	 * byteLength of data
+	 */
+	byteLength?: (data: T) => number;
 }

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

@@ -2,5 +2,5 @@ import { expectTypeOf, test } from 'vitest';
 import { ArrayBuffers } from './ArrayBuffers';
 
 test('my types work properly', () => {
-  expectTypeOf(ArrayBuffers.asView(Buffer, new Uint8Array())).toMatchTypeOf<Buffer>();
+	expectTypeOf(ArrayBuffers.asView(Buffer, new Uint8Array())).toExtend<Buffer>();
 });

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

@@ -2,92 +2,92 @@ import { assert, beforeAll, expect, test } from 'vitest';
 import { ArrayBuffers } from './ArrayBuffers';
 
 beforeAll(() => {
-  expect(ArrayBuffers.isNativeBufferAvailable()).toBeTruthy();
-  ArrayBuffers.setNativeBufferAllowed(false);
+	expect(ArrayBuffers.isNativeBufferAvailable()).toBeTruthy();
+	ArrayBuffers.setNativeBufferAllowed(false);
 });
 
 test('base64: ignore whitespace', function () {
-  const text = '\n   YW9ldQ==  ';
-  const buf = ArrayBuffers.from(text, 'base64');
-  expect(ArrayBuffers.toString(buf)).toBe('aoeu');
+	const text = '\n   YW9ldQ==  ';
+	const buf = ArrayBuffers.from(text, 'base64');
+	expect(ArrayBuffers.toString(buf)).toBe('aoeu');
 });
 
 test('base64: strings without padding', function () {
-  expect(ArrayBuffers.toString(ArrayBuffers.from('YW9ldQ', 'base64'))).toBe('aoeu');
+	expect(ArrayBuffers.toString(ArrayBuffers.from('YW9ldQ', 'base64'))).toBe('aoeu');
 });
 
 test('base64: newline in utf8 -- should not be an issue', function () {
-  assert.equal(
-    ArrayBuffers.toString(
-      ArrayBuffers.from('LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK', 'base64'),
-      'utf8',
-    ),
-    '---\ntitle: Three dashes marks the spot\ntags:\n',
-  );
+	assert.equal(
+		ArrayBuffers.toString(
+			ArrayBuffers.from('LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK', 'base64'),
+			'utf8',
+		),
+		'---\ntitle: Three dashes marks the spot\ntags:\n',
+	);
 });
 
 test('base64: newline in base64 -- should get stripped', function () {
-  assert.equal(
-    ArrayBuffers.toString(
-      ArrayBuffers.from(
-        'LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\nICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt',
-        'base64',
-      ),
-      'utf8',
-    ),
-    '---\ntitle: Three dashes marks the spot\ntags:\n  - yaml\n  - front-matter\n  - dashes\nexpaned-',
-  );
+	assert.equal(
+		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 () {
-  assert.equal(
-    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-',
-  );
+	assert.equal(
+		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 () {
-  expect(ArrayBuffers.toString(ArrayBuffers.from('!"#$%&\'()*,.:;<=>?@[\\]^`{|}~', 'base64'), 'utf8')).toBe('');
+	expect(ArrayBuffers.toString(ArrayBuffers.from('!"#$%&\'()*,.:;<=>?@[\\]^`{|}~', 'base64'), 'utf8')).toBe('');
 });
 
 test('base64: high byte', function () {
-  const highByte = ArrayBuffers.from([128]);
-  assert.deepEqual(ArrayBuffers.alloc(1, ArrayBuffers.toString(highByte, 'base64'), 'base64'), highByte);
+	const highByte = ArrayBuffers.from([128]);
+	assert.deepEqual(ArrayBuffers.alloc(1, ArrayBuffers.toString(highByte, 'base64'), 'base64'), highByte);
 });
 
 test('fromBase64', () => {
-  const text = 'aoeu';
-  const buf = ArrayBuffers.from(text, 'utf8', Uint8Array);
-  expect(ArrayBuffers.fromBase64(ArrayBuffers.toBase64(buf))).toEqual(buf);
+	const text = 'aoeu';
+	const buf = ArrayBuffers.from(text, 'utf8', Uint8Array);
+	expect(ArrayBuffers.fromBase64(ArrayBuffers.toBase64(buf))).toEqual(buf);
 });
 
 test('fromHex', () => {
-  const text = 'aoeu';
-  const buf = ArrayBuffers.from(text, 'utf8', Uint8Array);
-  expect(ArrayBuffers.fromHex(ArrayBuffers.toHex(buf))).toEqual(buf);
+	const text = 'aoeu';
+	const buf = ArrayBuffers.from(text, 'utf8', Uint8Array);
+	expect(ArrayBuffers.fromHex(ArrayBuffers.toHex(buf))).toEqual(buf);
 });
 
 test('toHex', () => {
-  const text = 'aoeu';
-  const buf = ArrayBuffers.from(text, 'utf8', Uint8Array);
-  expect(ArrayBuffers.toHex(buf)).toEqual('616f6575');
+	const text = 'aoeu';
+	const buf = ArrayBuffers.from(text, 'utf8', Uint8Array);
+	expect(ArrayBuffers.toHex(buf)).toEqual('616f6575');
 });
 
 test('toBase64', () => {
-  const text = 'aoeu';
-  const buf = ArrayBuffers.from(text, 'utf8', Uint8Array);
-  expect(ArrayBuffers.toBase64(buf)).toEqual('YW9ldQ==');
+	const text = 'aoeu';
+	const buf = ArrayBuffers.from(text, 'utf8', Uint8Array);
+	expect(ArrayBuffers.toBase64(buf)).toEqual('YW9ldQ==');
 });
 
 test('base64: utf8 string', () => {
-  const text = '你好';
-  // latin1 only
-  expect(() => btoa(text)).toThrow('Invalid character');
-  expect(ArrayBuffers.toBase64(text)).toEqual('5L2g5aW9');
+	const text = '你好';
+	// latin1 only
+	expect(() => btoa(text)).toThrow('Invalid character');
+	expect(ArrayBuffers.toBase64(text)).toEqual('5L2g5aW9');
 });