@jackens/nnn 2026.4.14 → 2026.8.24

package/readme.md

@@ -1,6 +1,6 @@
 # nnn
 
-A collection of Jackens’ JavaScript helper utilities (version: `2026.4.14`).
+A collection of Jackens’ JavaScript helper utilities (version: `2026.8.24`).
 
 ## Installation
 
@@ -19,30 +19,29 @@ 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,
-
+  createEscape,
+  createPluralRules,
+  createTokenizer,
+  csvParse,
+  fixPlTypography,
+  h,
+  hasOwn,
+  isArray,
+  isFiniteNumber,
+  isInteger,
+  isNumber,
+  isRecord,
+  isString,
+  jsOnParse,
+  monokai,
+  nanolightTs,
+  omit,
+  pick,
+  rwd,
+  s,
+  svgUse,
+  uuidV1,
+  vivify,
 } from '@jackens/nnn' // or './node_modules/@jackens/nnn/nnn.js'
 ```
 
@@ -62,6 +61,16 @@ vivify,
   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.
@@ -99,17 +108,7 @@ vivify,
   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.
@@ -270,7 +269,8 @@ const actual3 = c({
   '@font-face$$1': {
     fontFamily: 'Jackens',
     src$$1: 'url(otf/jackens.otf)',
-    src$$2: "url(otf/jackens.otf) format('opentype')," +
+    src$$2:
+      "url(otf/jackens.otf) format('opentype')," +
       "url(svg/jackens.svg) format('svg')",
     font_weight: 'normal',
     'font-style': 'normal',
@@ -399,6 +399,294 @@ const expected6 = `
 expect(actual6).to.equal(expected6)
 ```
 
+### createEscape
+
+```ts
+const createEscape: (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 = createEscape(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)
+```
+
+### createPluralRules
+
+```ts
+const createPluralRules: (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)
+
+#### locale
+
+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.
+
+#### Returns
+
+A function that takes a numeric value
+and returns the appropriate noun form.
+
+#### Usage Examples
+
+```ts
+const auto = createPluralRules('pl', {
+  one: 'auto',
+  few: 'auta',
+  other: 'aut',
+})
+
+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 car = createPluralRules('en', {
+  one: 'car',
+  other: 'cars',
+})
+
+expect(car(0)).to.equal('cars')
+expect(car(1)).to.equal('car')
+expect(car(17)).to.equal('cars')
+expect(car(42)).to.equal('cars')
+
+const empty = createPluralRules('en', {})
+
+expect(empty(0)).to.equal('')
+expect(empty(1)).to.equal('')
+expect(empty(17)).to.equal('')
+expect(empty(42)).to.equal('')
+```
+
+### createTokenizer
+
+```ts
+const createTokenizer: <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)).
+
+#### 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`.
+
+#### 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.
+
+#### 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
@@ -470,23 +758,25 @@ except those inside `IFRAME`, `NOSCRIPT`, `PRE`,
 #### Usage Examples
 
 ```ts
-const p = h('p',
+const p = h(
+  'p',
   'Pchnąć w tę łódź jeża lub ośm skrzyń fig ' +
-  '(zob. https://pl.wikipedia.org/wiki/Pangram).',
+    '(zob. https://pl.wikipedia.org/wiki/Pangram).',
   ['br'],
-  ['b', 'Zażółć gęślą jaźń.'],
+  ['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>')
+    '<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
@@ -539,38 +829,46 @@ 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(i.outerHTML).to.equal(
+  '<i class="some class">text</i>'
+)
 
-expect(h('span', 'text').outerHTML)
-  .to.equal('<span>text</span>')
-expect(h('span', { $innerText: 'text' }).outerHTML)
-  .to.equal('<span>text</span>')
+expect(b.outerHTML).to.equal(
+  '<b><i class="some class">text</i></b>'
+)
 
-expect(h('span', '42').outerHTML)
-  .to.equal('<span>42</span>')
-expect(h('span', 42).outerHTML).to.equal('<span>42</span>')
+expect(h('span', 'text').outerHTML).to.equal(
+  '<span>text</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>')
+  h('span', { $innerText: 'text' }).outerHTML
+).to.equal('<span>text</span>')
 
-const input1 = h('input', { value: 42 })
+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')
@@ -579,22 +877,26 @@ 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')
 
@@ -615,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
@@ -708,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
 ```
@@ -735,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
 ```
 
@@ -761,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
 ```
 
@@ -791,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
 ```
 
@@ -818,22 +1140,26 @@ 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 })
+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 { }
+class FooBar {}
 
 expect(isRecord(new FooBar())).to.be.true
 ```
@@ -898,7 +1224,9 @@ const handlers = {
   $foo: () => 'bar',
 }
 
-const actual1 = jsOnParse(handlers, `[
+const actual1 = jsOnParse(
+  handlers,
+  `[
   {
     "$add": [1, 2]
   },
@@ -920,7 +1248,8 @@ const actual1 = jsOnParse(handlers, `[
     "one": 1,
     "two": 2
   }
-]`)
+]`
+)
 
 expect(actual1).to.deep.equal([
   3,
@@ -934,7 +1263,7 @@ expect(actual1).to.deep.equal([
   {
     $foo: [
       'The parent object does not have ' +
-      'exactly one property!',
+        'exactly one property!',
     ],
     one: 1,
     two: 2,
@@ -943,26 +1272,26 @@ expect(actual1).to.deep.equal([
 
 const actual2 = jsOnParse(
   { $notFunc: 'handler not being a function' } as any,
-  '{"$notFunc": [1, 2]}',
+  '{"$notFunc": [1, 2]}'
 )
 
 expect(actual2).to.deep.equal({ $notFunc: [1, 2] })
 
 const actual3 = jsOnParse(
   handlers,
-  '{"$unknown_handler_key": [1, 2]}',
+  '{"$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"}}',
+  '{"$add": {"not": "array"}}'
 )
 
-expect(actual4)
-  .to.deep.equal({ $add: { not: 'array' } })
+expect(actual4).to.deep.equal({ $add: { not: 'array' } })
 ```
 
 ### monokai
@@ -982,7 +1311,7 @@ const nanolightTs: (code: string) => HArgs1[];
 ```
 
 A TypeScript/JavaScript syntax highlighting tokenizer
-built using [`newTokenizer`](#newTokenizer).
+built using [`createTokenizer`](#createTokenizer).
 
 #### code
 
@@ -1003,7 +1332,8 @@ const codeJs =
 expect(nanolightTs(codeJs)).to.deep.equal([
   ['span', { class: 'keyword-1' }, 'const'],
   ' ',
-  ['span',
+  [
+    'span',
     { class: 'identifier-4' },
     'answerToLifeTheUniverseAndEverything',
   ],
@@ -1026,275 +1356,6 @@ expect(nanolightTs(codeJs)).to.deep.equal([
 ])
 ```
 
-### 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)
-
-#### locale
-
-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.
-
-#### Returns
-
-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' },
-)
-
-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 car = newNounForm('en', { one: 'car', other: 'cars' })
-
-expect(car(0)).to.equal('cars')
-expect(car(1)).to.equal('car')
-expect(car(17)).to.equal('cars')
-expect(car(42)).to.equal('cars')
-
-const empty = newNounForm('en', {})
-
-expect(empty(0)).to.equal('')
-expect(empty(1)).to.equal('')
-expect(empty(17)).to.equal('')
-expect(empty(42)).to.equal('')
-```
-
-### newTokenizer
-
-```ts
-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)).
-
-#### 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`.
-
-#### 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.
-
-#### 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 = newTokenizer(
-  (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 = newTokenizer(
-  (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 = newTokenizer(
-  (chunk) => chunk,
-  ['test', /test/],
-)
-const result3 = tokenizer3('')
-
-expect(result3).to.deep.equal([])
-
-const tokenizer4 = newTokenizer(
-  (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 = newTokenizer(
-  (chunk, metadata) => metadata,
-  ['later', /x/],
-  ['earlier', /y/],
-)
-const result5 = tokenizer5('yx')
-
-expect(result5).to.deep.equal(['earlier', 'later'])
-
-const tokenizer6 = newTokenizer(
-  (chunk) => chunk,
-  ['short', 'a'],
-  ['long', 'abc'],
-)
-const result6 = tokenizer6('abc')
-
-expect(result6).to.deep.equal(['abc'])
-
-const tokenizer7 = newTokenizer(
-  (chunk) => chunk,
-  ['empty', ''],
-  ['word', /\w+/],
-)
-const result7 = tokenizer7('hello')
-
-expect(result7).to.deep.equal(['hello'])
-
-const tokenizer8 = newTokenizer(
-  (chunk) => chunk,
-  ['test', /xyz/],
-)
-const result8 = tokenizer8('abc')
-
-expect(result8).to.deep.equal(['abc'])
-
-const tokenizer9 = newTokenizer(
-  (_chunk, metadata) => metadata,
-  ['a', 'a'],
-  ['b', 'b'],
-)
-const result9 = tokenizer9('aabb')
-
-expect(result9).to.deep.equal(['a', 'a', 'b', 'b'])
-```
-
 ### omit
 
 ```ts
@@ -1358,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
@@ -1415,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
@@ -1498,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
@@ -1548,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
@@ -1656,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
@@ -1777,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')
 
@@ -1798,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