@jackens/nnn 2024.2.11 → 2024.2.12

package/readme.md

@@ -2,7 +2,7 @@
 
 Jackens’ JavaScript helpers.
 
-<sub>Version: <code class="version">2024.2.11</code></sub>
+<sub>Version: <code class="version">2024.2.12</code></sub>
 
 ## Installation
 
@@ -50,6 +50,8 @@ import { «something» } from './node_modules/@jackens/nnn/nnn.js'
 - `locale`: Language translations helper.
 - `nanolight`: A generic helper for syntax highlighting (see also `nanolightJs`).
 - `nanolightJs`: A helper for highlighting JavaScript.
+- `omit`: A helper that implements TypeScript’s `Omit` utility type.
+- `pick`: A helper that implements TypeScript’s `Pick` utility type.
 - `plUral`: A helper for choosing the correct singular and plural.
 - `pro`: A helper that protects calls to nested properties by a `Proxy` that initializes non-existent values with an empty object.
 - `refsInfo`: A helper that provides information about the given `refs`.
@@ -148,35 +150,35 @@ A helper that checks equality of the given arguments.
 #### Usage Examples
 
 ```js
-console.assert(eq(true, true))
-console.assert(eq(NaN, NaN))
-console.assert(!eq(null, undefined))
-console.assert(eq(42, 42))
-console.assert(eq(42, new Number(42)))
-console.assert(eq(42, Number(42)))
-console.assert(eq(new Number(42), Number(42)))
-console.assert(!eq(42, '42'))
-console.assert(eq('42', '42'))
-console.assert(eq('42', new String('42')))
-console.assert(eq('42', String('42')))
-console.assert(eq(String('42'), new String('42')))
-console.assert(eq(/42/, /42/))
-console.assert(!eq(/42/, /42/g))
-console.assert(eq(new Date(42), new Date(42)))
-console.assert(!eq(new Date(), new Date(42)))
-console.assert(eq({ j: '42', c: 42 }, { c: 42, j: '42' }))
-console.assert(eq([42, '42'], [42, '42']))
-console.assert(eq(new Set(['42', 42]), new Set([42, '42'])))
-console.assert(!eq(new Set(['42', 42]), new Set([42])))
-console.assert(!eq(new Set([42, undefined]), new Set([42])))
-console.assert(eq(
+expect(eq(true, true)).toBe(true)
+expect(eq(NaN, NaN)).toBe(true)
+expect(eq(null, undefined)).toBe(false)
+expect(eq(42, 42)).toBe(true)
+expect(eq(42, new Number(42))).toBe(true)
+expect(eq(42, Number(42))).toBe(true)
+expect(eq(new Number(42), Number(42))).toBe(true)
+expect(eq(42, '42')).toBe(false)
+expect(eq('42', '42')).toBe(true)
+expect(eq('42', new String('42'))).toBe(true)
+expect(eq('42', String('42'))).toBe(true)
+expect(eq(String('42'), new String('42'))).toBe(true)
+expect(eq(/42/, /42/)).toBe(true)
+expect(eq(/42/, /42/g)).toBe(false)
+expect(eq(new Date(42), new Date(42))).toBe(true)
+expect(eq(new Date(), new Date(42))).toBe(false)
+expect(eq({ j: '42', c: 42 }, { c: 42, j: '42' })).toBe(true)
+expect(eq([42, '42'], [42, '42'])).toBe(true)
+expect(eq(new Set(['42', 42]), new Set([42, '42']))).toBe(true)
+expect(eq(new Set(['42', 42]), new Set([42]))).toBe(false)
+expect(eq(new Set([42, undefined]), new Set([42]))).toBe(false)
+expect(eq(
   new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]),
   new Map([[{ c: 42 }, { C: '42' }], [{ j: 42 }, { J: '42' }]])
-))
-console.assert(!eq(
+)).toBe(true)
+expect(eq(
   new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]),
   new Map([[{ j: '42' }, { J: 42 }], [{ c: '42' }, { C: 42 }]])
-))
+)).toBe(false)
 ```
 
 ### escape
@@ -211,7 +213,7 @@ const expected = `
   FROM table_name
   WHERE column_name IN (b'1', NULL, NULL, 42, '42', '4''2', NULL, '1980-03-31 04:30:00')`
 
-console.assert(actual === expected)
+expect(actual).toEqual(expected)
 ```
 
 ### escapeValues
@@ -237,7 +239,7 @@ const p = h('p', 'Pchnąć w tę łódź jeża lub ośm skrzyń fig (zob. https:
 
 fixTypography(p)
 
-console.assert(p.innerHTML ===
+expect(p.innerHTML).toEqual(
   'Pchnąć <span style="white-space:nowrap">w </span>tę łódź jeża lub ośm skrzyń fig ' +
   '(zob. https://\u200Bpl.\u200Bwikipedia.\u200Borg/\u200Bwiki/\u200BPangram).')
 ```
@@ -269,67 +271,67 @@ A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style help
 ```js
 const b = h('b')
 
-console.assert(b.outerHTML === '<b></b>')
+expect(b.outerHTML).toEqual('<b></b>')
 
 const i = h('i', 'text')
 
 h(b, i)
 
-console.assert(i.outerHTML === '<i>text</i>')
-console.assert(b.outerHTML === '<b><i>text</i></b>')
+expect(i.outerHTML).toEqual('<i>text</i>')
+expect(b.outerHTML).toEqual('<b><i>text</i></b>')
 
 h(i, { $className: 'some class' })
 
-console.assert(i.outerHTML === '<i class="some class">text</i>')
-console.assert(b.outerHTML === '<b><i class="some class">text</i></b>')
+expect(i.outerHTML).toEqual('<i class="some class">text</i>')
+expect(b.outerHTML).toEqual('<b><i class="some class">text</i></b>')
 ```
 
 ```js
-console.assert(h('span', 'text').outerHTML === '<span>text</span>')
-console.assert(h('span', { $innerText: 'text' }).outerHTML === '<span>text</span>')
+expect(h('span', 'text').outerHTML).toEqual('<span>text</span>')
+expect(h('span', { $innerText: 'text' }).outerHTML).toEqual('<span>text</span>')
 ```
 
 ```js
-console.assert(h('div', { style: 'margin:0;padding:0' }).outerHTML ===
-  '<div style="margin:0;padding:0"></div>')
-console.assert(h('div', { $style: 'margin:0;padding:0' }).outerHTML ===
-  '<div style="margin: 0px; padding: 0px;"></div>')
-console.assert(h('div', { $style: { margin: 0, padding: 0 } }).outerHTML ===
-  '<div style="margin: 0px; padding: 0px;"></div>')
+expect(h('div', { style: 'margin:0;padding:0' }).outerHTML)
+  .toEqual('<div style="margin:0;padding:0"></div>')
+expect(h('div', { $style: 'margin:0;padding:0' }).outerHTML)
+  .toEqual('<div style="margin: 0px; padding: 0px;"></div>')
+expect(h('div', { $style: { margin: 0, padding: 0 } }).outerHTML)
+  .toEqual('<div style="margin: 0px; padding: 0px;"></div>')
 ```
 
 ```js
 const input1 = h('input', { value: 42 })
 const input2 = h('input', { $value: '42' })
 
-console.assert(input1.value === '42')
-console.assert(input2.value === '42')
+expect(input1.value).toEqual('42')
+expect(input2.value).toEqual('42')
 
-console.assert(input1.outerHTML === '<input value="42">')
-console.assert(input2.outerHTML === '<input>')
+expect(input1.outerHTML).toEqual('<input value="42">')
+expect(input2.outerHTML).toEqual('<input>')
 
 const checkbox1 = h('input', { type: 'checkbox', checked: true })
 const checkbox2 = h('input', { type: 'checkbox', $checked: true })
 
-console.assert(checkbox1.checked === true)
-console.assert(checkbox2.checked === true)
+expect(checkbox1.checked).toBe(true)
+expect(checkbox2.checked).toBe(true)
 
-console.assert(checkbox1.outerHTML === '<input type="checkbox" checked="">')
-console.assert(checkbox2.outerHTML === '<input type="checkbox">')
+expect(checkbox1.outerHTML).toEqual('<input type="checkbox" checked="">')
+expect(checkbox2.outerHTML).toEqual('<input type="checkbox">')
 ```
 
 ```js
 const div = h('div')
 
-console.assert(div.key === undefined)
+expect(div.key).toBeUndefined()
 
 h(div, { $key: { one: 1 } })
 
-console.assert(eq(div.key, { one: 1 }))
+expect(div.key).toEqual({ one: 1 })
 
 h(div, { $key: { two: 2 } })
 
-console.assert(eq(div.key, { one: 1, two: 2 }))
+expect(div.key).toEqual({ one: 1, two: 2 })
 ```
 
 ### has
@@ -345,30 +347,30 @@ A replacement for the `in` operator (not to be confused with the `for-in` loop)
 ```js
 const obj = { key: 'K', null: 'N' }
 
-console.assert('key' in obj)
-console.assert(has('key', obj))
+expect('key' in obj).toBe(true)
+expect(has('key', obj)).toBe(true)
 
-console.assert('null' in obj)
-console.assert(has('null', obj))
+expect('null' in obj).toBe(true)
+expect(has('null', obj)).toBe(true)
 
-console.assert(null in obj)
-console.assert(!has(null, obj))
+expect(null in obj).toBe(true)
+expect(has(null, obj)).toBe(false)
 
-console.assert('toString' in obj)
-console.assert(!has('toString', obj))
+expect('toString' in obj).toBe(true)
+expect(has('toString', obj)).toBe(false)
 ```
 
 ```js
 let typeError
 
 try {
-  console.assert('key' in null)
+  'key' in null
 } catch (error) {
   typeError = error
 }
 
-console.assert(typeError instanceof TypeError) // Cannot use 'in' operator to search for 'key' in null
-console.assert(!has('key', null))
+expect(typeError instanceof TypeError) // Cannot use 'in' operator to search for 'key' in null
+expect(has('key', null)).toBe(false)
 ```
 
 ### is
@@ -390,23 +392,23 @@ A helper that checks if the given argument is of a certain type.
 #### Usage Examples
 
 ```js
-console.assert(is(Number, 42))
-console.assert(is(Number, Number(42)))
-console.assert(is(Number, new Number(42)))
-console.assert(is(Number, NaN))
-console.assert(is(String, '42'))
-console.assert(is(String, String('42')))
-console.assert(is(String, new String('42')))
-console.assert(is(Symbol, Symbol('42')))
-console.assert(is(Symbol, Object(Symbol('42'))))
-console.assert(is(undefined, undefined))
-console.assert(is(undefined, null))
-console.assert(is(Object, {}))
-console.assert(is(Array, []))
-console.assert(is(RegExp, /42/))
-console.assert(is(Date, new Date(42)))
-console.assert(is(Set, new Set(['42', 42])))
-console.assert(is(Map, new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]])))
+expect(is(Number, 42)).toBe(true)
+expect(is(Number, Number(42))).toBe(true)
+expect(is(Number, new Number(42))).toBe(true)
+expect(is(Number, NaN)).toBe(true)
+expect(is(String, '42')).toBe(true)
+expect(is(String, String('42'))).toBe(true)
+expect(is(String, new String('42'))).toBe(true)
+expect(is(Symbol, Symbol('42'))).toBe(true)
+expect(is(Symbol, Object(Symbol('42')))).toBe(true)
+expect(is(undefined, undefined)).toBe(true)
+expect(is(undefined, null)).toBe(true)
+expect(is(Object, {})).toBe(true)
+expect(is(Array, [])).toBe(true)
+expect(is(RegExp, /42/)).toBe(true)
+expect(is(Date, new Date(42))).toBe(true)
+expect(is(Set, new Set(['42', 42]))).toBe(true)
+expect(is(Map, new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]))).toBe(true)
 ```
 
 ```js
@@ -414,21 +416,21 @@ const iz = (/** @type {any} */ type, /** @type {any} */ arg) => ({}).toString.ca
 
 class FooBar { }
 
-console.assert(is(FooBar, new FooBar()))
-console.assert(!iz(FooBar, new FooBar()))
+expect(is(FooBar, new FooBar())).toBe(true)
+expect(iz(FooBar, new FooBar())).toBe(false)
 
-console.assert(!is(Object, new FooBar()))
-console.assert(iz(Object, new FooBar()))
+expect(is(Object, new FooBar())).toBe(false)
+expect(iz(Object, new FooBar())).toBe(true)
 
 const fakeFooBar = {}
 
 fakeFooBar[Symbol.toStringTag] = FooBar.name
 
-console.assert(!is(FooBar, fakeFooBar))
-console.assert(iz(FooBar, fakeFooBar))
+expect(is(FooBar, fakeFooBar)).toBe(false)
+expect(iz(FooBar, fakeFooBar)).toBe(true)
 
-console.assert(is(Object, fakeFooBar))
-console.assert(!iz(Object, fakeFooBar))
+expect(is(Object, fakeFooBar)).toBe(true)
+expect(iz(Object, fakeFooBar)).toBe(false)
 ```
 
 ### jcss
@@ -472,7 +474,7 @@ a{
   padding:1
 }`.replace(/\n\s*/g, '')
 
-console.assert(actual === expected)
+expect(actual).toEqual(expected)
 ```
 
 ```js
@@ -500,7 +502,7 @@ a.b{
   padding:1
 }`.replace(/\n\s*/g, '')
 
-console.assert(actual === expected)
+expect(actual).toEqual(expected)
 ```
 
 ```js
@@ -575,7 +577,7 @@ div.c2{
   }
 }`.replace(/\n\s*/g, '')
 
-console.assert(actual === expected)
+expect(actual).toEqual(expected)
 ```
 
 ```js
@@ -598,7 +600,7 @@ a.b.d,a.c.d{
   margin:2
 }`.replace(/\n\s*/g, '')
 
-console.assert(actual === expected)
+expect(actual).toEqual(expected)
 ```
 
 ```js
@@ -619,7 +621,7 @@ const expected = `
   margin:2
 }`.replace(/\n\s*/g, '')
 
-console.assert(actual === expected)
+expect(actual).toEqual(expected)
 ```
 
 ```js
@@ -640,7 +642,7 @@ const expected = `
   margin:2
 }`.replace(/\n\s*/g, '')
 
-console.assert(actual === expected)
+expect(actual).toEqual(expected)
 ```
 
 ### jsOnParse
@@ -705,7 +707,7 @@ const expected = [
   }
 ]
 
-console.assert(eq(actual, expected))
+expect(actual).toEqual(expected)
 ```
 
 ### locale
@@ -724,18 +726,18 @@ const _ = locale({
   button: { Login: 'Zaloguj' }
 }, 'default')
 
-console.assert(_('Login') === 'Login')
-console.assert(_('Password') === 'Hasło')
+expect(_('Login')).toEqual('Login')
+expect(_('Password')).toEqual('Hasło')
 
-console.assert(_('Undefined text') === 'Undefined text')
+expect(_('Undefined text')).toEqual('Undefined text')
 
-console.assert(_('Login', 'button') === 'Zaloguj')
+expect(_('Login', 'button')).toEqual('Zaloguj')
 
-console.assert(_('Password', 'undefined_version') === 'Hasło')
-console.assert(_('Undefined text', 'undefined_version') === 'Undefined text')
+expect(_('Password', 'undefined_version')).toEqual('Hasło')
+expect(_('Undefined text', 'undefined_version')).toEqual('Undefined text')
 
-console.assert(_('toString') === 'toString')
-console.assert(_('toString', 'undefined_version') === 'toString')
+expect(_('toString')).toEqual('toString')
+expect(_('toString', 'undefined_version')).toEqual('toString')
 ```
 
 ### nanolight
@@ -759,10 +761,42 @@ A helper for highlighting JavaScript.
 ```js
 const codeJs = 'const answerToLifeTheUniverseAndEverything = 42'
 
-console.assert(h('pre', ['code', ...nanolightJs(codeJs)]).outerHTML ===
+expect(h('pre', ['code', ...nanolightJs(codeJs)]).outerHTML).toEqual(
   '<pre><code><span class="keyword">const</span> <span class="literal">answerToLifeTheUniverseAndEverything</span> <span class="operator">=</span> <span class="number">42</span></code></pre>')
 ```
 
+### omit
+
+```ts
+export const omit: <T extends Partial<Record<PropertyKey, any>>, K extends (keyof T)[]>(obj: T, keys: K) => Omit<T, K[number]>;
+```
+
+A helper that implements TypeScript’s `Omit` utility type.
+
+#### Usage Examples
+
+```js
+const obj = { a: 42, b: '42', c: 17 }
+
+expect(omit(obj, ['c'])).toEqual({ a: 42, b: '42' })
+```
+
+### pick
+
+```ts
+export const pick: <T extends Partial<Record<PropertyKey, any>>, K extends (keyof T)[]>(obj: T, keys: K) => Pick<T, K[number]>;
+```
+
+A helper that implements TypeScript’s `Pick` utility type.
+
+#### Usage Examples
+
+```js
+const obj = { a: 42, b: '42', c: 17 }
+
+expect(pick(obj, ['a', 'b'])).toEqual({ a: 42, b: '42' })
+```
+
 ### plUral
 
 ```ts
@@ -776,17 +810,17 @@ A helper for choosing the correct singular and plural.
 ```js
 const auto = plUral.bind(null, 'auto', 'auta', 'aut')
 
-console.assert(auto(0) === 'aut')
-console.assert(auto(1) === 'auto')
-console.assert(auto(17) === 'aut')
-console.assert(auto(42) === 'auta')
+expect(auto(0)).toEqual('aut')
+expect(auto(1)).toEqual('auto')
+expect(auto(17)).toEqual('aut')
+expect(auto(42)).toEqual('auta')
 
 const car = plUral.bind(null, 'car', 'cars', 'cars')
 
-console.assert(car(0) === 'cars')
-console.assert(car(1) === 'car')
-console.assert(car(17) === 'cars')
-console.assert(car(42) === 'cars')
+expect(car(0)).toEqual('cars')
+expect(car(1)).toEqual('car')
+expect(car(17)).toEqual('cars')
+expect(car(42)).toEqual('cars')
 ```
 
 ### pro
@@ -804,27 +838,27 @@ const ref = {}
 
 pro(ref).one.two[3][4] = 1234
 
-console.assert(eq(ref, { one: { two: { 3: { 4: 1234 } } } }))
+expect(ref).toEqual({ one: { two: { 3: { 4: 1234 } } } })
 
 pro(ref).one.two.tree = 123
 
-console.assert(eq(ref, { one: { two: { 3: { 4: 1234 }, tree: 123 } } }))
+expect(ref).toEqual({ one: { two: { 3: { 4: 1234 }, tree: 123 } } })
 
 pro(ref).one.two = undefined
 
-console.assert(eq(ref, { one: { two: undefined } }))
+expect(ref).toEqual({ one: { two: undefined } })
 
 delete pro(ref).one.two
 
-console.assert(eq(ref, { one: {} }))
+expect(ref).toEqual({ one: {} })
 
 pro(ref).one.two.three.four
 
-console.assert(eq(ref, { one: { two: { three: { four: {} } } } }))
+expect(ref).toEqual({ one: { two: { three: { four: {} } } } })
 
 pro(ref).one.two.three.four = 1234
 
-console.assert(eq(ref, { one: { two: { three: { four: 1234 } } } }))
+expect(ref).toEqual({ one: { two: { three: { four: 1234 } } } })
 ```
 
 ### refsInfo
@@ -842,8 +876,8 @@ It returns an array of triples: `[«name», «prototype-name», «array-of-own-p
 ```js
 const info = refsInfo(Array, Function)
 
-console.assert(info.find(([name]) => name === 'Array')?.[2]?.includes?.('length'))
-console.assert(info.find(([name]) => name === 'Function')?.[2]?.includes?.('length'))
+expect(info.find(([name]) => name === 'Array')?.[2]?.includes('length')).toBe(true)
+expect(info.find(([name]) => name === 'Function')?.[2]?.includes('length')).toBe(true)
 ```
 
 ```js
@@ -912,23 +946,23 @@ A helper that generates a UUID v1 identifier (with a creation timestamp).
 for (let i = 1; i <= 22136; ++i) {
   const uuid = uuid1()
 
-  i === 1 && console.assert(uuid.split('-')[3] === '8001')
-  i === 4095 && console.assert(uuid.split('-')[3] === '8fff')
-  i === 4096 && console.assert(uuid.split('-')[3] === '9000')
-  i === 9029 && console.assert(uuid.split('-')[3] === 'a345')
-  i === 13398 && console.assert(uuid.split('-')[3] === 'b456')
-  i === 16384 && console.assert(uuid.split('-')[3] === '8000')
-  i === 17767 && console.assert(uuid.split('-')[3] === '8567')
+  i === 1 && expect(uuid.split('-')[3]).toEqual('8001')
+  i === 4095 && expect(uuid.split('-')[3]).toEqual('8fff')
+  i === 4096 && expect(uuid.split('-')[3]).toEqual('9000')
+  i === 9029 && expect(uuid.split('-')[3]).toEqual('a345')
+  i === 13398 && expect(uuid.split('-')[3]).toEqual('b456')
+  i === 16384 && expect(uuid.split('-')[3]).toEqual('8000')
+  i === 17767 && expect(uuid.split('-')[3]).toEqual('8567')
 }
 ```
 
 ```js
-console.assert(uuid1({ node: '000123456789abc' }).split('-')[4] === '123456789abc')
-console.assert(uuid1({ node: '123456789' }).split('-')[4] === '000123456789')
+expect(uuid1({ node: '000123456789abc' }).split('-')[4]).toEqual('123456789abc')
+expect(uuid1({ node: '123456789' }).split('-')[4]).toEqual('000123456789')
 ```
 
 ```js
-console.assert(uuid1({ date: new Date(323325000000) }).startsWith('c1399400-9a71-11bd'))
+expect(uuid1({ date: new Date(323325000000) })).toStartWith('c1399400-9a71-11bd')
 ```
 
 ## License

package/refsInfo.d.ts

@@ -6,6 +6,6 @@
 export function refsInfo(...refs: any[]): [string, string, string[]][];
 
 export const tests: {
-    refsInfo: () => void;
-    'refsInfo: browserFingerprint': () => void;
+    refsInfo: (expect: import('bun:test').Expect) => void;
+    'refsInfo: browserFingerprint': (expect: import('bun:test').Expect) => void;
 };

package/refsInfo.js

@@ -23,14 +23,14 @@ export const refsInfo = (/** @type {any[]} */ ...refs) => {
 }
 
 export const tests = {
-  refsInfo: () => {
+  refsInfo: (/** @type {import('bun:test').Expect} */ expect) => {
     const info = refsInfo(Array, Function)
 
-    console.assert(info.find(([name]) => name === 'Array')?.[2]?.includes?.('length'))
-    console.assert(info.find(([name]) => name === 'Function')?.[2]?.includes?.('length'))
+    expect(info.find(([name]) => name === 'Array')?.[2]?.includes('length')).toBe(true)
+    expect(info.find(([name]) => name === 'Function')?.[2]?.includes('length')).toBe(true)
   },
 
-  'refsInfo: browserFingerprint': () => {
+  'refsInfo: browserFingerprint': (/** @type {import('bun:test').Expect} */ expect) => {
     const browserFingerprint = () => {
       // @ts-ignore
       const refs = Object.getOwnPropertyNames(window).map(name => window[name])

package/uuid1.d.ts

@@ -1,7 +1,7 @@
 export const tests: {
-    uuid1: () => void;
-    'uuid1: node': () => void;
-    'uuid1: date': () => void;
+    uuid1: (expect: import('bun:test').Expect) => void;
+    'uuid1: node': (expect: import('bun:test').Expect) => void;
+    'uuid1: date': (expect: import('bun:test').Expect) => void;
 };
 
 /**

package/uuid1.js

@@ -29,26 +29,26 @@ export const uuid1 = ({
 }
 
 export const tests = {
-  uuid1: () => {
+  uuid1: (/** @type {import('bun:test').Expect} */ expect) => {
     for (let i = 1; i <= 22136; ++i) {
       const uuid = uuid1()
 
-      i === 1 && console.assert(uuid.split('-')[3] === '8001')
-      i === 4095 && console.assert(uuid.split('-')[3] === '8fff')
-      i === 4096 && console.assert(uuid.split('-')[3] === '9000')
-      i === 9029 && console.assert(uuid.split('-')[3] === 'a345')
-      i === 13398 && console.assert(uuid.split('-')[3] === 'b456')
-      i === 16384 && console.assert(uuid.split('-')[3] === '8000')
-      i === 17767 && console.assert(uuid.split('-')[3] === '8567')
+      i === 1 && expect(uuid.split('-')[3]).toEqual('8001')
+      i === 4095 && expect(uuid.split('-')[3]).toEqual('8fff')
+      i === 4096 && expect(uuid.split('-')[3]).toEqual('9000')
+      i === 9029 && expect(uuid.split('-')[3]).toEqual('a345')
+      i === 13398 && expect(uuid.split('-')[3]).toEqual('b456')
+      i === 16384 && expect(uuid.split('-')[3]).toEqual('8000')
+      i === 17767 && expect(uuid.split('-')[3]).toEqual('8567')
     }
   },
 
-  'uuid1: node': () => {
-    console.assert(uuid1({ node: '000123456789abc' }).split('-')[4] === '123456789abc')
-    console.assert(uuid1({ node: '123456789' }).split('-')[4] === '000123456789')
+  'uuid1: node': (/** @type {import('bun:test').Expect} */ expect) => {
+    expect(uuid1({ node: '000123456789abc' }).split('-')[4]).toEqual('123456789abc')
+    expect(uuid1({ node: '123456789' }).split('-')[4]).toEqual('000123456789')
   },
 
-  'uuid1: date': () => {
-    console.assert(uuid1({ date: new Date(323325000000) }).startsWith('c1399400-9a71-11bd'))
+  'uuid1: date': (/** @type {import('bun:test').Expect} */ expect) => {
+    expect(uuid1({ date: new Date(323325000000) })).toStartWith('c1399400-9a71-11bd')
   }
 }

package/tests.d.ts

@@ -1,30 +0,0 @@
-export const tests: {
-    uuid1: () => void;
-    'uuid1: node': () => void;
-    'uuid1: date': () => void;
-    refsInfo: () => void;
-    'refsInfo: browserFingerprint': () => void;
-    pro: () => void;
-    plUral: () => void;
-    nanolightJs: () => void;
-    locale: () => void;
-    jsOnParse: () => void;
-    'jcss: #1': () => void;
-    'jcss: #2': () => void;
-    'jcss: #3': () => void;
-    'jcss: #4': () => void;
-    'jcss: #5': () => void;
-    'jcss: #6': () => void;
-    is: () => void;
-    'is: toString.call': () => void;
-    has: () => void;
-    'has: null': () => void;
-    h: () => void;
-    'h: innerText vs items': () => void;
-    'h: style': () => void;
-    'h: attributes vs properties': () => void;
-    'h: nested properties': () => void;
-    fixTypography: () => void;
-    escape: () => void;
-    eq: () => void;
-};