@jackens/nnn 2024.2.17 → 2024.2.19

package/readme.md

@@ -2,7 +2,7 @@
 
 Jackens’ JavaScript helpers.
 
-<sub>Version: <code class="version">2024.2.17</code></sub>
+<sub>Version: <code class="version">2024.2.19</code></sub>
 
 ## Installation
 
@@ -103,35 +103,35 @@ The type of arguments of the `jcss` helper.
 ### chartable
 
 ```ts
-export function chartable({ bottom, gapX, gapY, headerColumn, left, maxY, reverse, right, rotate, table, top }: {
-    bottom?: number;
-    gapX?: number;
-    gapY?: number;
-    headerColumn?: boolean;
-    left?: number;
-    maxY?: number;
-    reverse?: boolean;
-    right?: number;
-    rotate?: boolean;
+export function chartable({ table, headerColumn, xGap, xLabelsPx, xLabelsRotate, xReverse, yGap, yLabelsLeftPx, yLabelsRightPx, yMax, zLabelsPx }: {
     table: HTMLTableElement;
-    top?: number;
-}): Node;
+    headerColumn?: boolean;
+    xGap?: number;
+    xLabelsPx?: number;
+    xLabelsRotate?: boolean;
+    xReverse?: boolean;
+    yGap?: number;
+    yLabelsLeftPx?: number;
+    yLabelsRightPx?: number;
+    yMax?: number;
+    zLabelsPx?: number;
+}): SVGSVGElement;
 ```
 
 A helper for creating a chart based on a table (conf. <https://jackens.github.io/nnn/chartable/>).
 
 Options:
-- `bottom`: bottom padding (for X axis labels)
-- `gapX`: X axis spacing
-- `gapY`: Y axis spacing
-- `headerColumn`: flag indicating that `table` has a header column (with X axis labels)
-- `left`: left padding
-- `maxY`: number of Y axis lines
-- `reverse`: flag to reverse all data series
-- `right`: right padding (for data series labels)
-- `rotate`: flag to rotate X axis labels
 - `table`: `HTMLTableElement` to extract data, data series labels and X axis labels
-- `top`: top padding
+- `headerColumn`: flag indicating that `table` has a header column with X axis labels
+- `xGap`: X axis spacing
+- `xLabelsPx`:
+- `xLabelsRotate`: flag to rotate X axis labels
+- `xReverse`: flag to reverse all data series
+- `yGap`: Y axis spacing
+- `yLabelsLeftPx`:
+- `yLabelsRightPx`:
+- `yMax`: number of Y axis lines
+- `zLabelsPx`:
 
 ### eq
 
@@ -144,35 +144,35 @@ A helper that checks equality of the given arguments.
 #### Usage Examples
 
 ```js
-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(true, true)).to.be.true
+expect(eq(NaN, NaN)).to.be.true
+expect(eq(null, undefined)).to.be.false
+expect(eq(42, 42)).to.be.true
+expect(eq(42, new Number(42))).to.be.true
+expect(eq(42, Number(42))).to.be.true
+expect(eq(new Number(42), Number(42))).to.be.true
+expect(eq(42, '42')).to.be.false
+expect(eq('42', '42')).to.be.true
+expect(eq('42', new String('42'))).to.be.true
+expect(eq('42', String('42'))).to.be.true
+expect(eq(String('42'), new String('42'))).to.be.true
+expect(eq(/42/, /42/)).to.be.true
+expect(eq(/42/, /42/g)).to.be.false
+expect(eq(new Date(42), new Date(42))).to.be.true
+expect(eq(new Date(), new Date(42))).to.be.false
+expect(eq({ j: '42', c: 42 }, { c: 42, j: '42' })).to.be.true
+expect(eq([42, '42'], [42, '42'])).to.be.true
+expect(eq(new Set(['42', 42]), new Set([42, '42']))).to.be.true
+expect(eq(new Set(['42', 42]), new Set([42]))).to.be.false
+expect(eq(new Set([42, undefined]), new Set([42]))).to.be.false
 expect(eq(
   new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]),
   new Map([[{ c: 42 }, { C: '42' }], [{ j: 42 }, { J: '42' }]])
-)).toBe(true)
+)).to.be.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)
+)).to.be.false
 ```
 
 ### escape
@@ -207,7 +207,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')`
 
-expect(actual).toEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ### escapeValues
@@ -233,7 +233,7 @@ const p = h('p', 'Pchnąć w tę łódź jeża lub ośm skrzyń fig (zob. https:
 
 fixTypography(p)
 
-expect(p.innerHTML).toEqual(
+expect(p.innerHTML).to.deep.equal(
   'Pchnąć <span style="white-space:nowrap">w </span>tę łódź jeża lub ośm skrzyń fig ' +
   '(zob. https://\u200Bpl.\u200Bwikipedia.\u200Borg/\u200Bwiki/\u200BPangram).')
 ```
@@ -265,67 +265,67 @@ A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style help
 ```js
 const b = h('b')
 
-expect(b.outerHTML).toEqual('<b></b>')
+expect(b.outerHTML).to.deep.equal('<b></b>')
 
 const i = h('i', 'text')
 
 h(b, i)
 
-expect(i.outerHTML).toEqual('<i>text</i>')
-expect(b.outerHTML).toEqual('<b><i>text</i></b>')
+expect(i.outerHTML).to.deep.equal('<i>text</i>')
+expect(b.outerHTML).to.deep.equal('<b><i>text</i></b>')
 
 h(i, { $className: 'some class' })
 
-expect(i.outerHTML).toEqual('<i class="some class">text</i>')
-expect(b.outerHTML).toEqual('<b><i class="some class">text</i></b>')
+expect(i.outerHTML).to.deep.equal('<i class="some class">text</i>')
+expect(b.outerHTML).to.deep.equal('<b><i class="some class">text</i></b>')
 ```
 
 ```js
-expect(h('span', 'text').outerHTML).toEqual('<span>text</span>')
-expect(h('span', { $innerText: 'text' }).outerHTML).toEqual('<span>text</span>')
+expect(h('span', 'text').outerHTML).to.deep.equal('<span>text</span>')
+expect(h('span', { $innerText: 'text' }).outerHTML).to.deep.equal('<span>text</span>')
 ```
 
 ```js
 expect(h('div', { style: 'margin:0;padding:0' }).outerHTML)
-  .toEqual('<div style="margin:0;padding:0"></div>')
+  .to.deep.equal('<div style="margin:0;padding:0"></div>')
 expect(h('div', { $style: 'margin:0;padding:0' }).outerHTML)
-  .toEqual('<div style="margin: 0px; padding: 0px;"></div>')
+  .to.deep.equal('<div style="margin: 0px; padding: 0px;"></div>')
 expect(h('div', { $style: { margin: 0, padding: 0 } }).outerHTML)
-  .toEqual('<div style="margin: 0px; padding: 0px;"></div>')
+  .to.deep.equal('<div style="margin: 0px; padding: 0px;"></div>')
 ```
 
 ```js
 const input1 = h('input', { value: 42 })
 const input2 = h('input', { $value: '42' })
 
-expect(input1.value).toEqual('42')
-expect(input2.value).toEqual('42')
+expect(input1.value).to.deep.equal('42')
+expect(input2.value).to.deep.equal('42')
 
-expect(input1.outerHTML).toEqual('<input value="42">')
-expect(input2.outerHTML).toEqual('<input>')
+expect(input1.outerHTML).to.deep.equal('<input value="42">')
+expect(input2.outerHTML).to.deep.equal('<input>')
 
 const checkbox1 = h('input', { type: 'checkbox', checked: true })
 const checkbox2 = h('input', { type: 'checkbox', $checked: true })
 
-expect(checkbox1.checked).toBe(true)
-expect(checkbox2.checked).toBe(true)
+expect(checkbox1.checked).to.be.true
+expect(checkbox2.checked).to.be.true
 
-expect(checkbox1.outerHTML).toEqual('<input type="checkbox" checked="">')
-expect(checkbox2.outerHTML).toEqual('<input type="checkbox">')
+expect(checkbox1.outerHTML).to.deep.equal('<input type="checkbox" checked="">')
+expect(checkbox2.outerHTML).to.deep.equal('<input type="checkbox">')
 ```
 
 ```js
 const div = h('div')
 
-expect(div.key).toBeUndefined()
+expect(div.key).to.be.undefined
 
 h(div, { $key: { one: 1 } })
 
-expect(div.key).toEqual({ one: 1 })
+expect(div.key).to.deep.equal({ one: 1 })
 
 h(div, { $key: { two: 2 } })
 
-expect(div.key).toEqual({ one: 1, two: 2 })
+expect(div.key).to.deep.equal({ one: 1, two: 2 })
 ```
 
 ### has
@@ -341,17 +341,17 @@ A replacement for the `in` operator (not to be confused with the `for-in` loop)
 ```js
 const obj = { key: 'K', null: 'N' }
 
-expect('key' in obj).toBe(true)
-expect(has('key', obj)).toBe(true)
+expect('key' in obj).to.be.true
+expect(has('key', obj)).to.be.true
 
-expect('null' in obj).toBe(true)
-expect(has('null', obj)).toBe(true)
+expect('null' in obj).to.be.true
+expect(has('null', obj)).to.be.true
 
-expect(null in obj).toBe(true)
-expect(has(null, obj)).toBe(false)
+expect(null in obj).to.be.true
+expect(has(null, obj)).to.be.false
 
-expect('toString' in obj).toBe(true)
-expect(has('toString', obj)).toBe(false)
+expect('toString' in obj).to.be.true
+expect(has('toString', obj)).to.be.false
 ```
 
 ```js
@@ -364,7 +364,7 @@ try {
 }
 
 expect(typeError instanceof TypeError) // Cannot use 'in' operator to search for 'key' in null
-expect(has('key', null)).toBe(false)
+expect(has('key', null)).to.be.false
 ```
 
 ### is
@@ -386,23 +386,23 @@ A helper that checks if the given argument is of a certain type.
 #### Usage Examples
 
 ```js
-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)
+expect(is(Number, 42)).to.be.true
+expect(is(Number, Number(42))).to.be.true
+expect(is(Number, new Number(42))).to.be.true
+expect(is(Number, NaN)).to.be.true
+expect(is(String, '42')).to.be.true
+expect(is(String, String('42'))).to.be.true
+expect(is(String, new String('42'))).to.be.true
+expect(is(Symbol, Symbol('42'))).to.be.true
+expect(is(Symbol, Object(Symbol('42')))).to.be.true
+expect(is(undefined, undefined)).to.be.true
+expect(is(undefined, null)).to.be.true
+expect(is(Object, {})).to.be.true
+expect(is(Array, [])).to.be.true
+expect(is(RegExp, /42/)).to.be.true
+expect(is(Date, new Date(42))).to.be.true
+expect(is(Set, new Set(['42', 42]))).to.be.true
+expect(is(Map, new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]))).to.be.true
 ```
 
 ```js
@@ -410,21 +410,21 @@ const iz = (/** @type {any} */ type, /** @type {any} */ arg) => ({}).toString.ca
 
 class FooBar { }
 
-expect(is(FooBar, new FooBar())).toBe(true)
-expect(iz(FooBar, new FooBar())).toBe(false)
+expect(is(FooBar, new FooBar())).to.be.true
+expect(iz(FooBar, new FooBar())).to.be.false
 
-expect(is(Object, new FooBar())).toBe(false)
-expect(iz(Object, new FooBar())).toBe(true)
+expect(is(Object, new FooBar())).to.be.false
+expect(iz(Object, new FooBar())).to.be.true
 
 const fakeFooBar = {}
 
 fakeFooBar[Symbol.toStringTag] = FooBar.name
 
-expect(is(FooBar, fakeFooBar)).toBe(false)
-expect(iz(FooBar, fakeFooBar)).toBe(true)
+expect(is(FooBar, fakeFooBar)).to.be.false
+expect(iz(FooBar, fakeFooBar)).to.be.true
 
-expect(is(Object, fakeFooBar)).toBe(true)
-expect(iz(Object, fakeFooBar)).toBe(false)
+expect(is(Object, fakeFooBar)).to.be.true
+expect(iz(Object, fakeFooBar)).to.be.false
 ```
 
 ### jcss
@@ -468,7 +468,7 @@ a{
   padding:1
 }`.replace(/\n\s*/g, '')
 
-expect(actual).toEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ```js
@@ -496,7 +496,7 @@ a.b{
   padding:1
 }`.replace(/\n\s*/g, '')
 
-expect(actual).toEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ```js
@@ -571,7 +571,7 @@ div.c2{
   }
 }`.replace(/\n\s*/g, '')
 
-expect(actual).toEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ```js
@@ -594,7 +594,7 @@ a.b.d,a.c.d{
   margin:2
 }`.replace(/\n\s*/g, '')
 
-expect(actual).toEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ```js
@@ -615,7 +615,7 @@ const expected = `
   margin:2
 }`.replace(/\n\s*/g, '')
 
-expect(actual).toEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ```js
@@ -636,7 +636,7 @@ const expected = `
   margin:2
 }`.replace(/\n\s*/g, '')
 
-expect(actual).toEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ### jsOnParse
@@ -701,7 +701,7 @@ const expected = [
   }
 ]
 
-expect(actual).toEqual(expected)
+expect(actual).to.deep.equal(expected)
 ```
 
 ### locale
@@ -720,18 +720,18 @@ const _ = locale({
   button: { Login: 'Zaloguj' }
 }, 'default')
 
-expect(_('Login')).toEqual('Login')
-expect(_('Password')).toEqual('Hasło')
+expect(_('Login')).to.deep.equal('Login')
+expect(_('Password')).to.deep.equal('Hasło')
 
-expect(_('Undefined text')).toEqual('Undefined text')
+expect(_('Undefined text')).to.deep.equal('Undefined text')
 
-expect(_('Login', 'button')).toEqual('Zaloguj')
+expect(_('Login', 'button')).to.deep.equal('Zaloguj')
 
-expect(_('Password', 'undefined_version')).toEqual('Hasło')
-expect(_('Undefined text', 'undefined_version')).toEqual('Undefined text')
+expect(_('Password', 'undefined_version')).to.deep.equal('Hasło')
+expect(_('Undefined text', 'undefined_version')).to.deep.equal('Undefined text')
 
-expect(_('toString')).toEqual('toString')
-expect(_('toString', 'undefined_version')).toEqual('toString')
+expect(_('toString')).to.deep.equal('toString')
+expect(_('toString', 'undefined_version')).to.deep.equal('toString')
 ```
 
 ### nanolight
@@ -755,7 +755,7 @@ A helper for highlighting JavaScript.
 ```js
 const codeJs = 'const answerToLifeTheUniverseAndEverything = 42'
 
-expect(h('pre', ['code', ...nanolightJs(codeJs)]).outerHTML).toEqual(
+expect(h('pre', ['code', ...nanolightJs(codeJs)]).outerHTML).to.deep.equal(
   '<pre><code><span class="keyword">const</span> <span class="literal">answerToLifeTheUniverseAndEverything</span> <span class="operator">=</span> <span class="number">42</span></code></pre>')
 ```
 
@@ -772,7 +772,7 @@ A helper that implements TypeScript’s `Omit` utility type.
 ```js
 const obj = { a: 42, b: '42', c: 17 }
 
-expect(omit(obj, ['c'])).toEqual({ a: 42, b: '42' })
+expect(omit(obj, ['c'])).to.deep.equal({ a: 42, b: '42' })
 ```
 
 ### pick
@@ -788,7 +788,7 @@ A helper that implements TypeScript’s `Pick` utility type.
 ```js
 const obj = { a: 42, b: '42', c: 17 }
 
-expect(pick(obj, ['a', 'b'])).toEqual({ a: 42, b: '42' })
+expect(pick(obj, ['a', 'b'])).to.deep.equal({ a: 42, b: '42' })
 ```
 
 ### plUral
@@ -804,17 +804,17 @@ A helper for choosing the correct singular and plural.
 ```js
 const auto = plUral.bind(null, 'auto', 'auta', 'aut')
 
-expect(auto(0)).toEqual('aut')
-expect(auto(1)).toEqual('auto')
-expect(auto(17)).toEqual('aut')
-expect(auto(42)).toEqual('auta')
+expect(auto(0)).to.deep.equal('aut')
+expect(auto(1)).to.deep.equal('auto')
+expect(auto(17)).to.deep.equal('aut')
+expect(auto(42)).to.deep.equal('auta')
 
 const car = plUral.bind(null, 'car', 'cars', 'cars')
 
-expect(car(0)).toEqual('cars')
-expect(car(1)).toEqual('car')
-expect(car(17)).toEqual('cars')
-expect(car(42)).toEqual('cars')
+expect(car(0)).to.deep.equal('cars')
+expect(car(1)).to.deep.equal('car')
+expect(car(17)).to.deep.equal('cars')
+expect(car(42)).to.deep.equal('cars')
 ```
 
 ### pro
@@ -832,27 +832,27 @@ const ref = {}
 
 pro(ref).one.two[3][4] = 1234
 
-expect(ref).toEqual({ one: { two: { 3: { 4: 1234 } } } })
+expect(ref).to.deep.equal({ one: { two: { 3: { 4: 1234 } } } })
 
 pro(ref).one.two.tree = 123
 
-expect(ref).toEqual({ one: { two: { 3: { 4: 1234 }, tree: 123 } } })
+expect(ref).to.deep.equal({ one: { two: { 3: { 4: 1234 }, tree: 123 } } })
 
 pro(ref).one.two = undefined
 
-expect(ref).toEqual({ one: { two: undefined } })
+expect(ref).to.deep.equal({ one: { two: undefined } })
 
 delete pro(ref).one.two
 
-expect(ref).toEqual({ one: {} })
+expect(ref).to.deep.equal({ one: {} })
 
 pro(ref).one.two.three.four
 
-expect(ref).toEqual({ one: { two: { three: { four: {} } } } })
+expect(ref).to.deep.equal({ one: { two: { three: { four: {} } } } })
 
 pro(ref).one.two.three.four = 1234
 
-expect(ref).toEqual({ one: { two: { three: { four: 1234 } } } })
+expect(ref).to.deep.equal({ one: { two: { three: { four: 1234 } } } })
 ```
 
 ### refsInfo
@@ -870,8 +870,8 @@ It returns an array of triples: `[«name», «prototype-name», «array-of-own-p
 ```js
 const info = refsInfo(Array, Function)
 
-expect(info.find(([name]) => name === 'Array')?.[2]?.includes('length')).toBe(true)
-expect(info.find(([name]) => name === 'Function')?.[2]?.includes('length')).toBe(true)
+expect(info.find(([name]) => name === 'Array')?.[2]?.includes('length')).to.be.true
+expect(info.find(([name]) => name === 'Function')?.[2]?.includes('length')).to.be.true
 ```
 
 ```js
@@ -940,23 +940,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 && 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')
+  i === 1 && expect(uuid.split('-')[3]).to.deep.equal('8001')
+  i === 4095 && expect(uuid.split('-')[3]).to.deep.equal('8fff')
+  i === 4096 && expect(uuid.split('-')[3]).to.deep.equal('9000')
+  i === 9029 && expect(uuid.split('-')[3]).to.deep.equal('a345')
+  i === 13398 && expect(uuid.split('-')[3]).to.deep.equal('b456')
+  i === 16384 && expect(uuid.split('-')[3]).to.deep.equal('8000')
+  i === 17767 && expect(uuid.split('-')[3]).to.deep.equal('8567')
 }
 ```
 
 ```js
-expect(uuid1({ node: '000123456789abc' }).split('-')[4]).toEqual('123456789abc')
-expect(uuid1({ node: '123456789' }).split('-')[4]).toEqual('000123456789')
+expect(uuid1({ node: '000123456789abc' }).split('-')[4]).to.deep.equal('123456789abc')
+expect(uuid1({ node: '123456789' }).split('-')[4]).to.deep.equal('000123456789')
 ```
 
 ```js
-expect(uuid1({ date: new Date(323325000000) })).toStartWith('c1399400-9a71-11bd')
+expect(uuid1({ date: new Date(323325000000) }).startsWith('c1399400-9a71-11bd')).to.be.true
 ```
 
 ## License

package/refsInfo.d.ts

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

package/refsInfo.js

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

package/uuid1.d.ts

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

package/uuid1.js

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