@jackens/nnn 2026.4.12 → 2026.4.14

package/readme.md

@@ -1,6 +1,6 @@
 # nnn
 
-A collection of Jackens’ JavaScript helper utilities (version: `2026.4.12`).
+A collection of Jackens’ JavaScript helper utilities (version: `2026.4.14`).
 
 ## Installation
 
@@ -19,62 +19,118 @@ npm i @jackens/nnn
 ```js
 import {
   c,
-  csvParse,
-  fixPlTypography,
-  h,
-  hasOwn,
-  isArray,
-  isFiniteNumber,
-  isInteger,
-  isNumber,
-  isRecord,
-  isString,
-  jsOnParse,
-  monokai,
-  nanolightTs,
-  newEscape,
-  newNounForm,
-  newTokenizer,
-  omit,
-  pick,
-  rwd,
-  s,
-  svgUse,
-  uuidV1,
-  vivify
+csvParse,
+fixPlTypography,
+h,
+hasOwn,
+isArray,
+isFiniteNumber,
+isInteger,
+isNumber,
+isRecord,
+isString,
+jsOnParse,
+monokai,
+nanolightTs,
+newEscape,
+newNounForm,
+newTokenizer,
+omit,
+pick,
+rwd,
+s,
+svgUse,
+uuidV1,
+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 +140,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 +149,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 +158,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 +167,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 +176,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,12 +199,19 @@ 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
 
@@ -333,9 +405,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 +421,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
 
@@ -374,22 +449,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 +480,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 +499,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 +543,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 +579,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 +615,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 +632,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 +647,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 +703,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 +720,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 +762,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 +776,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 +803,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 +820,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 +868,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
 
@@ -790,23 +932,37 @@ expect(actual1).to.deep.equal([
   },
   'bar',
   {
-    $foo: ['The parent object does not have exactly one property!'],
+    $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 +971,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 +981,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,17 +990,23 @@ 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 */"
+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: 'identifier-4' },
+    'answerToLifeTheUniverseAndEverything',
+  ],
   ' ',
   ['span', { class: 'operator' }, '='],
   ' ',
@@ -867,15 +1032,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,7 +1066,18 @@ 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 *
@@ -914,14 +1093,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 +1117,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 +1162,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
 
@@ -1021,7 +1223,13 @@ 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,
@@ -1078,7 +1286,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 +1301,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 +1331,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 +1358,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 +1369,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 +1391,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 +1415,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 +1457,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 +1488,28 @@ The created or modified `SVGElement`.
 #### Usage Examples
 
 ```ts
-const svg = s('svg')
+const XLINK_NS = 'http://www.w3.org/1999/xlink'
 
-s(svg, { 'xlink:href': true })
-expect(svg.getAttributeNS('http://www.w3.org/1999/xlink', 'href')).to.equal('')
+const svg1 = s('svg', { 'xlink:href': true })
 
-const svg2 = s('svg')
+expect(svg1.getAttributeNS(XLINK_NS, 'href')).to.equal('')
 
-s(svg2, { 'xlink:href': false })
-expect(svg2.getAttributeNS('http://www.w3.org/1999/xlink', 'href')).to.be.null
+const svg2 = s('svg', { 'xlink:href': false })
 
-const svg3 = s('svg')
+expect(svg2.getAttributeNS(XLINK_NS, 'href')).to.be.null
 
-s(svg3, { 'xlink:href': 'http://example.com' })
-expect(svg3.getAttributeNS('http://www.w3.org/1999/xlink', 'href')).to.equal('http://example.com')
+const svg3 = s(
+  'svg',
+  { 'xlink:href': '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 +1518,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 +1544,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' })
+const svgWithMultipleAttrs = svgUse(
+  'icon-settings',
+  { width: 24, height: 24, class: 'icon' },
+)
+
+expect(svgWithMultipleAttrs.getAttribute('width'))
+  .to.equal('24')
+
+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 +1605,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 +1656,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 +1675,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 +1712,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
 
@@ -1455,7 +1732,12 @@ vivify(ref).one.two[3][4] = 5
 
 expect(ref).to.deep.equal({
   one: {
-    two: [undefined, undefined, undefined, [undefined, undefined, undefined, undefined, 5]],
+    two: [
+      undefined,
+      undefined,
+      undefined,
+      [undefined, undefined, undefined, undefined, 5],
+    ],
   },
 })
 
@@ -1495,7 +1777,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 +1798,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