@wener/utils 1.1.13 → 1.1.15

package/src/fetch/dumpRequest.ts

@@ -0,0 +1,51 @@
+export function dumpRequest({
+  url,
+  req = {},
+  log = console.log,
+}: {
+  url: string;
+  req?: RequestInit;
+  log?: (s: string) => void;
+}) {
+  const { method = 'GET' } = req;
+  let out = `-> ${method} ${url}
+${Array.from(new Headers(req.headers).entries())
+  .map(([k, v]) => `${k}: ${v}`)
+  .join('\n')}
+`;
+
+  let done: Promise<string> | undefined;
+  if (req.body) {
+    if (req.body instanceof ReadableStream) {
+      const [a, b] = req.body.tee();
+      req.body = a;
+      const signal = req.signal;
+      done = Promise.resolve().then(async () => {
+        const reader = b.getReader();
+        log(out);
+        while (true) {
+          if (signal?.aborted) {
+            break;
+          }
+
+          let { done, value } = await reader.read();
+          value instanceof Uint8Array && (value = new TextDecoder().decode(value));
+          out += value;
+          log(value);
+          if (!done) {
+            break;
+          }
+        }
+        // maybe for archive
+        out += `\n`;
+        return out;
+      });
+    } else {
+      out += `
+${req.body}
+`;
+    }
+    log(out);
+  }
+  return done || Promise.resolve(out);
+}

package/src/fetch/dumpResponse.ts

@@ -0,0 +1,28 @@
+export async function dumpResponse({
+  res,
+  url,
+  req,
+  log = console.log,
+}: {
+  res: Response;
+  url: string;
+  req: RequestInit;
+  log?: (s: string) => void;
+}) {
+  let out = `<- ${res.status} ${res.statusText} ${req.method} ${url}
+  ${Array.from(res.headers.entries())
+    .map(([k, v]) => `${k}: ${v}`)
+    .join('\n')}
+   `;
+  let contentType = res.headers.get('content-type');
+  // TODO text/event-stream
+  if (contentType?.includes('application/json') || contentType?.includes('text/plain')) {
+    const body = await res.text();
+    out += `\n${body}\n`;
+    res = new Response(body, res);
+  }
+
+  log(out);
+
+  return res;
+}

package/src/fetch/index.ts

@@ -1 +1,5 @@
 export type FetchLike = (url: string | Request, init?: RequestInit) => Promise<Response>;
+export { createFetchWith } from './createFetchWith';
+export { createFetchWithLogging } from './createFetchWithLogging';
+export { dumpRequest } from './dumpRequest';
+export { dumpResponse } from './dumpResponse';

package/src/i18n/createTranslate.test.ts

@@ -1,80 +1,83 @@
-import test from 'ava';
+import { assert, test } from 'vitest';
 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('exports', () => {
+  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');
 });
 
-test('usage', (t) => {
-  const ctx = createTranslate({
+test('usage', () => {
+  let ctx = createTranslate({
     en: { hello: 'Hello, {{name}}!' },
     es: { hello: 'Hola {{name}}!' },
     pt: { foo: 'foo {{name}}~!' },
   });
 
-  t.deepEqual(ctx.dict('en'), { hello: 'Hello, {{name}}!' });
+  assert.deepEqual(ctx.dict('en'), { hello: 'Hello, {{name}}!' });
+
+  assert.equal(ctx.dict('foobar'), undefined);
 
-  t.true(ctx.dict('foobar') === undefined);
+  let foo = ctx.t('hello');
+  assert.equal(foo, '', '~> "" w/o locale');
 
-  const foo = ctx.t('hello');
-  t.is(foo, '', '~> "" w/o locale');
+  assert.equal(ctx.locale('en'), 'en', '>>> ctx.locale()');
 
-  t.is(ctx.locale('en'), 'en', '>>> ctx.locale()');
+  assert.equal(ctx.locale(), 'en');
 
-  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');
+  assert.notEqual(bar, '', '(en) found "hello" key');
+  assert.equal(bar, 'Hello, !', '~> interpolations empty if missing param');
 
-  const baz = ctx.t('hello', { name: 'world' });
-  t.is(baz, 'Hello, world!', '~> interpolations successful');
+  let baz = ctx.t('hello', { name: 'world' });
+  assert.equal(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');
+  let bat = ctx.t('hello', { name: 'world' }, 'es');
+  assert.notEqual(bat, '', '(es) found "hello" key');
+  assert.equal(bat, 'Hola world!', '~> success');
 
-  t.is(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');
 
-  t.is(ctx.dict('pt', { hello: 'Oí {{name}}!' }), undefined, '>>> ctx.dict()');
+  assert.equal(ctx.dict('pt', { hello: 'Oí {{name}}!' }), undefined, '>>> ctx.set()');
 
-  const quz = ctx.t('hello', { name: 'world' }, 'pt');
-  t.not(quz, '', '(pt) found "hello" key');
-  t.is(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');
 
-  const qut = ctx.t('foo', { name: 'bar' }, 'pt');
-  t.not(qut, '', '(pt) found "foo" key');
-  t.is(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');
 
-  t.is(ctx.locale('es'), 'es', '>>> ctx.locale()');
+  assert.equal(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');
+  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');
 
-  const qux = ctx.t('hello', { name: 'default' });
-  t.not(qux, '', '(es) found "hello" key');
-  t.is(qux, 'Hola default!', '~> success');
+  let qux = ctx.t('hello', { name: 'default' });
+  assert.notEqual(qux, '', '(es) found "hello" key');
+  assert.equal(qux, 'Hola default!', '~> success');
 
-  t.is(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');
 
-  t.is(ctx.dict('de', { hello: 'Hallo {{name}}!' }), undefined, '>>> ctx.dict(de)');
+  assert.equal(ctx.dict('de', { hello: 'Hallo {{name}}!' }), undefined, '>>> ctx.set(de)');
 
-  const qar = ctx.t('hello', { name: 'world' }, 'de');
-  t.not(qar, '', '(de) found "hello" key');
-  t.is(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', (t) => {
-  const ctx = createTranslate({
+test('functional', () => {
+  let ctx = createTranslate({
     en: {
-      hello(value: any) {
+      hello(value: string) {
         return `hello ${value || 'stranger'}~!`;
       },
     },
@@ -82,18 +85,18 @@ test('functional', (t) => {
 
   ctx.locale('en');
 
-  const foo = ctx.t('hello');
-  t.is(foo, 'hello stranger~!', '~> called function w/o param');
+  let foo = ctx.t('hello');
+  assert.equal(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)');
+  let bar = ctx.t('hello', 'world' as any);
+  assert.equal(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)');
+  let baz = ctx.t('hello', [1, 2, 3]);
+  assert.equal(baz, 'hello 1,2,3~!', '~> called function w/ param (array)');
 });
 
-test('nested', (t) => {
-  const ctx = createTranslate({
+test('nested', () => {
+  let ctx = createTranslate({
     en: {
       fruits: {
         apple: 'apple',
@@ -111,22 +114,22 @@ test('nested', (t) => {
   });
 
   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 ~> ""');
+  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');
-  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 ~> ""');
+  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', (t) => {
-  const ctx = createTranslate({
+test('arrays', () => {
+  let ctx = createTranslate({
     en: {
       foo: '{{0}} + {{1}} = {{2}}',
       bar: [
@@ -139,32 +142,17 @@ test('arrays', (t) => {
 
   ctx.locale('en');
 
-  t.is(ctx.t('foo', [1, 2, 3]), '1 + 2 = 3', '~> foo');
+  assert.equal(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');
+  assert.equal(ctx.t('bar.0.baz', { colors: ['red', 'blue'] }), 'roses are red, violets are blue', '~> bar.0.baz');
 });
 
-test('invalid value', (t) => {
-  const ctx = createTranslate({
+test('invalid value', () => {
+  let ctx = createTranslate({
     en: {
       foo: ['bar'],
     },
   });
 
-  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');
+  assert.deepEqual(ctx.t('foo', null as never, 'en'), ['bar'] as any);
 });

package/src/index.ts

@@ -72,8 +72,9 @@ export { getFileFromDataTransfer } from './browsers/getFileFromDataTransfer';
 
 // polyfills
 export { getGlobalThis } from './isomorphics/getGlobalThis';
-export { globalThis } from './isomorphics/globalThis';
 export { structuredClone } from './isomorphics/structuredClone';
+// should not export as sideEffect
+// export { globalThis } from './isomorphics/globalThis';
 
 // crypto
 export { randomUUID } from './crypto/randomUUID';
@@ -86,7 +87,8 @@ export { PEM } from './crypto/pem/pem';
 // misc
 export { createRandom } from './maths/random';
 
-export { type FetchLike } from './fetch';
+// network
+export { type FetchLike, createFetchWith, createFetchWithLogging, dumpResponse, dumpRequest } from './fetch';
 
 // bundled
 export { default as ms } from './libs/ms';

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

@@ -1,4 +1,6 @@
-import { expectType } from 'tsd';
+import { expectTypeOf, test } from 'vitest';
 import { ArrayBuffers } from './ArrayBuffers';
 
-expectType<Buffer>(ArrayBuffers.asView(Buffer, new Uint8Array()));
+test('my types work properly', () => {
+  expectTypeOf(ArrayBuffers.asView(Buffer, new Uint8Array())).toMatchTypeOf<Buffer>();
+});

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

@@ -1,23 +1,23 @@
-import test from 'ava';
+import { test, beforeAll, assert, expect } from 'vitest';
 import { ArrayBuffers } from './ArrayBuffers';
 
-test.before((t) => {
-  t.true(ArrayBuffers.isNativeBufferAvailable());
+beforeAll(() => {
+  expect(ArrayBuffers.isNativeBufferAvailable()).toBeTruthy();
   ArrayBuffers.setNativeBufferAllowed(false);
 });
 
-test('base64: ignore whitespace', function (t) {
+test('base64: ignore whitespace', function () {
   const text = '\n   YW9ldQ==  ';
   const buf = ArrayBuffers.from(text, 'base64');
-  t.is(ArrayBuffers.toString(buf), 'aoeu');
+  expect(ArrayBuffers.toString(buf)).toBe('aoeu');
 });
 
-test('base64: strings without padding', function (t) {
-  t.is(ArrayBuffers.toString(ArrayBuffers.from('YW9ldQ', 'base64')), 'aoeu');
+test('base64: strings without padding', function () {
+  expect(ArrayBuffers.toString(ArrayBuffers.from('YW9ldQ', 'base64'))).toBe('aoeu');
 });
 
-test('base64: newline in utf8 -- should not be an issue', function (t) {
-  t.is(
+test('base64: newline in utf8 -- should not be an issue', function () {
+  assert.equal(
     ArrayBuffers.toString(
       ArrayBuffers.from('LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK', 'base64'),
       'utf8',
@@ -26,8 +26,8 @@ test('base64: newline in utf8 -- should not be an issue', function (t) {
   );
 });
 
-test('base64: newline in base64 -- should get stripped', function (t) {
-  t.is(
+test('base64: newline in base64 -- should get stripped', function () {
+  assert.equal(
     ArrayBuffers.toString(
       ArrayBuffers.from(
         'LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\nICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt',
@@ -39,8 +39,8 @@ test('base64: newline in base64 -- should get stripped', function (t) {
   );
 });
 
-test('base64: tab characters in base64 - should get stripped', function (t) {
-  t.is(
+test('base64: tab characters in base64 - should get stripped', function () {
+  assert.equal(
     ArrayBuffers.toString(
       ArrayBuffers.from(
         'LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\t\t\t\tICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt',
@@ -52,11 +52,11 @@ test('base64: tab characters in base64 - should get stripped', function (t) {
   );
 });
 
-test('base64: invalid non-alphanumeric characters -- should be stripped', function (t) {
-  t.is(ArrayBuffers.toString(ArrayBuffers.from('!"#$%&\'()*,.:;<=>?@[\\]^`{|}~', 'base64'), 'utf8'), '');
+test('base64: invalid non-alphanumeric characters -- should be stripped', function () {
+  expect(ArrayBuffers.toString(ArrayBuffers.from('!"#$%&\'()*,.:;<=>?@[\\]^`{|}~', 'base64'), 'utf8')).toBe('');
 });
 
-test('base64: high byte', function (t) {
+test('base64: high byte', function () {
   const highByte = ArrayBuffers.from([128]);
-  t.deepEqual(ArrayBuffers.alloc(1, ArrayBuffers.toString(highByte, 'base64'), 'base64'), highByte);
+  assert.deepEqual(ArrayBuffers.alloc(1, ArrayBuffers.toString(highByte, 'base64'), 'base64'), highByte);
 });

package/src/io/ArrayBuffers.test.ts

@@ -1,23 +1,23 @@
-import test from 'ava';
+import { test, expect } from 'vitest';
 import { ArrayBuffers } from './ArrayBuffers';
 
-test('concat', (t) => {
+test('concat', () => {
   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}`);
+    expect(ArrayBuffers.concat([a, b]), `should concat ${Type}`).toStrictEqual(new Type([...va, ...vb]).buffer);
   };
   check(Uint8Array);
   check(Uint16Array, [0xff, 0xffff]);
   check(Uint32Array, [0xfffffff]);
 });
 
-test('asView for Buffer', (t) => {
+test('asView for Buffer', () => {
   const buf = Buffer.from([1, 2, 3, 4, 5]);
-  t.is(ArrayBuffers.asView(Buffer, buf), buf);
+  expect(ArrayBuffers.asView(Buffer, buf)).toBe(buf);
   const uint8 = ArrayBuffers.asView(Uint8Array, buf);
-  t.is(ArrayBuffers.asView(Buffer, uint8).buffer, buf.buffer);
+  expect(ArrayBuffers.asView(Buffer, uint8).buffer).toBe(buf.buffer);
 
-  t.deepEqual(uint8, buf);
-  t.deepEqual(ArrayBuffers.asView(Buffer, uint8), buf);
+  expect(uint8).toEqual(buf);
+  expect(ArrayBuffers.asView(Buffer, uint8)).toEqual(buf);
 });

package/src/io/ArrayBuffers.ts

@@ -1,4 +1,4 @@
-import { globalThis } from '../isomorphics/globalThis';
+import { getGlobalThis } from '../isomorphics/getGlobalThis';
 import { classOf } from '../langs/classOf';
 import { decodeBase64ToArrayBuffer, encodeArrayBufferToBase64 } from './base64';
 import { isBuffer } from './isBuffer';
@@ -74,7 +74,7 @@ export class ArrayBuffers {
 
   static isNativeBufferAvailable() {
     // eslint-disable-next-line no-return-assign
-    return (this.#isBufferAvailable ??= !(globalThis.Buffer as any)?.isPollyfill?.());
+    return (this.#isBufferAvailable ??= !(getGlobalThis().Buffer as any)?.isPollyfill?.());
   }
 
   static isNativeBufferAllowed() {

package/src/io/Buffer.test.ts

@@ -1,12 +1,12 @@
-import test from 'ava';
+import { test, expect } from 'vitest';
 import { Buffer } from './Buffer';
 import { isBuffer } from './isBuffer';
 
-test('basic', (t) => {
+test('basic', () => {
   {
     const buf = new Buffer(0);
-    t.true(Buffer.isBuffer(buf));
-    t.true(isBuffer(buf));
+    expect(Buffer.isBuffer(buf)).toBeTruthy();
+    expect(isBuffer(buf)).toBeTruthy();
   }
   // const b = new Buffer(10)
   // t.is(b.length,10)

package/src/io/isBuffer.test.ts

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

package/src/io/isTransferable.test.ts

@@ -1,10 +1,11 @@
-import test from 'ava';
 import { Buffer } from 'node:buffer';
+import { expect, test } from 'vitest';
 import { isTransferable } from './isTransferable';
 
-test('isTransferable', (t) => {
-  t.false(isTransferable(0));
-  t.false(isTransferable(Buffer.from('')));
-  t.true(new ArrayBuffer(0) instanceof ArrayBuffer);
-  t.true(isTransferable(new ArrayBuffer(0)));
+test('isTransferable', () => {
+  expect(isTransferable(0)).toBeFalsy();
+  expect(isTransferable(Buffer.from(''))).toBeFalsy();
+
+  expect(new ArrayBuffer(0) instanceof ArrayBuffer).toBeTruthy();
+  expect(isTransferable(new ArrayBuffer(0))).toBeTruthy();
 });

package/src/io/isTransferable.ts

@@ -1,4 +1,6 @@
-import { globalThis } from '../isomorphics/globalThis';
+import { getGlobalThis } from '../isomorphics/getGlobalThis';
+
+const globalThis = getGlobalThis();
 
 /**
  * transferable object pass between workers, can work with structuredClone

package/src/isomorphics/structuredClone.test.ts

@@ -1,14 +1,14 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 import { classOf } from '../langs/classOf';
 import { _clone } from './structuredClone';
 
-test('structuredClone', (t) => {
+test('structuredClone', () => {
   for (const [k, v] of [
     ['', ''],
     [Number(1), 1],
   ]) {
     const c = _clone(k);
-    t.deepEqual(c, v);
-    t.is(classOf(c), classOf(v));
+    expect(c).toEqual(v);
+    expect(classOf(c)).toBe(classOf(v));
   }
 });

package/src/isomorphics/structuredClone.ts

@@ -1,6 +1,8 @@
 /* eslint no-proto:0 */
 import { classOf } from '../langs/classOf';
-import { globalThis } from './globalThis';
+import { getGlobalThis } from './getGlobalThis';
+
+const globalThis = getGlobalThis();
 
 /**
  * Clone an object using structured cloning algorithm

package/src/langs/deepEqual.test.ts

@@ -1,8 +1,8 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 import { deepEqual } from './deepEqual';
 
-test('deep equal', (t) => {
-  t.true(
+test('deep equal', () => {
+  expect(
     deepEqual(
       {
         a: null,
@@ -13,5 +13,5 @@ test('deep equal', (t) => {
         b: Infinity,
       },
     ),
-  );
+  ).toBeTruthy();
 });

package/src/langs/langs.test.ts

@@ -1,7 +1,7 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 import { classOf } from './classOf';
 
-test('classOf', (t) => {
+test('classOf', () => {
   for (const [k, v] of [
     [0, 'Number'],
     ['', 'String'],
@@ -18,6 +18,6 @@ test('classOf', (t) => {
     [new DataView(new ArrayBuffer(0)), 'DataView'],
     [new Int8Array(0), 'Int8Array'],
   ]) {
-    t.is(classOf(k), v as any);
+    expect(classOf(k)).toBe(v);
   }
 });