@jackens/nnn 2026.4.15 → 2026.8.31

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.31`).
 
 ## Installation
 
@@ -19,6 +19,8 @@ npm i @jackens/nnn
 ```js
 import {
   c,
+  createEscape,
+  createTokenizer,
   csvParse,
   fixPlTypography,
   h,
@@ -32,9 +34,6 @@ import {
   jsOnParse,
   monokai,
   nanolightTs,
-  newEscape,
-  newNounForm,
-  newTokenizer,
   omit,
   pick,
   rwd,
@@ -61,6 +60,12 @@ 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.
+- [`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 +103,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 +210,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 +234,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 +260,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 +334,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 +355,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 +374,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,6 +394,221 @@ 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)
+```
+
+### 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
@@ -447,13 +646,11 @@ yyy",zzz
 
 `
 
-expect(csvParse(text)).to.deep.equal(
-  [
-    ['aaa\n"aaa"\naaa', 'bbb', 'ccc,ccc'],
-    ['xxx,xxx', 'yyy\nyyy', 'zzz'],
-    [' 42 ', '42', ' 17'],
-  ],
-)
+expect(csvParse(text)).to.deep.equal([
+  ['aaa\n"aaa"\naaa', 'bbb', 'ccc,ccc'],
+  ['xxx,xxx', 'yyy\nyyy', 'zzz'],
+  [' 42 ', '42', ' 17'],
+])
 ```
 
 ### fixPlTypography
@@ -483,23 +680,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
@@ -552,35 +751,43 @@ 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(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,
+  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 })
@@ -592,22 +799,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')
 
@@ -628,15 +839,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 +937,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 +965,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 +995,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 +1031,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,22 +1062,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
 ```
@@ -911,7 +1146,9 @@ const handlers = {
   $foo: () => 'bar',
 }
 
-const actual1 = jsOnParse(handlers, `[
+const actual1 = jsOnParse(
+  handlers,
+  `[
   {
     "$add": [1, 2]
   },
@@ -933,51 +1170,50 @@ const actual1 = jsOnParse(handlers, `[
     "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 ' +
+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,
-    },
-  ],
-)
+    ],
+    one: 1,
+    two: 2,
+  },
+])
 
 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
@@ -997,7 +1233,7 @@ const nanolightTs: (code: string) => HArgs1[];
 ```
 
 A TypeScript/JavaScript syntax highlighting tokenizer
-built using [`newTokenizer`](#newTokenizer).
+built using [`createTokenizer`](#createTokenizer).
 
 #### code
 
@@ -1015,311 +1251,31 @@ const codeJs =
   'const answerToLifeTheUniverseAndEverything = ' +
   "{ 42: 42 }['42'] /* 42 */"
 
-expect(nanolightTs(codeJs)).to.deep.equal(
+expect(nanolightTs(codeJs)).to.deep.equal([
+  ['span', { class: 'keyword-1' }, 'const'],
+  ' ',
   [
-    ['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 */'],
+    'span',
+    { class: 'identifier-4' },
+    'answerToLifeTheUniverseAndEverything',
   ],
-)
-```
-
-### 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'])
+  ' ',
+  ['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 +1341,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 +1399,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 +1480,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 +1531,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 +1651,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 +1719,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 +1774,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 +1795,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