@jackens/nnn 2024.2.19 → 2024.2.24

package/readme.md

@@ -2,7 +2,7 @@
 
 Jackens’ JavaScript helpers.
 
-<sub>Version: <code class="version">2024.2.19</code></sub>
+<sub>Version: <code class="version">2024.2.24</code></sub>
 
 ## Installation
 
@@ -61,7 +61,7 @@ import { «something» } from './node_modules/@jackens/nnn/nnn.js'
 ### EscapeMap
 
 ```ts
-export type EscapeMap = Map<any, (value?: any) => string>;
+type EscapeMap = Map<any, (value?: any) => string>;
 ```
 
 The type of arguments of the `escapeValues` and `escape` helpers.
@@ -69,7 +69,7 @@ The type of arguments of the `escapeValues` and `escape` helpers.
 ### HArgs
 
 ```ts
-export type HArgs = [string | Node, ...HArgs1[]];
+type HArgs = [string | Node, ...HArgs1[]];
 ```
 
 The type of arguments of the `h` and `s` helpers.
@@ -77,7 +77,7 @@ The type of arguments of the `h` and `s` helpers.
 ### HArgs1
 
 ```ts
-export type HArgs1 = Partial<Record<PropertyKey, any>> | null | undefined | Node | string | number | [string | Node, ...HArgs1[]];
+type HArgs1 = Partial<Record<PropertyKey, any>> | null | undefined | Node | string | number | HArgs;
 ```
 
 The type of arguments of the `h` and `s` helpers.
@@ -85,7 +85,7 @@ The type of arguments of the `h` and `s` helpers.
 ### JcssNode
 
 ```ts
-export type JcssNode = {
+type JcssNode = {
     [attributeOrSelector: string]: string | number | JcssNode | undefined;
 };
 ```
@@ -95,7 +95,7 @@ The type of arguments of the `jcss` helper.
 ### JcssRoot
 
 ```ts
-export type JcssRoot = Partial<Record<PropertyKey, JcssNode>>;
+type JcssRoot = Partial<Record<PropertyKey, JcssNode>>;
 ```
 
 The type of arguments of the `jcss` helper.
@@ -103,19 +103,20 @@ The type of arguments of the `jcss` helper.
 ### chartable
 
 ```ts
-export function chartable({ table, headerColumn, xGap, xLabelsPx, xLabelsRotate, xReverse, yGap, yLabelsLeftPx, yLabelsRightPx, yMax, zLabelsPx }: {
+const chartable: ({ table, headerColumn, xGap, xLabelsMinHeight, xLabelsRotate, xReverse, yGap, yLabelsLeftMinWidth, yLabelsRightMinWidth, yMax, zLabelsMinWidth, zyMappings }: {
     table: HTMLTableElement;
-    headerColumn?: boolean;
-    xGap?: number;
-    xLabelsPx?: number;
-    xLabelsRotate?: boolean;
-    xReverse?: boolean;
-    yGap?: number;
-    yLabelsLeftPx?: number;
-    yLabelsRightPx?: number;
-    yMax?: number;
-    zLabelsPx?: number;
-}): SVGSVGElement;
+    headerColumn?: boolean | undefined;
+    xGap?: number | undefined;
+    xLabelsMinHeight?: number | undefined;
+    xLabelsRotate?: boolean | undefined;
+    xReverse?: boolean | undefined;
+    yGap?: number | undefined;
+    yLabelsLeftMinWidth?: number | undefined;
+    yLabelsRightMinWidth?: number | undefined;
+    yMax?: number | undefined;
+    zLabelsMinWidth?: number | undefined;
+    zyMappings?: [(label: string) => number, (value: number) => string][] | undefined;
+}) => SVGSVGElement;
 ```
 
 A helper for creating a chart based on a table (conf. <https://jackens.github.io/nnn/chartable/>).
@@ -124,19 +125,20 @@ Options:
 - `table`: `HTMLTableElement` to extract data, data series labels and X axis labels
 - `headerColumn`: flag indicating that `table` has a header column with X axis labels
 - `xGap`: X axis spacing
-- `xLabelsPx`:
+- `xLabelsMinHeight`: minimal height of X axis labels
 - `xLabelsRotate`: flag to rotate X axis labels
 - `xReverse`: flag to reverse all data series
 - `yGap`: Y axis spacing
-- `yLabelsLeftPx`:
-- `yLabelsRightPx`:
+- `yLabelsLeftMinWidth`: minimal width of Y axis left labels
+- `yLabelsRightMinWidth`: minimal width of Y axis right labels
 - `yMax`: number of Y axis lines
-- `zLabelsPx`:
+- `zLabelsMinWidth`: minimal width of data series labels
+- `zyMappings`: mappings per data series
 
 ### eq
 
 ```ts
-export function eq(x: any, y: any): boolean;
+const eq: (x: any, y: any) => boolean;
 ```
 
 A helper that checks equality of the given arguments.
@@ -144,41 +146,41 @@ A helper that checks equality of the given arguments.
 #### Usage Examples
 
 ```js
-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(true, true)).toBeTrue()
+expect(eq(NaN, NaN)).toBeTrue()
+expect(eq(null, undefined)).toBeFalse()
+expect(eq(42, 42)).toBeTrue()
+expect(eq(42, new Number(42))).toBeTrue()
+expect(eq(42, Number(42))).toBeTrue()
+expect(eq(new Number(42), Number(42))).toBeTrue()
+expect(eq(42, '42')).toBeFalse()
+expect(eq('42', '42')).toBeTrue()
+expect(eq('42', new String('42'))).toBeTrue()
+expect(eq('42', String('42'))).toBeTrue()
+expect(eq(String('42'), new String('42'))).toBeTrue()
+expect(eq(/42/, /42/)).toBeTrue()
+expect(eq(/42/, /42/g)).toBeFalse()
+expect(eq(new Date(42), new Date(42))).toBeTrue()
+expect(eq(new Date(), new Date(42))).toBeFalse()
+expect(eq({ j: '42', c: 42 }, { c: 42, j: '42' })).toBeTrue()
+expect(eq([42, '42'], [42, '42'])).toBeTrue()
+expect(eq(new Set(['42', 42]), new Set([42, '42']))).toBeTrue()
+expect(eq(new Set(['42', 42]), new Set([42]))).toBeFalse()
+expect(eq(new Set([42, undefined]), new Set([42]))).toBeFalse()
 expect(eq(
   new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]),
   new Map([[{ c: 42 }, { C: '42' }], [{ j: 42 }, { J: '42' }]])
-)).to.be.true
+)).toBeTrue()
 expect(eq(
   new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]),
   new Map([[{ j: '42' }, { J: 42 }], [{ c: '42' }, { C: 42 }]])
-)).to.be.false
+)).toBeFalse()
 ```
 
 ### escape
 
 ```ts
-export function escape(escapeMap: EscapeMap, template: TemplateStringsArray, ...values: any[]): string;
+const escape: (escapeMap: EscapeMap, template: TemplateStringsArray, ...values: any[]) => string;
 ```
 
 A generic helper for escaping `values` by given `escapeMap` (in *TemplateStrings* flavor).
@@ -186,13 +188,13 @@ A generic helper for escaping `values` by given `escapeMap` (in *TemplateStrings
 #### Usage Examples
 
 ```js
-const /** @type {EscapeMap} */ escapeMap = new Map([
+const escapeMap: EscapeMap = new Map([
   [undefined, () => 'NULL'],
-  [Array, (/** @type {any[]} */ values) => escapeValues(escapeMap, values).join(', ')],
-  [Boolean, (/** @type {boolean} */ value) => `b'${+value}'`],
-  [Date, (/** @type {Date} */ value) => `'${value.toISOString().replace(/^(.+)T(.+)\..*$/, '$1 $2')}'`],
-  [Number, (/** @type {number} */ value) => `${value}`],
-  [String, (/** @type {string} */ value) => `'${value.replace(/'/g, "''")}'`]
+  [Array, (values: any[]) => escapeValues(escapeMap, values).join(', ')],
+  [Boolean, (value: boolean) => `b'${+value}'`],
+  [Date, (value: Date) => `'${value.toISOString().replace(/^(.+)T(.+)\..*$/, '$1 $2')}'`],
+  [Number, (value: number) => `${value}`],
+  [String, (value: string) => `'${value.replace(/'/g, "''")}'`]
 ])
 
 const sql = escape.bind(null, escapeMap)
@@ -207,13 +209,13 @@ 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).to.deep.equal(expected)
+expect(actual).toStrictEqual(expected)
 ```
 
 ### escapeValues
 
 ```ts
-export function escapeValues(escapeMap: EscapeMap, values: any[]): string[];
+const escapeValues: (escapeMap: EscapeMap, values: any[]) => string[];
 ```
 
 A generic helper for escaping `values` by given `escapeMap`.
@@ -221,7 +223,7 @@ A generic helper for escaping `values` by given `escapeMap`.
 ### fixTypography
 
 ```ts
-export function fixTypography(node: Node): void;
+const fixTypography: (node: Node) => void;
 ```
 
 A helper that implements typographic corrections specific to Polish typography.
@@ -233,7 +235,7 @@ const p = h('p', 'Pchnąć w tę łódź jeża lub ośm skrzyń fig (zob. https:
 
 fixTypography(p)
 
-expect(p.innerHTML).to.deep.equal(
+expect(p.innerHTML).toStrictEqual(
   'Pchnąć <span style="white-space:nowrap">w </span>tę łódź jeża lub ośm skrzyń fig ' +
   '(zob. https://\u200Bpl.\u200Bwikipedia.\u200Borg/\u200Bwiki/\u200BPangram).')
 ```
@@ -241,9 +243,11 @@ expect(p.innerHTML).to.deep.equal(
 ### h
 
 ```ts
-export function h<T extends keyof HTMLElementTagNameMap>(tag: T, ...args1: HArgs1[]): HTMLElementTagNameMap[T];
-export function h<N extends Node>(node: N, ...args1: HArgs1[]): N;
-export function h(tagOrNode: string | Node, ...args1: HArgs1[]): Node;
+const h: {
+    <T extends keyof HTMLElementTagNameMap>(tag: T, ...args1: HArgs1[]): HTMLElementTagNameMap[T];
+    <N extends Node>(node: N, ...args1: HArgs1[]): N;
+    (tagOrNode: string | Node, ...args1: HArgs1[]): Node;
+};
 ```
 
 A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `HTMLElement`s (see also `s`).
@@ -265,73 +269,73 @@ A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style help
 ```js
 const b = h('b')
 
-expect(b.outerHTML).to.deep.equal('<b></b>')
+expect(b.outerHTML).toStrictEqual('<b></b>')
 
 const i = h('i', 'text')
 
 h(b, i)
 
-expect(i.outerHTML).to.deep.equal('<i>text</i>')
-expect(b.outerHTML).to.deep.equal('<b><i>text</i></b>')
+expect(i.outerHTML).toStrictEqual('<i>text</i>')
+expect(b.outerHTML).toStrictEqual('<b><i>text</i></b>')
 
 h(i, { $className: 'some class' })
 
-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>')
+expect(i.outerHTML).toStrictEqual('<i class="some class">text</i>')
+expect(b.outerHTML).toStrictEqual('<b><i class="some class">text</i></b>')
 ```
 
 ```js
-expect(h('span', 'text').outerHTML).to.deep.equal('<span>text</span>')
-expect(h('span', { $innerText: 'text' }).outerHTML).to.deep.equal('<span>text</span>')
+expect(h('span', 'text').outerHTML).toStrictEqual('<span>text</span>')
+expect(h('span', { $innerText: 'text' }).outerHTML).toStrictEqual('<span>text</span>')
 ```
 
 ```js
 expect(h('div', { style: 'margin:0;padding:0' }).outerHTML)
-  .to.deep.equal('<div style="margin:0;padding:0"></div>')
+  .toStrictEqual('<div style="margin:0;padding:0"></div>')
 expect(h('div', { $style: 'margin:0;padding:0' }).outerHTML)
-  .to.deep.equal('<div style="margin: 0px; padding: 0px;"></div>')
+  .toStrictEqual('<div style="margin: 0px; padding: 0px;"></div>')
 expect(h('div', { $style: { margin: 0, padding: 0 } }).outerHTML)
-  .to.deep.equal('<div style="margin: 0px; padding: 0px;"></div>')
+  .toStrictEqual('<div style="margin: 0px; padding: 0px;"></div>')
 ```
 
 ```js
 const input1 = h('input', { value: 42 })
 const input2 = h('input', { $value: '42' })
 
-expect(input1.value).to.deep.equal('42')
-expect(input2.value).to.deep.equal('42')
+expect(input1.value).toStrictEqual('42')
+expect(input2.value).toStrictEqual('42')
 
-expect(input1.outerHTML).to.deep.equal('<input value="42">')
-expect(input2.outerHTML).to.deep.equal('<input>')
+expect(input1.outerHTML).toStrictEqual('<input value="42">')
+expect(input2.outerHTML).toStrictEqual('<input>')
 
 const checkbox1 = h('input', { type: 'checkbox', checked: true })
 const checkbox2 = h('input', { type: 'checkbox', $checked: true })
 
-expect(checkbox1.checked).to.be.true
-expect(checkbox2.checked).to.be.true
+expect(checkbox1.checked).toBeTrue()
+expect(checkbox2.checked).toBeTrue()
 
-expect(checkbox1.outerHTML).to.deep.equal('<input type="checkbox" checked="">')
-expect(checkbox2.outerHTML).to.deep.equal('<input type="checkbox">')
+expect(checkbox1.outerHTML).toStrictEqual('<input type="checkbox" checked="">')
+expect(checkbox2.outerHTML).toStrictEqual('<input type="checkbox">')
 ```
 
 ```js
 const div = h('div')
 
-expect(div.key).to.be.undefined
+expect(div.key).toBeUndefined()
 
 h(div, { $key: { one: 1 } })
 
-expect(div.key).to.deep.equal({ one: 1 })
+expect(div.key).toStrictEqual({ one: 1 })
 
 h(div, { $key: { two: 2 } })
 
-expect(div.key).to.deep.equal({ one: 1, two: 2 })
+expect(div.key).toStrictEqual({ one: 1, two: 2 })
 ```
 
 ### has
 
 ```ts
-export function has(key: any, ref: any): boolean;
+const has: (key: any, ref: any) => boolean;
 ```
 
 A replacement for the `in` operator (not to be confused with the `for-in` loop) that works properly.
@@ -341,17 +345,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).to.be.true
-expect(has('key', obj)).to.be.true
+expect('key' in obj).toBeTrue()
+expect(has('key', obj)).toBeTrue()
 
-expect('null' in obj).to.be.true
-expect(has('null', obj)).to.be.true
+expect('null' in obj).toBeTrue()
+expect(has('null', obj)).toBeTrue()
 
-expect(null in obj).to.be.true
-expect(has(null, obj)).to.be.false
+expect(null in obj).toBeTrue()
+expect(has(null, obj)).toBeFalse()
 
-expect('toString' in obj).to.be.true
-expect(has('toString', obj)).to.be.false
+expect('toString' in obj).toBeTrue()
+expect(has('toString', obj)).toBeFalse()
 ```
 
 ```js
@@ -364,21 +368,20 @@ try {
 }
 
 expect(typeError instanceof TypeError) // Cannot use 'in' operator to search for 'key' in null
-expect(has('key', null)).to.be.false
+expect(has('key', null)).toBeFalse()
 ```
 
 ### is
 
 ```ts
-export const is: {
-    (type: BigIntConstructor, arg: any): arg is bigint;
-    (type: BooleanConstructor, arg: any): arg is boolean;
-    (type: NumberConstructor, arg: any): arg is number;
-    (type: StringConstructor, arg: any): arg is string;
-    (type: SymbolConstructor, arg: any): arg is symbol;
-    (type: undefined, arg: any): arg is null | undefined;
-    <T extends abstract new (...args: any[]) => any>(type: T, arg: any): arg is InstanceType<T>;
-};
+function is(type: BigIntConstructor, arg: any): arg is bigint;
+function is(type: BooleanConstructor, arg: any): arg is boolean;
+function is(type: NumberConstructor, arg: any): arg is number;
+function is(type: ObjectConstructor, arg: any): arg is Partial<Record<PropertyKey, any>>;
+function is(type: StringConstructor, arg: any): arg is string;
+function is(type: SymbolConstructor, arg: any): arg is symbol;
+function is(type: undefined, arg: any): arg is undefined | null;
+function is<T extends abstract new (...args: any[]) => any>(type: T, arg: any): arg is InstanceType<T>;
 ```
 
 A helper that checks if the given argument is of a certain type.
@@ -386,51 +389,51 @@ A helper that checks if the given argument is of a certain type.
 #### Usage Examples
 
 ```js
-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
+expect(is(Number, 42)).toBeTrue()
+expect(is(Number, Number(42))).toBeTrue()
+expect(is(Number, new Number(42))).toBeTrue()
+expect(is(Number, NaN)).toBeTrue()
+expect(is(String, '42')).toBeTrue()
+expect(is(String, String('42'))).toBeTrue()
+expect(is(String, new String('42'))).toBeTrue()
+expect(is(Symbol, Symbol('42'))).toBeTrue()
+expect(is(Symbol, Object(Symbol('42')))).toBeTrue()
+expect(is(undefined, undefined)).toBeTrue()
+expect(is(undefined, null)).toBeTrue()
+expect(is(Object, {})).toBeTrue()
+expect(is(Array, [])).toBeTrue()
+expect(is(RegExp, /42/)).toBeTrue()
+expect(is(Date, new Date(42))).toBeTrue()
+expect(is(Set, new Set(['42', 42]))).toBeTrue()
+expect(is(Map, new Map([[{ j: 42 }, { J: '42' }], [{ c: 42 }, { C: '42' }]]))).toBeTrue()
 ```
 
 ```js
-const iz = (/** @type {any} */ type, /** @type {any} */ arg) => ({}).toString.call(arg).slice(8, -1) === type?.name
+const iz = (type: any, arg: any) => ({}).toString.call(arg).slice(8, -1) === type?.name
 
 class FooBar { }
 
-expect(is(FooBar, new FooBar())).to.be.true
-expect(iz(FooBar, new FooBar())).to.be.false
+expect(is(FooBar, new FooBar())).toBeTrue()
+expect(iz(FooBar, new FooBar())).toBeFalse()
 
-expect(is(Object, new FooBar())).to.be.false
-expect(iz(Object, new FooBar())).to.be.true
+expect(is(Object, new FooBar())).toBeFalse()
+expect(iz(Object, new FooBar())).toBeTrue()
 
 const fakeFooBar = {}
 
 fakeFooBar[Symbol.toStringTag] = FooBar.name
 
-expect(is(FooBar, fakeFooBar)).to.be.false
-expect(iz(FooBar, fakeFooBar)).to.be.true
+expect(is(FooBar, fakeFooBar)).toBeFalse()
+expect(iz(FooBar, fakeFooBar)).toBeTrue()
 
-expect(is(Object, fakeFooBar)).to.be.true
-expect(iz(Object, fakeFooBar)).to.be.false
+expect(is(Object, fakeFooBar)).toBeTrue()
+expect(iz(Object, fakeFooBar)).toBeFalse()
 ```
 
 ### jcss
 
 ```ts
-export function jcss(root: JcssRoot, splitter?: string): string;
+const jcss: (root: JcssRoot, splitter?: string) => string;
 ```
 
 A simple CSS-in-JS helper.
@@ -468,7 +471,7 @@ a{
   padding:1
 }`.replace(/\n\s*/g, '')
 
-expect(actual).to.deep.equal(expected)
+expect(actual).toStrictEqual(expected)
 ```
 
 ```js
@@ -496,7 +499,7 @@ a.b{
   padding:1
 }`.replace(/\n\s*/g, '')
 
-expect(actual).to.deep.equal(expected)
+expect(actual).toStrictEqual(expected)
 ```
 
 ```js
@@ -571,7 +574,7 @@ div.c2{
   }
 }`.replace(/\n\s*/g, '')
 
-expect(actual).to.deep.equal(expected)
+expect(actual).toStrictEqual(expected)
 ```
 
 ```js
@@ -594,7 +597,7 @@ a.b.d,a.c.d{
   margin:2
 }`.replace(/\n\s*/g, '')
 
-expect(actual).to.deep.equal(expected)
+expect(actual).toStrictEqual(expected)
 ```
 
 ```js
@@ -615,7 +618,7 @@ const expected = `
   margin:2
 }`.replace(/\n\s*/g, '')
 
-expect(actual).to.deep.equal(expected)
+expect(actual).toStrictEqual(expected)
 ```
 
 ```js
@@ -636,13 +639,13 @@ const expected = `
   margin:2
 }`.replace(/\n\s*/g, '')
 
-expect(actual).to.deep.equal(expected)
+expect(actual).toStrictEqual(expected)
 ```
 
 ### jsOnParse
 
 ```ts
-export function jsOnParse(handlers: Partial<Record<PropertyKey, Function>>, text: string): any;
+const jsOnParse: (handlers: Partial<Record<PropertyKey, Function>>, text: string) => any;
 ```
 
 `JSON.parse` with “JavaScript turned on”.
@@ -663,9 +666,10 @@ handlers['«handlerName»'](...«params»)
 
 ```js
 const handlers = {
-  $hello: (/** @type {string} */ name) => `Hello ${name}!`,
+  $hello: (name: string) => `Hello ${name}!`,
   $foo: () => 'bar'
 }
+
 const actual = jsOnParse(handlers, `[
   {
     "$hello": ["World"]
@@ -686,6 +690,7 @@ const actual = jsOnParse(handlers, `[
     "two": 2
   }
 ]`)
+
 const expected = [
   'Hello World!',
   {
@@ -701,13 +706,13 @@ const expected = [
   }
 ]
 
-expect(actual).to.deep.equal(expected)
+expect(actual).toStrictEqual(expected)
 ```
 
 ### locale
 
 ```ts
-export function locale(map: Partial<Record<PropertyKey, Partial<Record<PropertyKey, string>>>>, defaultVersion: string): (text: string, version?: string) => string;
+const locale: (map: Partial<Record<PropertyKey, Partial<Record<PropertyKey, string>>>>, defaultVersion: string) => (text: string, version?: string) => string;
 ```
 
 Language translations helper.
@@ -720,24 +725,24 @@ const _ = locale({
   button: { Login: 'Zaloguj' }
 }, 'default')
 
-expect(_('Login')).to.deep.equal('Login')
-expect(_('Password')).to.deep.equal('Hasło')
+expect(_('Login')).toStrictEqual('Login')
+expect(_('Password')).toStrictEqual('Hasło')
 
-expect(_('Undefined text')).to.deep.equal('Undefined text')
+expect(_('Undefined text')).toStrictEqual('Undefined text')
 
-expect(_('Login', 'button')).to.deep.equal('Zaloguj')
+expect(_('Login', 'button')).toStrictEqual('Zaloguj')
 
-expect(_('Password', 'undefined_version')).to.deep.equal('Hasło')
-expect(_('Undefined text', 'undefined_version')).to.deep.equal('Undefined text')
+expect(_('Password', 'undefined_version')).toStrictEqual('Hasło')
+expect(_('Undefined text', 'undefined_version')).toStrictEqual('Undefined text')
 
-expect(_('toString')).to.deep.equal('toString')
-expect(_('toString', 'undefined_version')).to.deep.equal('toString')
+expect(_('toString')).toStrictEqual('toString')
+expect(_('toString', 'undefined_version')).toStrictEqual('toString')
 ```
 
 ### nanolight
 
 ```ts
-export function nanolight(pattern: RegExp, highlighters: ((chunk: string, index: number) => import('./h.js').HArgs1)[], code: string): import("./h.js").HArgs1[];
+const nanolight: (pattern: RegExp, highlighters: ((chunk: string, index: number) => HArgs1)[], code: string) => HArgs1[];
 ```
 
 A generic helper for syntax highlighting (see also `nanolightJs`).
@@ -745,7 +750,7 @@ A generic helper for syntax highlighting (see also `nanolightJs`).
 ### nanolightJs
 
 ```ts
-export const nanolightJs: (code?: string | undefined) => import("./h.js").HArgs1[];
+const nanolightJs: (code: string) => HArgs1[];
 ```
 
 A helper for highlighting JavaScript.
@@ -755,14 +760,14 @@ A helper for highlighting JavaScript.
 ```js
 const codeJs = 'const answerToLifeTheUniverseAndEverything = 42'
 
-expect(h('pre', ['code', ...nanolightJs(codeJs)]).outerHTML).to.deep.equal(
+expect(h('pre', ['code', ...nanolightJs(codeJs)]).outerHTML).toStrictEqual(
   '<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]>;
+const omit: <T extends Partial<Record<PropertyKey, any>>, K extends (keyof T)[]>(obj: Partial<Record<PropertyKey, any>>, keys: any[]) => Omit<T, K[number]>;
 ```
 
 A helper that implements TypeScript’s `Omit` utility type.
@@ -772,13 +777,13 @@ A helper that implements TypeScript’s `Omit` utility type.
 ```js
 const obj = { a: 42, b: '42', c: 17 }
 
-expect(omit(obj, ['c'])).to.deep.equal({ a: 42, b: '42' })
+expect(omit(obj, ['c'])).toStrictEqual({ 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]>;
+const pick: <T extends Partial<Record<PropertyKey, any>>, K extends (keyof T)[]>(obj: Partial<Record<PropertyKey, any>>, keys: any[]) => Pick<T, K[number]>;
 ```
 
 A helper that implements TypeScript’s `Pick` utility type.
@@ -788,13 +793,13 @@ A helper that implements TypeScript’s `Pick` utility type.
 ```js
 const obj = { a: 42, b: '42', c: 17 }
 
-expect(pick(obj, ['a', 'b'])).to.deep.equal({ a: 42, b: '42' })
+expect(pick(obj, ['a', 'b'])).toStrictEqual({ a: 42, b: '42' })
 ```
 
 ### plUral
 
 ```ts
-export function plUral(singular: string, plural2: string, plural5: string, value: number): string;
+const plUral: (singular: string, plural2: string, plural5: string, value: number) => string;
 ```
 
 A helper for choosing the correct singular and plural.
@@ -804,23 +809,23 @@ A helper for choosing the correct singular and plural.
 ```js
 const auto = plUral.bind(null, 'auto', 'auta', 'aut')
 
-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')
+expect(auto(0)).toStrictEqual('aut')
+expect(auto(1)).toStrictEqual('auto')
+expect(auto(17)).toStrictEqual('aut')
+expect(auto(42)).toStrictEqual('auta')
 
 const car = plUral.bind(null, 'car', 'cars', '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')
+expect(car(0)).toStrictEqual('cars')
+expect(car(1)).toStrictEqual('car')
+expect(car(17)).toStrictEqual('cars')
+expect(car(42)).toStrictEqual('cars')
 ```
 
 ### pro
 
 ```ts
-export function pro(ref: any): any;
+const pro: (ref: any) => any;
 ```
 
 A helper that protects calls to nested properties by a `Proxy` that initializes non-existent values with an empty object.
@@ -832,33 +837,33 @@ const ref = {}
 
 pro(ref).one.two[3][4] = 1234
 
-expect(ref).to.deep.equal({ one: { two: { 3: { 4: 1234 } } } })
+expect(ref).toStrictEqual({ one: { two: { 3: { 4: 1234 } } } })
 
 pro(ref).one.two.tree = 123
 
-expect(ref).to.deep.equal({ one: { two: { 3: { 4: 1234 }, tree: 123 } } })
+expect(ref).toStrictEqual({ one: { two: { 3: { 4: 1234 }, tree: 123 } } })
 
 pro(ref).one.two = undefined
 
-expect(ref).to.deep.equal({ one: { two: undefined } })
+expect(ref).toStrictEqual({ one: { two: undefined } })
 
 delete pro(ref).one.two
 
-expect(ref).to.deep.equal({ one: {} })
+expect(ref).toStrictEqual({ one: {} })
 
 pro(ref).one.two.three.four
 
-expect(ref).to.deep.equal({ one: { two: { three: { four: {} } } } })
+expect(ref).toStrictEqual({ one: { two: { three: { four: {} } } } })
 
 pro(ref).one.two.three.four = 1234
 
-expect(ref).to.deep.equal({ one: { two: { three: { four: 1234 } } } })
+expect(ref).toStrictEqual({ one: { two: { three: { four: 1234 } } } })
 ```
 
 ### refsInfo
 
 ```ts
-export function refsInfo(...refs: any[]): [string, string, string[]][];
+const refsInfo: (...refs: any[]) => [string, string, string[]][];
 ```
 
 A helper that provides information about the given `refs`.
@@ -870,8 +875,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')).to.be.true
-expect(info.find(([name]) => name === 'Function')?.[2]?.includes('length')).to.be.true
+expect(info.find(([name]) => name === 'Array')?.[2]?.includes('length')).toBeTrue()
+expect(info.find(([name]) => name === 'Function')?.[2]?.includes('length')).toBeTrue()
 ```
 
 ```js
@@ -901,9 +906,11 @@ console.log(browserFingerprint())
 ### s
 
 ```ts
-export function s<T extends keyof SVGElementTagNameMap>(tag: T, ...args1: HArgs1[]): SVGElementTagNameMap[T];
-export function s<N extends Node>(node: N, ...args1: HArgs1[]): N;
-export function s(tagOrNode: string | Node, ...args1: HArgs1[]): Node;
+const s: {
+    <T extends keyof SVGElementTagNameMap>(tag: T, ...args1: HArgs1[]): SVGElementTagNameMap[T];
+    <N extends Node>(node: N, ...args1: HArgs1[]): N;
+    (tagOrNode: string | Node, ...args1: HArgs1[]): Node;
+};
 ```
 
 A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `SVGElement`s (see also `h`).
@@ -923,10 +930,10 @@ A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style help
 ### uuid1
 
 ```ts
-export function uuid1({ date, node }?: {
+const uuid1: ({ date, node }?: {
     date?: Date | undefined;
     node?: string | undefined;
-}): string;
+}) => string;
 ```
 
 A helper that generates a UUID v1 identifier (with a creation timestamp).
@@ -940,23 +947,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]).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')
+  i === 1 && expect(uuid.split('-')[3]).toStrictEqual('8001')
+  i === 4095 && expect(uuid.split('-')[3]).toStrictEqual('8fff')
+  i === 4096 && expect(uuid.split('-')[3]).toStrictEqual('9000')
+  i === 9029 && expect(uuid.split('-')[3]).toStrictEqual('a345')
+  i === 13398 && expect(uuid.split('-')[3]).toStrictEqual('b456')
+  i === 16384 && expect(uuid.split('-')[3]).toStrictEqual('8000')
+  i === 17767 && expect(uuid.split('-')[3]).toStrictEqual('8567')
 }
 ```
 
 ```js
-expect(uuid1({ node: '000123456789abc' }).split('-')[4]).to.deep.equal('123456789abc')
-expect(uuid1({ node: '123456789' }).split('-')[4]).to.deep.equal('000123456789')
+expect(uuid1({ node: '000123456789abc' }).split('-')[4]).toStrictEqual('123456789abc')
+expect(uuid1({ node: '123456789' }).split('-')[4]).toStrictEqual('000123456789')
 ```
 
 ```js
-expect(uuid1({ date: new Date(323325000000) }).startsWith('c1399400-9a71-11bd')).to.be.true
+expect(uuid1({ date: new Date(323325000000) }).startsWith('c1399400-9a71-11bd')).toBeTrue()
 ```
 
 ## License