@jackens/nnn 2026.4.15 → 2026.8.24

package/readme.md

@@ -1,6 +1,6 @@
 # nnn
 
-A collection of Jackens’ JavaScript helper utilities (version: `2026.4.15`).
+A collection of Jackens’ JavaScript helper utilities (version: `2026.8.24`).
 
 ## Installation
 
@@ -19,6 +19,9 @@ npm i @jackens/nnn
 ```js
 import {
   c,
+  createEscape,
+  createPluralRules,
+  createTokenizer,
   csvParse,
   fixPlTypography,
   h,
@@ -32,9 +35,6 @@ import {
   jsOnParse,
   monokai,
   nanolightTs,
-  newEscape,
-  newNounForm,
-  newTokenizer,
   omit,
   pick,
   rwd,
@@ -61,6 +61,16 @@ import {
   A minimal CSS-in-JS helper
   that converts a JavaScript object hierarchy
   into a CSS string.
+- [`createEscape`](#createEscape):
+  Creates a tag function
+  for escaping interpolated values in template literals.
+- [`createPluralRules`](#createPluralRules):
+  Creates a function that
+  returns the appropriate noun form
+  based on a numeric value using `Intl.PluralRules`.
+- [`createTokenizer`](#createTokenizer):
+  A helper for building simple tokenizers
+  (see also [`nanolightTs`](#nanolightTs)).
 - [`csvParse`](#csvParse):
   Parses a CSV string
   into a two-dimensional array of strings.
@@ -98,17 +108,7 @@ import {
   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)).
+  built using [`createTokenizer`](#createTokenizer).
 - [`omit`](#omit):
   Creates a new object excluding the specified keys
   from the source object.
@@ -215,16 +215,14 @@ A CSS string representing the compiled rules.
 #### 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{
@@ -241,18 +239,16 @@ 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{
@@ -269,36 +265,35 @@ 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{
@@ -344,18 +339,16 @@ 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{
@@ -367,16 +360,14 @@ 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{
@@ -388,16 +379,14 @@ 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{
@@ -410,204 +399,504 @@ const expected6 = `
 expect(actual6).to.equal(expected6)
 ```
 
-### csvParse
+### createEscape
 
 ```ts
-const csvParse: (csv: string, separator?: string) => string[][];
+const createEscape: (escapeFn: (value: any) => string) => (template: TemplateStringsArray, ...values: unknown[]) => string;
 ```
 
-Parses a CSV string
-into a two-dimensional array of strings.
-
-Supports quoted fields with escaped double quotes (`""`).
-Carriage returns are normalized.
-
-#### csv
-
-The CSV string to parse.
+Creates a tag function
+for escaping interpolated values in template literals.
 
-#### separator
+#### escapeFn
 
-The field delimiter (default: `','`).
+A function that takes a value
+and returns its escaped string representation.
 
 #### Returns
 
-A 2D array where each inner array
-represents a row of fields.
+A tag function that escapes interpolated values
+using the provided escape map.
 
 #### Usage Examples
 
 ```ts
-const text = `"aaa
-""aaa""
-aaa",bbb, "ccc,ccc"
-"xxx,xxx", "yyy
-yyy",zzz
- 42 , "42" , 17
+const escapeFn = (value: any): string =>
+  isArray(value)
+    ? value.map(escapeFn).join(', ')
+    : value === true || value === false
+      ? `b'${+value}'`
+      : value instanceof Date
+        ? `'${value
+            .toISOString()
+            .replace(/^(.+)T(.+)\..*$/, '$1 $2')}'`
+        : isFiniteNumber(value)
+          ? `${value}`
+          : isString(value)
+            ? `'${value.replace(/'/g, "''")}'`
+            : 'NULL'
 
-`
+const sql = createEscape(escapeFn)
 
-expect(csvParse(text)).to.deep.equal(
-  [
-    ['aaa\n"aaa"\naaa', 'bbb', 'ccc,ccc'],
-    ['xxx,xxx', 'yyy\nyyy', 'zzz'],
-    [' 42 ', '42', ' 17'],
-  ],
-)
-```
+const actual = sql`
+  SELECT *
+  FROM table_name
+  WHERE column_name IN (
+    ${[
+      true,
+      null,
+      undefined,
+      NaN,
+      Infinity,
+      42,
+      '42',
+      "4'2",
+      /42/,
+      new Date(323325000000),
+    ]}
+  )`
 
-### fixPlTypography
+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'
+  )`
 
-```ts
-const fixPlTypography: (node: Node) => void;
+expect(actual).to.equal(expected)
 ```
 
-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.
-
-#### 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.
-
-#### Usage Examples
+### createPluralRules
 
 ```ts
-const p = h('p',
-  'Pchnąć w tę łódź jeża lub ośm skrzyń fig ' +
-  '(zob. https://pl.wikipedia.org/wiki/Pangram).',
-  ['br'],
-  ['b', 'Zażółć gęślą jaźń.'],
-)
-
-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>')
+const createPluralRules: (locale: string, forms: Partial<Record<Intl.LDMLPluralRule, string>>) => (value: number) => string;
 ```
 
-### h
+Creates a function that
+returns the appropriate noun form
+based on a numeric value using `Intl.PluralRules`.
 
-```ts
-const h: {
-    <T extends keyof HTMLElementTagNameMap>(tag: T, ...args1: HArgs1[]): HTMLElementTagNameMap[T];
-    <N extends Node>(node: N, ...args1: HArgs1[]): N;
-    (tagOrNode: string | Node, ...args1: HArgs1[]): Node;
-};
-```
+Different languages have different plural rules.
+The `Intl.PluralRules` API provides locale-aware
+plural category selection.
+Possible categories are:
 
-A lightweight *HyperScript*-style helper
-for creating and modifying `HTMLElement`s
-(see also [`s`](#s)).
+- `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)
+- `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)
 
-#### tagOrNode
+#### locale
 
-If a `string`, it is treated as the tag name
-for a new element.
-If a `Node`, that node is modified in place.
+A BCP 47 language tag (e.g., `pl`, `en`).
 
-#### args
+#### forms
 
-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.
-- `null`/`undefined`: ignored.
-- `Node`: appended as a child.
-- `string`/`number`: converted to a `Text` node
-  and appended.
-- [`HArgs`](#HArgs) array: processed recursively.
+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
 
-The created or modified `HTMLElement`.
+A function that takes a numeric value
+and returns the appropriate noun form.
 
 #### Usage Examples
 
 ```ts
-const b = h('b')
+const auto = createPluralRules('pl', {
+  one: 'auto',
+  few: 'auta',
+  other: 'aut',
+})
 
-expect(b.outerHTML).to.equal('<b></b>')
+expect(auto(0)).to.equal('aut')
+expect(auto(1)).to.equal('auto')
+expect(auto(17)).to.equal('aut')
+expect(auto(42)).to.equal('auta')
 
-const i = h('i', 'text')
+const car = createPluralRules('en', {
+  one: 'car',
+  other: 'cars',
+})
 
-h(b, i)
+expect(car(0)).to.equal('cars')
+expect(car(1)).to.equal('car')
+expect(car(17)).to.equal('cars')
+expect(car(42)).to.equal('cars')
 
-expect(i.outerHTML).to.equal('<i>text</i>')
-expect(b.outerHTML).to.equal('<b><i>text</i></b>')
+const empty = createPluralRules('en', {})
 
-h(i, { $className: 'some class' })
+expect(empty(0)).to.equal('')
+expect(empty(1)).to.equal('')
+expect(empty(17)).to.equal('')
+expect(empty(42)).to.equal('')
+```
 
-expect(i.outerHTML)
-  .to.equal('<i class="some class">text</i>')
-expect(b.outerHTML)
-  .to.equal('<b><i class="some class">text</i></b>')
+### createTokenizer
 
-expect(h('span', 'text').outerHTML)
-  .to.equal('<span>text</span>')
-expect(h('span', { $innerText: 'text' }).outerHTML)
-  .to.equal('<span>text</span>')
+```ts
+const createTokenizer: <M, T>(decorator: (chunk: string, metadata?: M) => T, ...specs: [M, string | RegExp][]) => (code: string) => T[];
+```
 
-expect(h('span', '42').outerHTML)
-  .to.equal('<span>42</span>')
-expect(h('span', 42).outerHTML).to.equal('<span>42</span>')
+A helper for building simple tokenizers
+(see also [`nanolightTs`](#nanolightTs)).
 
-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>')
+#### decorator
 
-const input1 = h('input', { value: 42 })
-const input2 = h('input', { $value: '42' })
+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`.
 
-expect(input1.value).to.equal('42')
-expect(input2.value).to.equal('42')
+#### specs
 
-expect(input1.outerHTML).to.equal('<input value="42">')
-expect(input2.outerHTML).to.equal('<input>')
+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.
 
-const checkbox1 = h(
-  'input',
-  { type: 'checkbox', checked: true },
+#### Returns
+
+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.
+
+#### Usage Examples
+
+```ts
+const tokenizer1 = createTokenizer(
+  (chunk, metadata) => ({ chunk, metadata }),
+  ['keyword', /\b(if|else|for)\b/],
+  ['string', /"[^"]*"/]
+)
+
+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' },
+])
+
+const tokenizer2 = createTokenizer(
+  (chunk, metadata) => `${metadata}:${chunk}`,
+  ['tag', 'BEGIN'],
+  ['end', 'END']
+)
+
+const result2 = tokenizer2('aBEGINbENDc')
+
+expect(result2).to.deep.equal([
+  'undefined:a',
+  'tag:BEGIN',
+  'undefined:b',
+  'end:END',
+  'undefined:c',
+])
+
+const tokenizer3 = createTokenizer(
+  chunk => chunk,
+  ['test', /test/]
+)
+
+const result3 = tokenizer3('')
+
+expect(result3).to.deep.equal([])
+
+const tokenizer4 = createTokenizer(
+  (chunk, metadata) => ({ chunk, metadata }),
+  ['start', /^test/]
+)
+
+const result4 = tokenizer4('test here')
+
+expect(result4).to.deep.equal([
+  { chunk: 'test', metadata: 'start' },
+  { chunk: ' here', metadata: undefined },
+])
+
+const tokenizer5 = createTokenizer(
+  (chunk, metadata) => metadata,
+  ['later', /x/],
+  ['earlier', /y/]
+)
+
+const result5 = tokenizer5('yx')
+
+expect(result5).to.deep.equal(['earlier', 'later'])
+
+const tokenizer6 = createTokenizer(
+  chunk => chunk,
+  ['short', 'a'],
+  ['long', 'abc']
+)
+
+const result6 = tokenizer6('abc')
+
+expect(result6).to.deep.equal(['abc'])
+
+const tokenizer7 = createTokenizer(
+  chunk => chunk,
+  ['empty', ''],
+  ['word', /\w+/]
+)
+
+const result7 = tokenizer7('hello')
+
+expect(result7).to.deep.equal(['hello'])
+
+const tokenizer8 = createTokenizer(
+  chunk => chunk,
+  ['test', /xyz/]
+)
+
+const result8 = tokenizer8('abc')
+
+expect(result8).to.deep.equal(['abc'])
+
+const tokenizer9 = createTokenizer(
+  (_chunk, metadata) => metadata,
+  ['a', 'a'],
+  ['b', 'b']
+)
+
+const result9 = tokenizer9('aabb')
+
+expect(result9).to.deep.equal(['a', 'a', 'b', 'b'])
+```
+
+### csvParse
+
+```ts
+const csvParse: (csv: string, separator?: string) => string[][];
+```
+
+Parses a CSV string
+into a two-dimensional array of strings.
+
+Supports quoted fields with escaped double quotes (`""`).
+Carriage returns are normalized.
+
+#### csv
+
+The CSV string to parse.
+
+#### separator
+
+The field delimiter (default: `','`).
+
+#### Returns
+
+A 2D array where each inner array
+represents a row of fields.
+
+#### Usage Examples
+
+```ts
+const text = `"aaa
+""aaa""
+aaa",bbb, "ccc,ccc"
+"xxx,xxx", "yyy
+yyy",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
+
+```ts
+const fixPlTypography: (node: Node) => void;
+```
+
+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.
+
+#### 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.
+
+#### 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).',
+  ['br'],
+  ['b', 'Zażółć gęślą jaźń.']
+)
+
+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>'
+)
+```
+
+### h
+
+```ts
+const h: {
+    <T extends keyof HTMLElementTagNameMap>(tag: T, ...args1: HArgs1[]): HTMLElementTagNameMap[T];
+    <N extends Node>(node: N, ...args1: HArgs1[]): N;
+    (tagOrNode: string | Node, ...args1: HArgs1[]): Node;
+};
+```
+
+A lightweight *HyperScript*-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 `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.
+- `null`/`undefined`: ignored.
+- `Node`: appended as a child.
+- `string`/`number`: converted to a `Text` node
+  and appended.
+- [`HArgs`](#HArgs) array: processed recursively.
+
+#### Returns
+
+The created or modified `HTMLElement`.
+
+#### Usage Examples
+
+```ts
+const b = h('b')
+
+expect(b.outerHTML).to.equal('<b></b>')
+
+const i = h('i', 'text')
+
+h(b, i)
+
+expect(i.outerHTML).to.equal('<i>text</i>')
+
+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(h('span', 'text').outerHTML).to.equal(
+  '<span>text</span>'
 )
-const checkbox2 = h(
-  'input',
-  { type: 'checkbox', $checked: true },
+
+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('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>')
+
+const input1 = h('input', { value: 42 })
+const input2 = h('input', { $value: '42' })
+
+expect(input1.value).to.equal('42')
+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,
+})
+
 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')
 
@@ -628,15 +917,20 @@ expect(elemWithClass.getAttribute('class')).to.equal('test')
 const elemWithText = h('div', 'initial')
 
 h(elemWithText, ' more')
-expect(elemWithText.outerHTML)
-  .to.equal('<div>initial more</div>')
 
-const elemWithNested = h('div',
+expect(elemWithText.outerHTML).to.equal(
+  '<div>initial more</div>'
+)
+
+const elemWithNested = h(
+  'div',
   ['span', 'hello'],
-  ['b', 'world'])
+  ['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
@@ -721,8 +1015,9 @@ const fakeArray1 = Object.create({ constructor: Array })
 
 expect(isArray(fakeArray1)).to.be.false
 
-const fakeArray2 =
-  Object.create({ [Symbol.toStringTag]: Array.name })
+const fakeArray2 = Object.create({
+  [Symbol.toStringTag]: Array.name,
+})
 
 expect(isArray(fakeArray2)).to.be.false
 ```
@@ -748,9 +1043,13 @@ The value to check.
 
 ```ts
 expect(isFiniteNumber(42)).to.be.true
+
 expect(isFiniteNumber(Number(42))).to.be.true
+
 expect(isFiniteNumber(new Number(42))).to.be.false
+
 expect(isFiniteNumber(NaN)).to.be.false
+
 expect(isFiniteNumber(Infinity)).to.be.false
 ```
 
@@ -774,12 +1073,18 @@ 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(Number(42))).to.be.true
+
 expect(isInteger(new Number(42))).to.be.false
+
 expect(isInteger(NaN)).to.be.false
+
 expect(isInteger(Infinity)).to.be.false
 ```
 
@@ -804,9 +1109,13 @@ The value to check.
 
 ```ts
 expect(isNumber(42)).to.be.true
+
 expect(isNumber(Number(42))).to.be.true
+
 expect(isNumber(new Number(42))).to.be.false
+
 expect(isNumber(NaN)).to.be.true
+
 expect(isNumber(Infinity)).to.be.true
 ```
 
@@ -831,495 +1140,220 @@ The value to check.
 
 ```ts
 expect(isRecord({})).to.be.true
-expect(isRecord([])).to.be.false
-expect(isRecord(Object.create(null))).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
-
-class FooBar { }
-
-expect(isRecord(new FooBar())).to.be.true
-```
-
-### isString
-
-```ts
-const isString: (arg: unknown) => arg is string;
-```
-
-Checks whether the argument is a string.
-
-#### arg
-
-The value to check.
-
-#### Returns
-
-`true` if `typeof arg === 'string'`, `false` otherwise.
-
-#### Usage Examples
-
-```ts
-expect(isString('42')).to.be.true
-expect(isString(String('42'))).to.be.true
-expect(isString(new String('42'))).to.be.false
-```
-
-### jsOnParse
-
-```ts
-const jsOnParse: (handlers: Record<PropertyKey, Function>, text: string) => any;
-```
-
-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.
-
-#### handlers
-
-An object mapping handler names to functions.
-
-#### text
-
-The JSON string to parse.
-
-#### Returns
-
-The parsed value with handler substitutions applied.
-
-#### Usage Examples
-
-```ts
-const handlers = {
-  $add: (a: number, b: number) => a + b,
-  $hello: (name: string) => `Hello ${name}!`,
-  $foo: () => 'bar',
-}
 
-const actual1 = jsOnParse(handlers, `[
-  {
-    "$add": [1, 2]
-  },
-  {
-    "$hello": ["World"]
-  },
-  {
-    "nested": {
-      "$hello": ["nested World"]
-    },
-    "one": 1,
-    "two": 2
-  },
-  {
-    "$foo": []
-  },
-  {
-    "$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]}',
-)
-
-expect(actual2).to.deep.equal({ $notFunc: [1, 2] })
-
-const actual3 = jsOnParse(
-  handlers,
-  '{"$unknown_handler_key": [1, 2]}',
-)
-
-expect(actual3)
-  .to.deep.equal({ $unknown_handler_key: [1, 2] })
-
-const actual4 = jsOnParse(
-  handlers,
-  '{"$add": {"not": "array"}}',
-)
-
-expect(actual4)
-  .to.deep.equal({ $add: { not: 'array' } })
-```
-
-### monokai
-
-```ts
-const monokai: CRoot;
-```
-
-A Monokai-inspired color scheme
-for use with the [`c`](#c) helper
-and [`nanolightTs`](#nanolightTs) tokenizer.
-
-### nanolightTs
-
-```ts
-const nanolightTs: (code: string) => HArgs1[];
-```
-
-A TypeScript/JavaScript syntax highlighting tokenizer
-built using [`newTokenizer`](#newTokenizer).
-
-#### code
-
-The source code string to tokenize.
-
-#### Returns
-
-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 */'],
-  ],
-)
-```
-
-### newEscape
-
-```ts
-const newEscape: (escapeFn: (value: any) => string) => (template: TemplateStringsArray, ...values: unknown[]) => string;
-```
-
-Creates a tag function
-for escaping interpolated values in template literals.
-
-#### escapeFn
-
-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.
-
-#### Usage Examples
-
-```ts
-const escapeFn = (value: any): string =>
-  isArray(value)
-    ? value.map(escapeFn).join(', ')
-    : value === true || value === false
-      ? `b'${+value}'`
-      : value instanceof Date
-        ? `'${value.toISOString().replace(/^(.+)T(.+)\..*$/, '$1 $2')}'`
-        : isFiniteNumber(value)
-          ? `${value}`
-          : isString(value)
-            ? `'${value.replace(/'/g, "''")}'`
-            : 'NULL'
-
-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),
-    ]}
-  )`
-
-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'
-  )`
-
-expect(actual).to.equal(expected)
-```
-
-### newNounForm
-
-```ts
-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`.
-
-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)
-- `one`: for singular (e.g., 1 item)
-- `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)
+expect(isRecord([])).to.be.false
 
-#### locale
+expect(isRecord(Object.create(null))).to.be.true
 
-A BCP 47 language tag (e.g., `pl`, `en`).
+const fakeNumber1 = Object.create({ constructor: Number })
 
-#### forms
+expect(isRecord(fakeNumber1)).to.be.true
 
-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.
+const fakeNumber2 = Object.create({
+  [Symbol.toStringTag]: Number.name,
+})
 
-#### Returns
+expect(isRecord(fakeNumber2)).to.be.true
 
-A function that takes a numeric value
-and returns the appropriate noun form.
+expect(isRecord(new Number(42))).to.be.true
 
-#### Usage Examples
+expect(isRecord(new String('42'))).to.be.true
+
+class FooBar {}
+
+expect(isRecord(new FooBar())).to.be.true
+```
+
+### isString
 
 ```ts
-const auto = newNounForm(
-  'pl',
-  { one: 'auto', few: 'auta', other: 'aut' },
-)
+const isString: (arg: unknown) => arg is string;
+```
 
-expect(auto(0)).to.equal('aut')
-expect(auto(1)).to.equal('auto')
-expect(auto(17)).to.equal('aut')
-expect(auto(42)).to.equal('auta')
+Checks whether the argument is a string.
 
-const car = newNounForm('en', { one: 'car', other: 'cars' })
+#### arg
 
-expect(car(0)).to.equal('cars')
-expect(car(1)).to.equal('car')
-expect(car(17)).to.equal('cars')
-expect(car(42)).to.equal('cars')
+The value to check.
 
-const empty = newNounForm('en', {})
+#### Returns
 
-expect(empty(0)).to.equal('')
-expect(empty(1)).to.equal('')
-expect(empty(17)).to.equal('')
-expect(empty(42)).to.equal('')
-```
+`true` if `typeof arg === 'string'`, `false` otherwise.
 
-### newTokenizer
+#### Usage Examples
 
 ```ts
-const newTokenizer: <M, T>(decorator: (chunk: string, metadata?: M) => T, ...specs: [M, string | RegExp][]) => (code: string) => T[];
+expect(isString('42')).to.be.true
+expect(isString(String('42'))).to.be.true
+expect(isString(new String('42'))).to.be.false
 ```
 
-A helper for building simple tokenizers
-(see also [`nanolightTs`](#nanolightTs)).
+### jsOnParse
 
-#### decorator
+```ts
+const jsOnParse: (handlers: Record<PropertyKey, Function>, text: string) => any;
+```
 
-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`.
+Parses JSON with support for
+handler-based value transformation (“JavaScript ON”).
 
-#### specs
+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.
 
-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.
+#### handlers
 
-#### Returns
+An object mapping handler names to functions.
 
-A tokenizer function that accepts a code string
-and returns an array of decorated tokens.
+#### text
 
-#### Remarks
+The JSON string to parse.
 
-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.
+#### Returns
+
+The parsed value with handler substitutions applied.
 
 #### Usage Examples
 
 ```ts
-const tokenizer1 = newTokenizer(
-  (chunk, metadata) => ({ chunk, metadata }),
-  ['keyword', /\b(if|else|for)\b/],
-  ['string', /"[^"]*"/],
-)
-const result1 = tokenizer1('if "hello" else "world"')
+const handlers = {
+  $add: (a: number, b: number) => a + b,
+  $hello: (name: string) => `Hello ${name}!`,
+  $foo: () => 'bar',
+}
 
-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 actual1 = jsOnParse(
+  handlers,
+  `[
+  {
+    "$add": [1, 2]
+  },
+  {
+    "$hello": ["World"]
+  },
+  {
+    "nested": {
+      "$hello": ["nested World"]
+    },
+    "one": 1,
+    "two": 2
+  },
+  {
+    "$foo": []
+  },
+  {
+    "$foo": ["The parent object does not have exactly one property!"],
+    "one": 1,
+    "two": 2
+  }
+]`
 )
 
-const tokenizer2 = newTokenizer(
-  (chunk, metadata) => `${metadata}:${chunk}`,
-  ['tag', 'BEGIN'],
-  ['end', 'END'],
-)
-const result2 = tokenizer2('aBEGINbENDc')
+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(result2).to.deep.equal(
-  [
-    'undefined:a',
-    'tag:BEGIN',
-    'undefined:b',
-    'end:END',
-    'undefined:c',
-  ],
+const actual2 = jsOnParse(
+  { $notFunc: 'handler not being a function' } as any,
+  '{"$notFunc": [1, 2]}'
 )
 
-const tokenizer3 = newTokenizer(
-  (chunk) => chunk,
-  ['test', /test/],
+expect(actual2).to.deep.equal({ $notFunc: [1, 2] })
+
+const actual3 = jsOnParse(
+  handlers,
+  '{"$unknown_handler_key": [1, 2]}'
 )
-const result3 = tokenizer3('')
 
-expect(result3).to.deep.equal([])
+expect(actual3).to.deep.equal({
+  $unknown_handler_key: [1, 2],
+})
 
-const tokenizer4 = newTokenizer(
-  (chunk, metadata) => ({ chunk, metadata }),
-  ['start', /^test/],
+const actual4 = jsOnParse(
+  handlers,
+  '{"$add": {"not": "array"}}'
 )
-const result4 = tokenizer4('test here')
 
-expect(result4).to.deep.equal(
-  [
-    { chunk: 'test', metadata: 'start' },
-    { chunk: ' here', metadata: undefined },
-  ],
-)
+expect(actual4).to.deep.equal({ $add: { not: 'array' } })
+```
 
-const tokenizer5 = newTokenizer(
-  (chunk, metadata) => metadata,
-  ['later', /x/],
-  ['earlier', /y/],
-)
-const result5 = tokenizer5('yx')
+### monokai
 
-expect(result5).to.deep.equal(['earlier', 'later'])
+```ts
+const monokai: CRoot;
+```
 
-const tokenizer6 = newTokenizer(
-  (chunk) => chunk,
-  ['short', 'a'],
-  ['long', 'abc'],
-)
-const result6 = tokenizer6('abc')
+A Monokai-inspired color scheme
+for use with the [`c`](#c) helper
+and [`nanolightTs`](#nanolightTs) tokenizer.
 
-expect(result6).to.deep.equal(['abc'])
+### nanolightTs
 
-const tokenizer7 = newTokenizer(
-  (chunk) => chunk,
-  ['empty', ''],
-  ['word', /\w+/],
-)
-const result7 = tokenizer7('hello')
+```ts
+const nanolightTs: (code: string) => HArgs1[];
+```
 
-expect(result7).to.deep.equal(['hello'])
+A TypeScript/JavaScript syntax highlighting tokenizer
+built using [`createTokenizer`](#createTokenizer).
 
-const tokenizer8 = newTokenizer(
-  (chunk) => chunk,
-  ['test', /xyz/],
-)
-const result8 = tokenizer8('abc')
+#### code
 
-expect(result8).to.deep.equal(['abc'])
+The source code string to tokenize.
 
-const tokenizer9 = newTokenizer(
-  (_chunk, metadata) => metadata,
-  ['a', 'a'],
-  ['b', 'b'],
-)
-const result9 = tokenizer9('aabb')
+#### Returns
 
-expect(result9).to.deep.equal(['a', 'a', 'b', 'b'])
+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 */'],
+])
 ```
 
 ### omit
@@ -1385,9 +1419,10 @@ 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
@@ -1442,36 +1477,34 @@ const style: CRoot = {
 
 rwd(style, '.r6', 200, 50, [6], [3], [1, 1, 2])
 
-expect(style).to.deep.equal(
-  {
-    body: {
-      margin: 0,
+expect(style).to.deep.equal({
+  body: {
+    margin: 0,
+  },
+  '.r6': {
+    border: 'solid red 1px',
+    '.no-border': {
+      border: 'none',
     },
+    boxSizing: 'border-box',
+    display: 'block',
+    float: 'left',
+    width: '100%',
+    height: '100px',
+  },
+  '@media(min-width:600px)': {
     '.r6': {
-      border: 'solid red 1px',
-      '.no-border': {
-        border: 'none',
-      },
-      boxSizing: 'border-box',
-      display: 'block',
-      float: 'left',
-      width: '100%',
-      height: '100px',
-    },
-    '@media(min-width:600px)': {
-      '.r6': {
-        width: 'calc(100% / 3)',
-        height: '50px',
-      },
+      width: 'calc(100% / 3)',
+      height: '50px',
     },
-    '@media(min-width:1200px)': {
-      '.r6': {
-        width: 'calc(50% / 3)',
-        height: '50px',
-      },
+  },
+  '@media(min-width:1200px)': {
+    '.r6': {
+      width: 'calc(50% / 3)',
+      height: '50px',
     },
   },
-)
+})
 ```
 
 ### s
@@ -1525,18 +1558,19 @@ const svg2 = s('svg', { 'xlink:href': false })
 
 expect(svg2.getAttributeNS(XLINK_NS, 'href')).to.be.null
 
-const svg3 = s(
-  'svg',
-  { 'xlink:href': 'http://example.com' },
-)
+const svg3 = s('svg', {
+  'xlink:href': 'http://example.com',
+})
 
-expect(svg3.getAttributeNS(XLINK_NS, 'href'))
-  .to.equal('http://example.com')
+expect(svg3.getAttributeNS(XLINK_NS, 'href')).to.equal(
+  'http://example.com'
+)
 
 const svg4 = s('svg', { 'xlink:title': 42 })
 
-expect(svg4.getAttributeNS(XLINK_NS, 'title'))
-  .to.equal('42')
+expect(svg4.getAttributeNS(XLINK_NS, 'title')).to.equal(
+  '42'
+)
 ```
 
 ### svgUse
@@ -1575,51 +1609,63 @@ expect(svg.children.length).to.equal(1)
 
 const useElement = svg.children[0]
 
-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')
-
-const svgWithMultipleAttrs = svgUse(
-  'icon-settings',
-  { width: 24, height: 24, class: 'icon' },
+expect(useClass.getAttributeNS(XLINK_NS, 'href')).to.equal(
+  '#icon-menu'
 )
 
-expect(svgWithMultipleAttrs.getAttribute('width'))
-  .to.equal('24')
+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('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
@@ -1683,17 +1729,19 @@ for (let i = 1; i <= 22136; ++i) {
   }
 }
 
-expect(uuidV1(new Date(), '000123456789abc').split('-')[4])
-  .to.equal('123456789abc')
+expect(
+  uuidV1(new Date(), '000123456789abc').split('-')[4]
+).to.equal('123456789abc')
 
-expect(uuidV1(new Date(), '123456789').split('-')[4])
-  .to.equal('000123456789')
+expect(
+  uuidV1(new Date(), '123456789').split('-')[4]
+).to.equal('000123456789')
 
 expect(
-  uuidV1(new Date(323325000000))
-    .startsWith('c1399400-9a71-11bd'),
-)
-  .to.be.true
+  uuidV1(new Date(323325000000)).startsWith(
+    'c1399400-9a71-11bd'
+  )
+).to.be.true
 ```
 
 ### vivify
@@ -1749,58 +1797,48 @@ 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
 
@@ -1814,8 +1852,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')
 
@@ -1835,14 +1873,17 @@ 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