@jackens/nnn 2026.4.13 → 2026.4.15

package/readme.md

@@ -1,6 +1,6 @@
 # nnn
 
-A collection of Jackens’ JavaScript helper utilities (version: `2026.4.13`).
+A collection of Jackens’ JavaScript helper utilities (version: `2026.4.15`).
 
 ## Installation
 
@@ -41,40 +41,95 @@ import {
   s,
   svgUse,
   uuidV1,
-  vivify
+  vivify,
 } from '@jackens/nnn' // or './node_modules/@jackens/nnn/nnn.js'
 ```
 
 ## Exports
 
-- [`CNode`](#CNode): Represents a CSS rule node for the [`c`](#c) helper. Keys are CSS properties or nested selectors.
-- [`CRoot`](#CRoot): Represents the root CSS object for the [`c`](#c) helper. Keys are top-level selectors or at-rules.
-- [`HArgs`](#HArgs): Tuple argument type for the [`h`](#h) and [`s`](#s) helpers.
-- [`HArgs1`](#HArgs1): Single argument type for the [`h`](#h) and [`s`](#s) helpers.
-- [`c`](#c): A minimal CSS-in-JS helper that converts a JavaScript object hierarchy into a CSS string.
-- [`csvParse`](#csvParse): Parses a CSV string into a two-dimensional array of strings.
-- [`fixPlTypography`](#fixPlTypography): Applies Polish-specific typographic corrections to a DOM subtree.
-- [`h`](#h): A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `HTMLElement`s (see also [`s`](#s)).
-- [`hasOwn`](#hasOwn): Checks whether an object has the specified key as its own property.
-- [`isArray`](#isArray): Checks whether the argument is an array.
-- [`isFiniteNumber`](#isFiniteNumber): Checks whether the argument is a finite number (excludes `±Infinity` and `NaN`).
-- [`isInteger`](#isInteger): Checks whether the argument is an integer number.
-- [`isNumber`](#isNumber): Checks whether the argument is of type `number` (includes `NaN` and `±Infinity`).
-- [`isRecord`](#isRecord): Checks whether the argument is a plain object (not `null` and not an array).
-- [`isString`](#isString): Checks whether the argument is a string.
-- [`jsOnParse`](#jsOnParse): Parses JSON with support for handler-based value transformation (“JavaScript ON”).
-- [`monokai`](#monokai): A Monokai-inspired color scheme for use with the [`c`](#c) helper and [`nanolightTs`](#nanolightTs) tokenizer.
-- [`nanolightTs`](#nanolightTs): A TypeScript/JavaScript syntax highlighting tokenizer built using [`newTokenizer`](#newTokenizer).
-- [`newEscape`](#newEscape): Creates a tag function for escaping interpolated values in template literals.
-- [`newNounForm`](#newNounForm): Creates a function that returns the appropriate noun form based on a numeric value using `Intl.PluralRules`.
-- [`newTokenizer`](#newTokenizer): A helper for building simple tokenizers (see also [`nanolightTs`](#nanolightTs)).
-- [`omit`](#omit): Creates a new object excluding the specified keys from the source object.
-- [`pick`](#pick): Creates a new object containing only the specified keys from the source object.
-- [`rwd`](#rwd): A responsive web design helper that generates CSS rules for a grid-like layout.
-- [`s`](#s): A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `SVGElement`s (see also [`h`](#h)).
-- [`svgUse`](#svgUse): Shorthand for creating an SVG element with a `<use>` child referencing an icon by ID.
-- [`uuidV1`](#uuidV1): Generates a UUID v1 (time-based) identifier.
-- [`vivify`](#vivify): A Proxy-based helper for auto-vivification of nested object structures.
+- [`CNode`](#CNode):
+  Represents a CSS rule node for the [`c`](#c) helper.
+- [`CRoot`](#CRoot):
+  Represents the root CSS object for the [`c`](#c) helper.
+- [`HArgs`](#HArgs):
+  Tuple argument type for the [`h`](#h) and [`s`](#s)
+  helpers.
+- [`HArgs1`](#HArgs1):
+  Single argument type for the [`h`](#h) and [`s`](#s)
+  helpers.
+- [`c`](#c):
+  A minimal CSS-in-JS helper
+  that converts a JavaScript object hierarchy
+  into a CSS string.
+- [`csvParse`](#csvParse):
+  Parses a CSV string
+  into a two-dimensional array of strings.
+- [`fixPlTypography`](#fixPlTypography):
+  Applies Polish-specific typographic corrections
+  to a DOM subtree.
+- [`h`](#h):
+  A lightweight *HyperScript*-style helper
+  for creating and modifying `HTMLElement`s
+  (see also [`s`](#s)).
+- [`hasOwn`](#hasOwn):
+  Checks whether an object has the specified key
+  as its own property.
+- [`isArray`](#isArray):
+  Checks whether the argument is an array.
+- [`isFiniteNumber`](#isFiniteNumber):
+  Checks whether the argument is a finite number
+  (excludes `±Infinity` and `NaN`).
+- [`isInteger`](#isInteger):
+  Checks whether the argument is an integer number.
+- [`isNumber`](#isNumber):
+  Checks whether the argument is of type `number`
+  (includes `NaN` and `±Infinity`).
+- [`isRecord`](#isRecord):
+  Checks whether the argument is a plain object
+  (not `null` and not an array).
+- [`isString`](#isString):
+  Checks whether the argument is a string.
+- [`jsOnParse`](#jsOnParse):
+  Parses JSON with support for
+  handler-based value transformation (“JavaScript ON”).
+- [`monokai`](#monokai):
+  A Monokai-inspired color scheme
+  for use with the [`c`](#c) helper
+  and [`nanolightTs`](#nanolightTs) tokenizer.
+- [`nanolightTs`](#nanolightTs):
+  A TypeScript/JavaScript syntax highlighting tokenizer
+  built using [`newTokenizer`](#newTokenizer).
+- [`newEscape`](#newEscape):
+  Creates a tag function
+  for escaping interpolated values in template literals.
+- [`newNounForm`](#newNounForm):
+  Creates a function that
+  returns the appropriate noun form
+  based on a numeric value using `Intl.PluralRules`.
+- [`newTokenizer`](#newTokenizer):
+  A helper for building simple tokenizers
+  (see also [`nanolightTs`](#nanolightTs)).
+- [`omit`](#omit):
+  Creates a new object excluding the specified keys
+  from the source object.
+- [`pick`](#pick):
+  Creates a new object containing only the specified keys
+  from the source object.
+- [`rwd`](#rwd):
+  A responsive web design helper
+  that generates CSS rules for a grid-like layout.
+- [`s`](#s):
+  A lightweight *HyperScript*-style helper
+  for creating and modifying `SVGElement`s
+  (see also [`h`](#h)).
+- [`svgUse`](#svgUse):
+  Shorthand for creating an SVG element
+  with a `<use>` child referencing an icon by ID.
+- [`uuidV1`](#uuidV1):
+  Generates a UUID v1 (time-based) identifier.
+- [`vivify`](#vivify):
+  A Proxy-based helper for auto-vivification
+  of nested object structures.
 
 ### CNode
 
@@ -84,7 +139,8 @@ type CNode = {
 };
 ```
 
-Represents a CSS rule node for the [`c`](#c) helper. Keys are CSS properties or nested selectors.
+Represents a CSS rule node for the [`c`](#c) helper.
+Keys are CSS properties or nested selectors.
 
 ### CRoot
 
@@ -92,7 +148,8 @@ Represents a CSS rule node for the [`c`](#c) helper. Keys are CSS properties or
 type CRoot = Record<PropertyKey, CNode>;
 ```
 
-Represents the root CSS object for the [`c`](#c) helper. Keys are top-level selectors or at-rules.
+Represents the root CSS object for the [`c`](#c) helper.
+Keys are top-level selectors or at-rules.
 
 ### HArgs
 
@@ -100,7 +157,8 @@ Represents the root CSS object for the [`c`](#c) helper. Keys are top-level sele
 type HArgs = [string | Node, ...HArgs1[]];
 ```
 
-Tuple argument type for the [`h`](#h) and [`s`](#s) helpers.
+Tuple argument type for the [`h`](#h) and [`s`](#s)
+helpers.
 
 ### HArgs1
 
@@ -108,7 +166,8 @@ Tuple argument type for the [`h`](#h) and [`s`](#s) helpers.
 type HArgs1 = Record<PropertyKey, unknown> | null | undefined | Node | string | number | HArgs;
 ```
 
-Single argument type for the [`h`](#h) and [`s`](#s) helpers.
+Single argument type for the [`h`](#h) and [`s`](#s)
+helpers.
 
 ### c
 
@@ -116,17 +175,22 @@ Single argument type for the [`h`](#h) and [`s`](#s) helpers.
 const c: (root: CRoot, splitter?: string) => string;
 ```
 
-A minimal CSS-in-JS helper that converts a JavaScript object hierarchy into a CSS string.
+A minimal CSS-in-JS helper
+that converts a JavaScript object hierarchy
+into a CSS string.
 
 #### root
 
 An object describing CSS rules.
-Keys are selectors or at-rules; values are either CSS property values or nested rule objects.
+Keys are selectors or at-rules;
+values are either CSS property values
+or nested rule objects.
 
 #### splitter
 
 A delimiter used to create unique keys (default: `'$$'`).
-The substring from `splitter` to the end of a key is ignored (e.g., `src$$1` → `src`).
+The substring from `splitter` to the end of a key
+is ignored (e.g., `src$$1` → `src`).
 
 #### Returns
 
@@ -134,24 +198,33 @@ A CSS string representing the compiled rules.
 
 #### Remarks
 
-- Keys whose values are primitives (`string` | `number`) are treated as CSS properties.
-- In property keys, uppercase letters become lowercase with a `-` prefix (e.g., `fontFamily` → `font-family`);
-  underscores become hyphens (e.g., `font_family` → `font-family`).
-- Comma-separated selector keys expand into multiple selectors
-  (e.g., `{ div: { '.a,.b': { margin: 1 } } }` → `div.a,div.b{margin:1}`).
-- Top-level keys starting with `@` (at-rules) are not concatenated with child selectors.
+- Keys whose values are primitives (`string` | `number`)
+  are treated as CSS properties.
+- In property keys, uppercase letters
+  become lowercase with a `-` prefix
+  (e.g., `fontFamily` → `font-family`);
+  underscores become hyphens
+  (e.g., `font_family` → `font-family`).
+- Comma-separated selector keys
+  expand into multiple selectors
+  (e.g., `{ div: { '.a,.b': { margin: 1 } } }` →
+  `div.a,div.b{margin:1}`).
+- Top-level keys starting with `@` (at-rules)
+  are not concatenated with child selectors.
 
 #### Usage Examples
 
 ```ts
-const actual1 = c({
-  a: {
-    color: 'red',
-    margin: 1,
-    '.c': { margin: 2, padding: 2 },
-    padding: 1,
+const actual1 = c(
+  {
+    a: {
+      color: 'red',
+      margin: 1,
+      '.c': { margin: 2, padding: 2 },
+      padding: 1,
+    },
   },
-})
+)
 
 const expected1 = `
 a{
@@ -168,16 +241,18 @@ a{
 
 expect(actual1).to.equal(expected1)
 
-const actual2 = c({
-  a: {
-    '.b': {
-      color: 'red',
-      margin: 1,
-      '.c': { margin: 2, padding: 2 },
-      padding: 1,
+const actual2 = c(
+  {
+    a: {
+      '.b': {
+        color: 'red',
+        margin: 1,
+        '.c': { margin: 2, padding: 2 },
+        padding: 1,
+      },
     },
   },
-})
+)
 
 const expected2 = `
 a.b{
@@ -194,34 +269,36 @@ a.b{
 
 expect(actual2).to.equal(expected2)
 
-const actual3 = c({
-  '@font-face$$1': {
-    fontFamily: 'Jackens',
-    src$$1: 'url(otf/jackens.otf)',
-    src$$2: "url(otf/jackens.otf) format('opentype')," +
+const actual3 = c(
+  {
+    '@font-face$$1': {
+      fontFamily: 'Jackens',
+      src$$1: 'url(otf/jackens.otf)',
+      src$$2: "url(otf/jackens.otf) format('opentype')," +
       "url(svg/jackens.svg) format('svg')",
-    font_weight: 'normal',
-    'font-style': 'normal',
-  },
-  '@font-face$$2': {
-    font_family: 'C64',
-    src: 'url(fonts/C64_Pro_Mono-STYLE.woff)',
-  },
-  '@keyframes spin': {
-    '0%': { transform: 'rotate(0deg)' },
-    '100%': { transform: 'rotate(360deg)' },
-  },
-  div: {
-    border: 'solid red 1px',
-    '.c1': { 'background-color': '#000' },
-    ' .c1': { background_color: 'black' },
-    '.c2': { backgroundColor: 'rgb(0,0,0)' },
-  },
-  '@media(min-width:200px)': {
-    div: { margin: 0, padding: 0 },
-    span: { color: '#000' },
+      font_weight: 'normal',
+      'font-style': 'normal',
+    },
+    '@font-face$$2': {
+      font_family: 'C64',
+      src: 'url(fonts/C64_Pro_Mono-STYLE.woff)',
+    },
+    '@keyframes spin': {
+      '0%': { transform: 'rotate(0deg)' },
+      '100%': { transform: 'rotate(360deg)' },
+    },
+    div: {
+      border: 'solid red 1px',
+      '.c1': { 'background-color': '#000' },
+      ' .c1': { background_color: 'black' },
+      '.c2': { backgroundColor: 'rgb(0,0,0)' },
+    },
+    '@media(min-width:200px)': {
+      div: { margin: 0, padding: 0 },
+      span: { color: '#000' },
+    },
   },
-})
+)
 
 const expected3 = `
 @font-face{
@@ -267,16 +344,18 @@ div.c2{
 
 expect(actual3).to.equal(expected3)
 
-const actual4 = c({
-  a: {
-    '.b,.c': {
-      margin: 1,
-      '.d': {
-        margin: 2,
+const actual4 = c(
+  {
+    a: {
+      '.b,.c': {
+        margin: 1,
+        '.d': {
+          margin: 2,
+        },
       },
     },
   },
-})
+)
 
 const expected4 = `
 a.b,a.c{
@@ -288,14 +367,16 @@ a.b.d,a.c.d{
 
 expect(actual4).to.equal(expected4)
 
-const actual5 = c({
-  '.b,.c': {
-    margin: 1,
-    '.d': {
-      margin: 2,
+const actual5 = c(
+  {
+    '.b,.c': {
+      margin: 1,
+      '.d': {
+        margin: 2,
+      },
     },
   },
-})
+)
 
 const expected5 = `
 .b,.c{
@@ -307,14 +388,16 @@ const expected5 = `
 
 expect(actual5).to.equal(expected5)
 
-const actual6 = c({
-  '.a,.b': {
-    margin: 1,
-    '.c,.d': {
-      margin: 2,
+const actual6 = c(
+  {
+    '.a,.b': {
+      margin: 1,
+      '.c,.d': {
+        margin: 2,
+      },
     },
   },
-})
+)
 
 const expected6 = `
 .a,.b{
@@ -333,9 +416,11 @@ expect(actual6).to.equal(expected6)
 const csvParse: (csv: string, separator?: string) => string[][];
 ```
 
-Parses a CSV string into a two-dimensional array of strings.
+Parses a CSV string
+into a two-dimensional array of strings.
 
-Supports quoted fields with escaped double quotes (`""`). Carriage returns are normalized.
+Supports quoted fields with escaped double quotes (`""`).
+Carriage returns are normalized.
 
 #### csv
 
@@ -347,7 +432,8 @@ The field delimiter (default: `','`).
 
 #### Returns
 
-A 2D array where each inner array represents a row of fields.
+A 2D array where each inner array
+represents a row of fields.
 
 #### Usage Examples
 
@@ -361,11 +447,13 @@ yyy",zzz
 
 `
 
-expect(csvParse(text)).to.deep.equal([
-  ['aaa\n"aaa"\naaa', 'bbb', 'ccc,ccc'],
-  ['xxx,xxx', 'yyy\nyyy', 'zzz'],
-  [' 42 ', '42', ' 17'],
-])
+expect(csvParse(text)).to.deep.equal(
+  [
+    ['aaa\n"aaa"\naaa', 'bbb', 'ccc,ccc'],
+    ['xxx,xxx', 'yyy\nyyy', 'zzz'],
+    [' 42 ', '42', ' 17'],
+  ],
+)
 ```
 
 ### fixPlTypography
@@ -374,22 +462,30 @@ expect(csvParse(text)).to.deep.equal([
 const fixPlTypography: (node: Node) => void;
 ```
 
-Applies Polish-specific typographic corrections to a DOM subtree.
+Applies Polish-specific typographic corrections
+to a DOM subtree.
 
-This function prevents orphaned conjunctions (single-letter words like “a”, “i”, “o”, “u”, “w”, “z”)
-from appearing at the end of a line by wrapping them with the following word in a non-breaking span.
-It also inserts zero-width spaces after slashes and dots to allow line breaks.
+This function prevents orphaned conjunctions
+(single-letter words like “a”, “i”, “o”, “u”, “w”, “z”)
+from appearing at the end of a line
+by wrapping them with the following word
+in a non-breaking span.
+It also inserts zero-width spaces
+after slashes and dots to allow line breaks.
 
 #### node
 
-The root DOM node to process. All descendant text nodes are corrected recursively,
-except those inside `IFRAME`, `NOSCRIPT`, `PRE`, `SCRIPT`, `STYLE`, or `TEXTAREA` elements.
+The root DOM node to process.
+All descendant text nodes are corrected recursively,
+except those inside `IFRAME`, `NOSCRIPT`, `PRE`,
+`SCRIPT`, `STYLE`, or `TEXTAREA` elements.
 
 #### Usage Examples
 
 ```ts
 const p = h('p',
-  'Pchnąć w tę łódź jeża lub ośm skrzyń fig (zob. https://pl.wikipedia.org/wiki/Pangram).',
+  'Pchnąć w tę łódź jeża lub ośm skrzyń fig ' +
+  '(zob. https://pl.wikipedia.org/wiki/Pangram).',
   ['br'],
   ['b', 'Zażółć gęślą jaźń.'],
 )
@@ -397,9 +493,13 @@ const p = h('p',
 fixPlTypography(p)
 
 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).' +
-  '<br><b>Zażółć gęślą jaźń.</b>')
+  'Pchnąć ' +
+  '<span style="white-space:nowrap">w </span>' +
+  'tę łódź jeża lub ośm skrzyń fig ' +
+  '(zob. https://\u200Bpl.\u200Bwikipedia.\u200Borg/' +
+  '\u200Bwiki/\u200BPangram).' +
+  '<br>' +
+  '<b>Zażółć gęślą jaźń.</b>')
 ```
 
 ### h
@@ -412,21 +512,28 @@ const h: {
 };
 ```
 
-A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `HTMLElement`s (see also [`s`](#s)).
+A lightweight *HyperScript*-style helper
+for creating and modifying `HTMLElement`s
+(see also [`s`](#s)).
 
 #### tagOrNode
 
-If a `string`, it is treated as the tag name for a new element.
+If a `string`, it is treated as the tag name
+for a new element.
 If a `Node`, that node is modified in place.
 
 #### args
 
 Additional arguments processed as follows:
-- `Object`: maps attributes/properties. Keys starting with `$` set element properties (without the `$` prefix);
-  other keys set attributes via `setAttribute`. A value of `false` removes the attribute.
+- `Object`: maps attributes/properties.
+  Keys starting with `$` set element properties
+  (without the `$` prefix);
+  other keys set attributes via `setAttribute`.
+  A value of `false` removes the attribute.
 - `null`/`undefined`: ignored.
 - `Node`: appended as a child.
-- `string`/`number`: converted to a `Text` node and appended.
+- `string`/`number`: converted to a `Text` node
+  and appended.
 - [`HArgs`](#HArgs) array: processed recursively.
 
 #### Returns
@@ -449,21 +556,32 @@ expect(b.outerHTML).to.equal('<b><i>text</i></b>')
 
 h(i, { $className: 'some class' })
 
-expect(i.outerHTML).to.equal('<i class="some class">text</i>')
-expect(b.outerHTML).to.equal('<b><i class="some class">text</i></b>')
+expect(i.outerHTML)
+  .to.equal('<i class="some class">text</i>')
+expect(b.outerHTML)
+  .to.equal('<b><i class="some class">text</i></b>')
 
-expect(h('span', 'text').outerHTML).to.equal('<span>text</span>')
-expect(h('span', { $innerText: 'text' }).outerHTML).to.equal('<span>text</span>')
+expect(h('span', 'text').outerHTML)
+  .to.equal('<span>text</span>')
+expect(h('span', { $innerText: 'text' }).outerHTML)
+  .to.equal('<span>text</span>')
 
-expect(h('span', '42').outerHTML).to.equal('<span>42</span>')
+expect(h('span', '42').outerHTML)
+  .to.equal('<span>42</span>')
 expect(h('span', 42).outerHTML).to.equal('<span>42</span>')
 
 expect(h('div', { style: 'margin:0;padding:0' }).outerHTML)
   .to.equal('<div style="margin:0;padding:0"></div>')
 expect(h('div', { $style: 'margin:0;padding:0' }).outerHTML)
-  .to.equal('<div style="margin: 0px; padding: 0px;"></div>')
-expect(h('div', { $style: { margin: 0, padding: 0 } }).outerHTML)
-  .to.equal('<div style="margin: 0px; padding: 0px;"></div>')
+  .to.equal(
+    '<div style="margin: 0px; padding: 0px;"></div>',
+  )
+expect(
+  h(
+    'div',
+    { $style: { margin: 0, padding: 0 } },
+  ).outerHTML,
+).to.equal('<div style="margin: 0px; padding: 0px;"></div>')
 
 const input1 = h('input', { value: 42 })
 const input2 = h('input', { $value: '42' })
@@ -474,14 +592,22 @@ expect(input2.value).to.equal('42')
 expect(input1.outerHTML).to.equal('<input value="42">')
 expect(input2.outerHTML).to.equal('<input>')
 
-const checkbox1 = h('input', { type: 'checkbox', checked: true })
-const checkbox2 = h('input', { type: 'checkbox', $checked: true })
+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.outerHTML).to.equal('<input type="checkbox" checked="">')
-expect(checkbox2.outerHTML).to.equal('<input type="checkbox">')
+expect(checkbox1.outerHTML)
+  .to.equal('<input type="checkbox" checked="">')
+expect(checkbox2.outerHTML)
+  .to.equal('<input type="checkbox">')
 
 const div = h('div')
 
@@ -502,11 +628,15 @@ expect(elemWithClass.getAttribute('class')).to.equal('test')
 const elemWithText = h('div', 'initial')
 
 h(elemWithText, ' more')
-expect(elemWithText.outerHTML).to.equal('<div>initial more</div>')
+expect(elemWithText.outerHTML)
+  .to.equal('<div>initial more</div>')
 
-const elemWithNested = h('div', ['span', 'hello'], ['b', 'world'])
+const elemWithNested = h('div',
+  ['span', 'hello'],
+  ['b', 'world'])
 
-expect(elemWithNested.outerHTML).to.equal('<div><span>hello</span><b>world</b></div>')
+expect(elemWithNested.outerHTML)
+  .to.equal('<div><span>hello</span><b>world</b></div>')
 ```
 
 ### hasOwn
@@ -515,7 +645,8 @@ expect(elemWithNested.outerHTML).to.equal('<div><span>hello</span><b>world</b></
 const hasOwn: (ref: unknown, key: unknown) => boolean;
 ```
 
-Checks whether an object has the specified key as its own property.
+Checks whether an object has the specified key
+as its own property.
 
 A null-safe wrapper around `Object.hasOwn`.
 
@@ -529,7 +660,8 @@ The property key to look for.
 
 #### Returns
 
-`true` if `ref` is not nullish and has `key` as an own property, `false` otherwise.
+`true` if `ref` is not nullish
+and has `key` as an own property, `false` otherwise.
 
 #### Usage Examples
 
@@ -584,8 +716,15 @@ The value to check.
 
 ```ts
 expect(isArray([])).to.be.true
-expect(isArray(Object.create({ constructor: Array }))).to.be.false
-expect(isArray(Object.create({ [Symbol.toStringTag]: Array.name }))).to.be.false
+
+const fakeArray1 = Object.create({ constructor: Array })
+
+expect(isArray(fakeArray1)).to.be.false
+
+const fakeArray2 =
+  Object.create({ [Symbol.toStringTag]: Array.name })
+
+expect(isArray(fakeArray2)).to.be.false
 ```
 
 ### isFiniteNumber
@@ -594,7 +733,8 @@ expect(isArray(Object.create({ [Symbol.toStringTag]: Array.name }))).to.be.false
 const isFiniteNumber: (arg: unknown) => arg is number;
 ```
 
-Checks whether the argument is a finite number (excludes `±Infinity` and `NaN`).
+Checks whether the argument is a finite number
+(excludes `±Infinity` and `NaN`).
 
 #### arg
 
@@ -635,7 +775,8 @@ The value to check.
 ```ts
 expect(isInteger(42)).to.be.true
 expect(isInteger(42.00000000000001)).to.be.false
-expect(isInteger(42.000000000000001)).to.be.true // because of loss of precision
+expect(isInteger(42.000000000000001)).to.be.true
+// ^because of loss of precision
 expect(isInteger(Number(42))).to.be.true
 expect(isInteger(new Number(42))).to.be.false
 expect(isInteger(NaN)).to.be.false
@@ -648,7 +789,8 @@ expect(isInteger(Infinity)).to.be.false
 const isNumber: (arg: unknown) => arg is number;
 ```
 
-Checks whether the argument is of type `number` (includes `NaN` and `±Infinity`).
+Checks whether the argument is of type `number`
+(includes `NaN` and `±Infinity`).
 
 #### arg
 
@@ -674,7 +816,8 @@ expect(isNumber(Infinity)).to.be.true
 const isRecord: (arg: unknown) => arg is Record<PropertyKey, unknown>;
 ```
 
-Checks whether the argument is a plain object (not `null` and not an array).
+Checks whether the argument is a plain object
+(not `null` and not an array).
 
 #### arg
 
@@ -690,8 +833,16 @@ The value to check.
 expect(isRecord({})).to.be.true
 expect(isRecord([])).to.be.false
 expect(isRecord(Object.create(null))).to.be.true
-expect(isRecord(Object.create({ constructor: Number }))).to.be.true
-expect(isRecord(Object.create({ [Symbol.toStringTag]: Number.name }))).to.be.true
+
+const fakeNumber1 = Object.create({ constructor: Number })
+
+expect(isRecord(fakeNumber1)).to.be.true
+
+const fakeNumber2 =
+  Object.create({ [Symbol.toStringTag]: Number.name })
+
+expect(isRecord(fakeNumber2)).to.be.true
+
 expect(isRecord(new Number(42))).to.be.true
 expect(isRecord(new String('42'))).to.be.true
 
@@ -730,10 +881,14 @@ expect(isString(new String('42'))).to.be.false
 const jsOnParse: (handlers: Record<PropertyKey, Function>, text: string) => any;
 ```
 
-Parses JSON with support for handler-based value transformation (“JavaScript ON”).
+Parses JSON with support for
+handler-based value transformation (“JavaScript ON”).
 
-Objects with exactly one property whose key exists in `handlers` and whose value is an array
-are replaced by invoking the corresponding handler with the array elements as arguments.
+Objects with exactly one property
+whose key exists in `handlers`
+and whose value is an array
+are replaced by invoking the corresponding handler
+with the array elements as arguments.
 
 #### handlers
 
@@ -780,33 +935,49 @@ const actual1 = jsOnParse(handlers, `[
   }
 ]`)
 
-expect(actual1).to.deep.equal([
-  3,
-  'Hello World!',
-  {
-    nested: 'Hello nested World!',
-    one: 1,
-    two: 2,
-  },
-  'bar',
-  {
-    $foo: ['The parent object does not have exactly one property!'],
-    one: 1,
-    two: 2,
-  },
-])
+expect(actual1).to.deep.equal(
+  [
+    3,
+    'Hello World!',
+    {
+      nested: 'Hello nested World!',
+      one: 1,
+      two: 2,
+    },
+    'bar',
+    {
+      $foo: [
+        'The parent object does not have ' +
+        'exactly one property!',
+      ],
+      one: 1,
+      two: 2,
+    },
+  ],
+)
 
-const actual2 = jsOnParse({ $notFunc: 'handler not being a function' } as any, '{"$notFunc": [1, 2]}')
+const actual2 = jsOnParse(
+  { $notFunc: 'handler not being a function' } as any,
+  '{"$notFunc": [1, 2]}',
+)
 
 expect(actual2).to.deep.equal({ $notFunc: [1, 2] })
 
-const actual3 = jsOnParse(handlers, '{"$unknown_handler_key": [1, 2]}')
+const actual3 = jsOnParse(
+  handlers,
+  '{"$unknown_handler_key": [1, 2]}',
+)
 
-expect(actual3).to.deep.equal({ $unknown_handler_key: [1, 2] })
+expect(actual3)
+  .to.deep.equal({ $unknown_handler_key: [1, 2] })
 
-const actual4 = jsOnParse(handlers, '{"$add": {"not": "array"}}')
+const actual4 = jsOnParse(
+  handlers,
+  '{"$add": {"not": "array"}}',
+)
 
-expect(actual4).to.deep.equal({ $add: { not: 'array' } })
+expect(actual4)
+  .to.deep.equal({ $add: { not: 'array' } })
 ```
 
 ### monokai
@@ -815,7 +986,9 @@ expect(actual4).to.deep.equal({ $add: { not: 'array' } })
 const monokai: CRoot;
 ```
 
-A Monokai-inspired color scheme for use with the [`c`](#c) helper and [`nanolightTs`](#nanolightTs) tokenizer.
+A Monokai-inspired color scheme
+for use with the [`c`](#c) helper
+and [`nanolightTs`](#nanolightTs) tokenizer.
 
 ### nanolightTs
 
@@ -823,7 +996,8 @@ A Monokai-inspired color scheme for use with the [`c`](#c) helper and [`nanoligh
 const nanolightTs: (code: string) => HArgs1[];
 ```
 
-A TypeScript/JavaScript syntax highlighting tokenizer built using [`newTokenizer`](#newTokenizer).
+A TypeScript/JavaScript syntax highlighting tokenizer
+built using [`newTokenizer`](#newTokenizer).
 
 #### code
 
@@ -831,34 +1005,42 @@ The source code string to tokenize.
 
 #### Returns
 
-An array of [`HArgs1`](#HArgs1) elements suitable for rendering with [`h`](#h).
+An array of [`HArgs1`](#HArgs1) elements
+suitable for rendering with [`h`](#h).
 
 #### Usage Examples
 
 ```ts
-const codeJs = "const answerToLifeTheUniverseAndEverything = { 42: 42 }['42'] /* 42 */"
-
-expect(nanolightTs(codeJs)).to.deep.equal([
-  ['span', { class: 'keyword-1' }, 'const'],
-  ' ',
-  ['span', { class: 'identifier-4' }, 'answerToLifeTheUniverseAndEverything'],
-  ' ',
-  ['span', { class: 'operator' }, '='],
-  ' ',
-  ['span', { class: 'punctuation' }, '{'],
-  ' ',
-  ['span', { class: 'number' }, '42'],
-  ['span', { class: 'operator' }, ':'],
-  ' ',
-  ['span', { class: 'number' }, '42'],
-  ' ',
-  ['span', { class: 'punctuation' }, '}'],
-  ['span', { class: 'punctuation' }, '['],
-  ['span', { class: 'string' }, "'42'"],
-  ['span', { class: 'punctuation' }, ']'],
-  ' ',
-  ['span', { class: 'comment' }, '/* 42 */'],
-])
+const codeJs =
+  'const answerToLifeTheUniverseAndEverything = ' +
+  "{ 42: 42 }['42'] /* 42 */"
+
+expect(nanolightTs(codeJs)).to.deep.equal(
+  [
+    ['span', { class: 'keyword-1' }, 'const'],
+    ' ',
+    ['span',
+      { class: 'identifier-4' },
+      'answerToLifeTheUniverseAndEverything',
+    ],
+    ' ',
+    ['span', { class: 'operator' }, '='],
+    ' ',
+    ['span', { class: 'punctuation' }, '{'],
+    ' ',
+    ['span', { class: 'number' }, '42'],
+    ['span', { class: 'operator' }, ':'],
+    ' ',
+    ['span', { class: 'number' }, '42'],
+    ' ',
+    ['span', { class: 'punctuation' }, '}'],
+    ['span', { class: 'punctuation' }, '['],
+    ['span', { class: 'string' }, "'42'"],
+    ['span', { class: 'punctuation' }, ']'],
+    ' ',
+    ['span', { class: 'comment' }, '/* 42 */'],
+  ],
+)
 ```
 
 ### newEscape
@@ -867,15 +1049,18 @@ expect(nanolightTs(codeJs)).to.deep.equal([
 const newEscape: (escapeFn: (value: any) => string) => (template: TemplateStringsArray, ...values: unknown[]) => string;
 ```
 
-Creates a tag function for escaping interpolated values in template literals.
+Creates a tag function
+for escaping interpolated values in template literals.
 
 #### escapeFn
 
-A function that takes a value and returns its escaped string representation.
+A function that takes a value
+and returns its escaped string representation.
 
 #### Returns
 
-A tag function that escapes interpolated values using the provided escape map.
+A tag function that escapes interpolated values
+using the provided escape map.
 
 #### Usage Examples
 
@@ -898,12 +1083,27 @@ const sql = newEscape(escapeFn)
 const actual = sql`
   SELECT *
   FROM table_name
-  WHERE column_name IN (${[true, null, undefined, NaN, Infinity, 42, '42', "4'2", /42/, new Date(323325000000)]})`
+  WHERE column_name IN (
+    ${[
+      true,
+      null,
+      undefined,
+      NaN,
+      Infinity,
+      42,
+      '42',
+      "4'2",
+      /42/,
+      new Date(323325000000),
+    ]}
+  )`
 
 const expected = `
   SELECT *
   FROM table_name
-  WHERE column_name IN (b'1', NULL, NULL, NULL, NULL, 42, '42', '4''2', NULL, '1980-03-31 04:30:00')`
+  WHERE column_name IN (
+    b'1', NULL, NULL, NULL, NULL, 42, '42', '4''2', NULL, '1980-03-31 04:30:00'
+  )`
 
 expect(actual).to.equal(expected)
 ```
@@ -914,14 +1114,20 @@ expect(actual).to.equal(expected)
 const newNounForm: (locale: string, forms: Partial<Record<Intl.LDMLPluralRule, string>>) => (value: number) => string;
 ```
 
-Creates a function that returns the appropriate noun form based on a numeric value using `Intl.PluralRules`.
+Creates a function that
+returns the appropriate noun form
+based on a numeric value using `Intl.PluralRules`.
 
-Different languages have different plural rules. The `Intl.PluralRules` API provides locale-aware plural category selection.
+Different languages have different plural rules.
+The `Intl.PluralRules` API provides locale-aware
+plural category selection.
 Possible categories are:
 
-- `zero`: for zero items (used in some languages like Arabic, Latvian)
+- `zero`: for zero items
+  (used in some languages like Arabic, Latvian)
 - `one`: for singular (e.g., 1 item)
-- `two`: for dual (used in some languages like Arabic, Hebrew)
+- `two`: for dual
+  (used in some languages like Arabic, Hebrew)
 - `few`: for small plurals (e.g., 2-4 in Polish)
 - `many`: for larger plurals (e.g., 5-21 in Polish)
 - `other`: fallback category (used by all languages)
@@ -932,17 +1138,24 @@ A BCP 47 language tag (e.g., `pl`, `en`).
 
 #### forms
 
-An object mapping plural categories to noun forms. Not all categories need to be provided;
-if a category is missing, the function falls back to `other`, then to an empty string.
+An object mapping plural categories to noun forms.
+Not all categories need to be provided;
+if a category is missing,
+the function falls back to `other`,
+then to an empty string.
 
 #### Returns
 
-A function that takes a numeric value and returns the appropriate noun form.
+A function that takes a numeric value
+and returns the appropriate noun form.
 
 #### Usage Examples
 
 ```ts
-const auto = newNounForm('pl', { one: 'auto', few: 'auta', other: 'aut' })
+const auto = newNounForm(
+  'pl',
+  { one: 'auto', few: 'auta', other: 'aut' },
+)
 
 expect(auto(0)).to.equal('aut')
 expect(auto(1)).to.equal('auto')
@@ -970,29 +1183,39 @@ expect(empty(42)).to.equal('')
 const newTokenizer: <M, T>(decorator: (chunk: string, metadata?: M) => T, ...specs: [M, string | RegExp][]) => (code: string) => T[];
 ```
 
-A helper for building simple tokenizers (see also [`nanolightTs`](#nanolightTs)).
+A helper for building simple tokenizers
+(see also [`nanolightTs`](#nanolightTs)).
 
 #### decorator
 
-A function that wraps each matched chunk. It receives the matched text (`chunk`)
-and optionally the `metadata` associated with the pattern that produced the match.
-For unmatched text between patterns, `metadata` is `undefined`.
+A function that wraps each matched chunk.
+It receives the matched text (`chunk`)
+and optionally the `metadata`
+associated with the pattern that produced the match.
+For unmatched text between patterns,
+`metadata` is `undefined`.
 
 #### specs
 
 An array of tuples `[metadata, pattern]` where:
-- `metadata`: arbitrary data (e.g., a CSS class name) passed to `decorator` when the pattern matches.
-- `pattern`: a `string` or `RegExp` to match against the input.
+- `metadata`: arbitrary data (e.g., a CSS class name)
+  passed to `decorator` when the pattern matches.
+- `pattern`: a `string` or `RegExp`
+  to match against the input.
 
 #### Returns
 
-A tokenizer function that accepts a code string and returns an array of decorated tokens.
+A tokenizer function that accepts a code string
+and returns an array of decorated tokens.
 
 #### Remarks
 
-1. Matches starting at an earlier position take precedence.
-2. Among matches at the same position, the longer one wins.
-3. Among matches of the same position and length, the one defined earlier wins.
+1. Matches starting at an earlier position
+   take precedence.
+2. Among matches at the same position,
+   the longer one wins.
+3. Among matches of the same position and length,
+   the one defined earlier wins.
 
 #### Usage Examples
 
@@ -1004,15 +1227,17 @@ const tokenizer1 = newTokenizer(
 )
 const result1 = tokenizer1('if "hello" else "world"')
 
-expect(result1).to.deep.equal([
-  { chunk: 'if', metadata: 'keyword' },
-  { chunk: ' ', metadata: undefined },
-  { chunk: '"hello"', metadata: 'string' },
-  { chunk: ' ', metadata: undefined },
-  { chunk: 'else', metadata: 'keyword' },
-  { chunk: ' ', metadata: undefined },
-  { chunk: '"world"', metadata: 'string' },
-])
+expect(result1).to.deep.equal(
+  [
+    { chunk: 'if', metadata: 'keyword' },
+    { chunk: ' ', metadata: undefined },
+    { chunk: '"hello"', metadata: 'string' },
+    { chunk: ' ', metadata: undefined },
+    { chunk: 'else', metadata: 'keyword' },
+    { chunk: ' ', metadata: undefined },
+    { chunk: '"world"', metadata: 'string' },
+  ],
+)
 
 const tokenizer2 = newTokenizer(
   (chunk, metadata) => `${metadata}:${chunk}`,
@@ -1021,7 +1246,15 @@ const tokenizer2 = newTokenizer(
 )
 const result2 = tokenizer2('aBEGINbENDc')
 
-expect(result2).to.deep.equal(['undefined:a', 'tag:BEGIN', 'undefined:b', 'end:END', 'undefined:c'])
+expect(result2).to.deep.equal(
+  [
+    'undefined:a',
+    'tag:BEGIN',
+    'undefined:b',
+    'end:END',
+    'undefined:c',
+  ],
+)
 
 const tokenizer3 = newTokenizer(
   (chunk) => chunk,
@@ -1037,10 +1270,12 @@ const tokenizer4 = newTokenizer(
 )
 const result4 = tokenizer4('test here')
 
-expect(result4).to.deep.equal([
-  { chunk: 'test', metadata: 'start' },
-  { chunk: ' here', metadata: undefined },
-])
+expect(result4).to.deep.equal(
+  [
+    { chunk: 'test', metadata: 'start' },
+    { chunk: ' here', metadata: undefined },
+  ],
+)
 
 const tokenizer5 = newTokenizer(
   (chunk, metadata) => metadata,
@@ -1078,7 +1313,7 @@ const result8 = tokenizer8('abc')
 expect(result8).to.deep.equal(['abc'])
 
 const tokenizer9 = newTokenizer(
-  (chunk, metadata) => metadata,
+  (_chunk, metadata) => metadata,
   ['a', 'a'],
   ['b', 'b'],
 )
@@ -1093,9 +1328,12 @@ expect(result9).to.deep.equal(['a', 'a', 'b', 'b'])
 const omit: <T, K extends keyof T>(ref: T, keys: unknown[]) => Omit<T, K>;
 ```
 
-Creates a new object excluding the specified keys from the source object.
+Creates a new object excluding the specified keys
+from the source object.
 
-A runtime equivalent of TypeScript’s `Omit<T, K>` utility type. See also [`pick`](#pick).
+A runtime equivalent
+of TypeScript’s `Omit<T, K>` utility type.
+See also [`pick`](#pick).
 
 #### ref
 
@@ -1120,12 +1358,15 @@ expect(omit(ref, ['c'])).to.deep.equal({ a: 42, b: '42' })
 ### pick
 
 ```ts
-const pick: <T, K extends keyof T>(ref: T, keys: K[]) => Pick<T, K>;
+const pick: <T, K extends keyof T>(ref: T, keys: unknown[]) => Pick<T, K>;
 ```
 
-Creates a new object containing only the specified keys from the source object.
+Creates a new object containing only the specified keys
+from the source object.
 
-A runtime equivalent of TypeScript’s `Pick<T, K>` utility type. See also [`omit`](#omit).
+A runtime equivalent
+of TypeScript’s `Pick<T, K>` utility type.
+See also [`omit`](#omit).
 
 #### ref
 
@@ -1144,7 +1385,9 @@ A new object with only the specified keys.
 ```ts
 const ref = { a: 42, b: '42', c: 17 }
 
-expect(pick(ref, ['a', 'b'])).to.deep.equal({ a: 42, b: '42' })
+expect(pick(ref, ['a', 'b'])).to.deep.equal(
+  { a: 42, b: '42' },
+)
 ```
 
 ### rwd
@@ -1153,7 +1396,8 @@ expect(pick(ref, ['a', 'b'])).to.deep.equal({ a: 42, b: '42' })
 const rwd: (root: CRoot, selector: string, cellWidthPx: number, cellHeightPx: number, ...specs: [number, number?, number?][]) => void;
 ```
 
-A responsive web design helper that generates CSS rules for a grid-like layout.
+A responsive web design helper
+that generates CSS rules for a grid-like layout.
 
 #### root
 
@@ -1174,9 +1418,12 @@ The base cell height in pixels.
 #### specs
 
 An array of breakpoint specifications, each a tuple of:
-- `maxWidth`: maximum number of cells per row (defines the viewport breakpoint).
-- `width` (optional, default `1`): number of horizontal cells the element spans.
-- `height` (optional, default `1`): number of vertical cells the element spans.
+- `maxWidth`: maximum number of cells per row
+  (defines the viewport breakpoint).
+- `width` (optional, default `1`):
+  number of horizontal cells the element spans.
+- `height` (optional, default `1`):
+  number of vertical cells the element spans.
 
 #### Usage Examples
 
@@ -1195,34 +1442,36 @@ const style: CRoot = {
 
 rwd(style, '.r6', 200, 50, [6], [3], [1, 1, 2])
 
-expect(style).to.deep.equal({
-  body: {
-    margin: 0,
-  },
-  '.r6': {
-    border: 'solid red 1px',
-    '.no-border': {
-      border: 'none',
+expect(style).to.deep.equal(
+  {
+    body: {
+      margin: 0,
     },
-    boxSizing: 'border-box',
-    display: 'block',
-    float: 'left',
-    width: '100%',
-    height: '100px',
-  },
-  '@media(min-width:600px)': {
     '.r6': {
-      width: 'calc(100% / 3)',
-      height: '50px',
+      border: 'solid red 1px',
+      '.no-border': {
+        border: 'none',
+      },
+      boxSizing: 'border-box',
+      display: 'block',
+      float: 'left',
+      width: '100%',
+      height: '100px',
     },
-  },
-  '@media(min-width:1200px)': {
-    '.r6': {
-      width: 'calc(50% / 3)',
-      height: '50px',
+    '@media(min-width:600px)': {
+      '.r6': {
+        width: 'calc(100% / 3)',
+        height: '50px',
+      },
+    },
+    '@media(min-width:1200px)': {
+      '.r6': {
+        width: 'calc(50% / 3)',
+        height: '50px',
+      },
     },
   },
-})
+)
 ```
 
 ### s
@@ -1235,21 +1484,28 @@ const s: {
 };
 ```
 
-A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `SVGElement`s (see also [`h`](#h)).
+A lightweight *HyperScript*-style helper
+for creating and modifying `SVGElement`s
+(see also [`h`](#h)).
 
 #### tagOrNode
 
-If a `string`, it is treated as the tag name for a new element.
+If a `string`, it is treated as the tag name
+for a new element.
 If a `Node`, that node is modified in place.
 
 #### args
 
 Additional arguments processed as follows:
-- `Object`: maps attributes/properties. Keys starting with `$` set element properties (without the `$` prefix);
-  other keys set attributes via `setAttributeNS`. A value of `false` removes the attribute.
+- `Object`: maps attributes/properties.
+  Keys starting with `$` set element properties
+  (without the `$` prefix);
+  other keys set attributes via `setAttributeNS`.
+  A value of `false` removes the attribute.
 - `null`/`undefined`: ignored.
 - `Node`: appended as a child.
-- `string`/`number`: converted to a `Text` node and appended.
+- `string`/`number`: converted to a `Text` node
+  and appended.
 - [`HArgs`](#HArgs) array: processed recursively.
 
 #### Returns
@@ -1259,25 +1515,28 @@ The created or modified `SVGElement`.
 #### Usage Examples
 
 ```ts
-const svg = s('svg')
+const XLINK_NS = 'http://www.w3.org/1999/xlink'
+
+const svg1 = s('svg', { 'xlink:href': true })
 
-s(svg, { 'xlink:href': true })
-expect(svg.getAttributeNS('http://www.w3.org/1999/xlink', 'href')).to.equal('')
+expect(svg1.getAttributeNS(XLINK_NS, 'href')).to.equal('')
 
-const svg2 = s('svg')
+const svg2 = s('svg', { 'xlink:href': false })
 
-s(svg2, { 'xlink:href': false })
-expect(svg2.getAttributeNS('http://www.w3.org/1999/xlink', 'href')).to.be.null
+expect(svg2.getAttributeNS(XLINK_NS, 'href')).to.be.null
 
-const svg3 = s('svg')
+const svg3 = s(
+  'svg',
+  { 'xlink:href': 'http://example.com' },
+)
 
-s(svg3, { 'xlink:href': 'http://example.com' })
-expect(svg3.getAttributeNS('http://www.w3.org/1999/xlink', 'href')).to.equal('http://example.com')
+expect(svg3.getAttributeNS(XLINK_NS, 'href'))
+  .to.equal('http://example.com')
 
-const svg4 = s('svg')
+const svg4 = s('svg', { 'xlink:title': 42 })
 
-s(svg4, { 'xlink:title': 42 })
-expect(svg4.getAttributeNS('http://www.w3.org/1999/xlink', 'title')).to.equal('42')
+expect(svg4.getAttributeNS(XLINK_NS, 'title'))
+  .to.equal('42')
 ```
 
 ### svgUse
@@ -1286,13 +1545,16 @@ expect(svg4.getAttributeNS('http://www.w3.org/1999/xlink', 'title')).to.equal('4
 const svgUse: (id: string, ...args: HArgs1[]) => SVGSVGElement;
 ```
 
-Shorthand for creating an SVG element with a `<use>` child referencing an icon by ID.
+Shorthand for creating an SVG element
+with a `<use>` child referencing an icon by ID.
 
-Equivalent to: `s('svg', ['use', { 'xlink:href': '#' + id }], ...args)`.
+Equivalent to:
+`s('svg', ['use', { 'xlink:href': '#' + id }], ...args)`.
 
 #### id
 
-The ID of the symbol to reference (without the `#` prefix).
+The ID of the symbol to reference
+(without the `#` prefix).
 
 #### args
 
@@ -1309,40 +1571,55 @@ const XLINK_NS = 'http://www.w3.org/1999/xlink'
 
 const svg = svgUse('icon-home')
 
-expect(svg.tagName).to.equal('SVG')
 expect(svg.children.length).to.equal(1)
 
 const useElement = svg.children[0]
 
-expect(useElement.tagName).to.equal('USE')
-expect(useElement.getAttributeNS(XLINK_NS, 'href')).to.equal('#icon-home')
+expect(useElement.getAttributeNS(XLINK_NS, 'href'))
+  .to.equal('#icon-home')
 
-const svgWithViewBox = svgUse('icon-star', { viewBox: '0 0 24 24' })
+const svgWithViewBox =
+  svgUse('icon-star', { viewBox: '0 0 24 24' })
 
-expect(svgWithViewBox.getAttribute('viewBox')).to.equal('0 0 24 24')
+expect(svgWithViewBox.getAttribute('viewBox'))
+  .to.equal('0 0 24 24')
 
 const useViewBox = svgWithViewBox.children[0]
 
-expect(useViewBox.getAttributeNS(XLINK_NS, 'href')).to.equal('#icon-star')
+expect(useViewBox.getAttributeNS(XLINK_NS, 'href'))
+  .to.equal('#icon-star')
 
-const svgWithClass = svgUse('icon-menu', { class: 'icon-btn' })
+const svgWithClass =
+  svgUse('icon-menu', { class: 'icon-btn' })
+
+expect(svgWithClass.getAttribute('class'))
+  .to.equal('icon-btn')
 
-expect(svgWithClass.getAttribute('class')).to.equal('icon-btn')
 expect(svgWithClass.children.length).to.equal(1)
 
 const useClass = svgWithClass.children[0]
 
-expect(useClass.getAttributeNS(XLINK_NS, 'href')).to.equal('#icon-menu')
+expect(useClass.getAttributeNS(XLINK_NS, 'href'))
+  .to.equal('#icon-menu')
+
+const svgWithMultipleAttrs = svgUse(
+  'icon-settings',
+  { width: 24, height: 24, class: 'icon' },
+)
+
+expect(svgWithMultipleAttrs.getAttribute('width'))
+  .to.equal('24')
 
-const svgWithMultipleAttrs = svgUse('icon-settings', { width: 24, height: 24, class: 'icon' })
+expect(svgWithMultipleAttrs.getAttribute('height'))
+  .to.equal('24')
 
-expect(svgWithMultipleAttrs.getAttribute('width')).to.equal('24')
-expect(svgWithMultipleAttrs.getAttribute('height')).to.equal('24')
-expect(svgWithMultipleAttrs.getAttribute('class')).to.equal('icon')
+expect(svgWithMultipleAttrs.getAttribute('class'))
+  .to.equal('icon')
 
 const useMultiple = svgWithMultipleAttrs.children[0]
 
-expect(useMultiple.getAttributeNS(XLINK_NS, 'href')).to.equal('#icon-settings')
+expect(useMultiple.getAttributeNS(XLINK_NS, 'href'))
+  .to.equal('#icon-settings')
 ```
 
 ### uuidV1
@@ -1355,16 +1632,21 @@ Generates a UUID v1 (time-based) identifier.
 
 #### date
 
-The date to use for the timestamp portion (default: current date/time).
+The date to use for the timestamp portion
+(default: current date/time).
 
 #### node
 
-A hexadecimal `string` for the node portion (default: random).
-Must match `/^[0-9a-f]*$/`; it is trimmed to the last 12 characters and left-padded with zeros if shorter.
+A hexadecimal `string` for the node portion
+(default: random).
+Must match `/^[0-9a-f]*$/`;
+it is trimmed to the last 12 characters
+and left-padded with zeros if shorter.
 
 #### Returns
 
-A UUID v1 `string` in the standard format `xxxxxxxx-xxxx-1xxx-xxxx-xxxxxxxxxxxx`.
+A UUID v1 `string` in the standard format
+`xxxxxxxx-xxxx-1xxx-xxxx-xxxxxxxxxxxx`.
 
 #### Usage Examples
 
@@ -1401,10 +1683,17 @@ for (let i = 1; i <= 22136; ++i) {
   }
 }
 
-expect(uuidV1(new Date(), '000123456789abc').split('-')[4]).to.equal('123456789abc')
-expect(uuidV1(new Date(), '123456789').split('-')[4]).to.equal('000123456789')
+expect(uuidV1(new Date(), '000123456789abc').split('-')[4])
+  .to.equal('123456789abc')
 
-expect(uuidV1(new Date(323325000000)).startsWith('c1399400-9a71-11bd')).to.be.true
+expect(uuidV1(new Date(), '123456789').split('-')[4])
+  .to.equal('000123456789')
+
+expect(
+  uuidV1(new Date(323325000000))
+    .startsWith('c1399400-9a71-11bd'),
+)
+  .to.be.true
 ```
 
 ### vivify
@@ -1413,22 +1702,36 @@ expect(uuidV1(new Date(323325000000)).startsWith('c1399400-9a71-11bd')).to.be.tr
 const vivify: (ref: unknown) => any;
 ```
 
-A Proxy-based helper for auto-vivification of nested object structures.
+A Proxy-based helper for auto-vivification
+of nested object structures.
 
-Accessing, assigning, or deleting any nested property on the returned proxy automatically creates intermediate objects
-(or arrays for numeric-string keys matching `^(0|[1-9]\d*)$`) as needed, allowing deep operations without explicit null checks.
+Accessing, assigning, or deleting any nested property
+on the returned proxy
+automatically creates intermediate objects
+(or arrays for numeric-string keys matching
+`^(0|[1-9]\d*)$`) as needed,
+allowing deep operations without explicit null checks.
 
-Intermediates of the last level in a get-only property chain are NOT auto-created.
-For example, `vivify(ref).one.two` will create `ref.one` as `{}`, but will NOT create `ref.one.two`.
+Intermediates of the last level
+in a get-only property chain are NOT auto-created.
+For example, `vivify(ref).one.two` will create
+`ref.one` as `{}`, but will NOT create `ref.one.two`.
 Only when a deeper access, assignment, or deletion occurs
-(e.g. `delete vivify(ref).one.two.three` or `vivify(ref).one.two.three = 4`) will `ref.one.two` be materialized.
+(e.g. `delete vivify(ref).one.two.three`
+or `vivify(ref).one.two.three = 4`)
+will `ref.one.two` be materialized.
 
-When traversal reaches a primitive value, no auto-creation happens;
+When traversal reaches a primitive value,
+no auto-creation happens;
 the primitive’s own property is returned instead
-(e.g. accessing `.toString.name` on a number yields `'toString'` without modifying the underlying structure).
+(e.g. accessing `.toString.name` on a number yields
+`'toString'` without modifying the underlying structure).
 
-Deletion on a non-existing intermediate path will auto-create intermediates up to the parent of the deleted key
-(e.g. `delete vivify(ref).one.two.three` will create `ref.one.two` as `{}` if it does not exist).
+Deletion on a non-existing intermediate path
+will auto-create intermediates up to the parent
+of the deleted key
+(e.g. `delete vivify(ref).one.two.three`
+will create `ref.one.two` as `{}` if it does not exist).
 
 #### ref
 
@@ -1436,7 +1739,8 @@ The root object to wrap.
 
 #### Returns
 
-A proxy that auto-creates nested objects/arrays on property access.
+A proxy that auto-creates nested objects/arrays
+on property access.
 
 #### Usage Examples
 
@@ -1445,43 +1749,58 @@ const ref: any = {}
 
 vivify(ref).one.two[3][4]
 
-expect(ref).to.deep.equal({
-  one: {
-    two: [undefined, undefined, undefined, []],
+expect(ref).to.deep.equal(
+  {
+    one: {
+      two: [undefined, undefined, undefined, []],
+    },
   },
-})
+)
 
 vivify(ref).one.two[3][4] = 5
 
-expect(ref).to.deep.equal({
-  one: {
-    two: [undefined, undefined, undefined, [undefined, undefined, undefined, undefined, 5]],
+expect(ref).to.deep.equal(
+  {
+    one: {
+      two: [
+        undefined,
+        undefined,
+        undefined,
+        [undefined, undefined, undefined, undefined, 5],
+      ],
+    },
   },
-})
+)
 
 vivify(ref).one.two[3].length = 1
 
-expect(ref).to.deep.equal({
-  one: {
-    two: [undefined, undefined, undefined, [undefined]],
+expect(ref).to.deep.equal(
+  {
+    one: {
+      two: [undefined, undefined, undefined, [undefined]],
+    },
   },
-})
+)
 
 vivify(ref).one.two[3] = 4
 
-expect(ref).to.deep.equal({
-  one: {
-    two: [undefined, undefined, undefined, 4],
+expect(ref).to.deep.equal(
+  {
+    one: {
+      two: [undefined, undefined, undefined, 4],
+    },
   },
-})
+)
 
 expect(vivify(ref).one.two.length).to.equal(4)
 
-expect(ref).to.deep.equal({
-  one: {
-    two: [undefined, undefined, undefined, 4],
+expect(ref).to.deep.equal(
+  {
+    one: {
+      two: [undefined, undefined, undefined, 4],
+    },
   },
-})
+)
 
 vivify(ref).one.two = 3
 
@@ -1495,7 +1814,8 @@ delete vivify(ref).one.two
 
 expect(ref).to.deep.equal({ one: {} })
 
-expect(vivify(ref).one.toString instanceof Function).to.be.true
+expect(vivify(ref).one.toString instanceof Function)
+  .to.be.true
 
 expect(vivify(ref).one.toString.name).to.equal('toString')
 
@@ -1515,11 +1835,14 @@ expect(ref).to.deep.equal({ one: { two: { three: {} } } })
 
 vivify(ref).one.two.three.four = 5
 
-expect(ref).to.deep.equal({ one: { two: { three: { four: 5 } } } })
+expect(ref)
+  .to.deep.equal({ one: { two: { three: { four: 5 } } } })
 
-expect(vivify(ref).one.two.three.four.toString.name).to.equal('toString')
+expect(vivify(ref).one.two.three.four.toString.name)
+  .to.equal('toString')
 
-expect(ref).to.deep.equal({ one: { two: { three: { four: 5 } } } })
+expect(ref)
+  .to.deep.equal({ one: { two: { three: { four: 5 } } } })
 
 const u = undefined