@jackens/nnn 2026.8.31 → 2026.9.2

package/readme.md

@@ -1,6 +1,6 @@
 # nnn
 
-A collection of Jackens’ JavaScript helper utilities (version: `2026.8.31`).
+A collection of Jackens’ JavaScript helper utilities (version: `2026.9.2`).
 
 ## Installation
 
@@ -24,18 +24,8 @@ import {
   csvParse,
   fixPlTypography,
   h,
-  hasOwn,
-  isArray,
-  isFiniteNumber,
-  isInteger,
-  isNumber,
-  isRecord,
-  isString,
-  jsOnParse,
   monokai,
   nanolightTs,
-  omit,
-  pick,
   rwd,
   s,
   svgUse,
@@ -47,9 +37,8 @@ import {
 ## Exports
 
 - [`CNode`](#CNode):
-  Represents a CSS rule node for the [`c`](#c) helper.
-- [`CRoot`](#CRoot):
-  Represents the root CSS object for the [`c`](#c) helper.
+  Represents a CSS rule node for the [`c`](#c) helper. Keys
+  are CSS properties or nested selectors.
 - [`HArgs`](#HArgs):
   Tuple argument type for the [`h`](#h) and [`s`](#s)
   helpers.
@@ -57,74 +46,43 @@ import {
   Single argument type for the [`h`](#h) and [`s`](#s)
   helpers.
 - [`c`](#c):
-  A minimal CSS-in-JS helper
-  that converts a JavaScript object hierarchy
-  into a CSS string.
+  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.
+  Creates a tag function for escaping interpolated values
+  in template literals.
 - [`createTokenizer`](#createTokenizer):
-  A helper for building simple tokenizers
-  (see also [`nanolightTs`](#nanolightTs)).
+  A helper for building simple tokenizers (see also
+  [`nanolightTs`](#nanolightTs)).
 - [`csvParse`](#csvParse):
-  Parses a CSV string
-  into a two-dimensional array of strings.
+  Parses a CSV string into a two-dimensional array of
+  strings.
 - [`fixPlTypography`](#fixPlTypography):
-  Applies Polish-specific typographic corrections
-  to a DOM subtree.
+  Applies Polish-specific typographic corrections to a DOM
+  subtree.
 - [`h`](#h):
-  A lightweight *HyperScript*-style helper
-  for creating and modifying `HTMLElement`s
-  (see also [`s`](#s)).
-- [`hasOwn`](#hasOwn):
-  Checks whether an object has the specified key
-  as its own property.
-- [`isArray`](#isArray):
-  Checks whether the argument is an array.
-- [`isFiniteNumber`](#isFiniteNumber):
-  Checks whether the argument is a finite number
-  (excludes `±Infinity` and `NaN`).
-- [`isInteger`](#isInteger):
-  Checks whether the argument is an integer number.
-- [`isNumber`](#isNumber):
-  Checks whether the argument is of type `number`
-  (includes `NaN` and `±Infinity`).
-- [`isRecord`](#isRecord):
-  Checks whether the argument is a plain object
-  (not `null` and not an array).
-- [`isString`](#isString):
-  Checks whether the argument is a string.
-- [`jsOnParse`](#jsOnParse):
-  Parses JSON with support for
-  handler-based value transformation (“JavaScript ON”).
+  A lightweight _HyperScript_-style helper for creating and
+  modifying `HTMLElement`s (see also [`s`](#s)).
 - [`monokai`](#monokai):
-  A Monokai-inspired color scheme
-  for use with the [`c`](#c) helper
-  and [`nanolightTs`](#nanolightTs) tokenizer.
+  A Monokai-inspired color scheme for use with the [`c`](#c)
+  helper and [`nanolightTs`](#nanolightTs) tokenizer.
 - [`nanolightTs`](#nanolightTs):
   A TypeScript/JavaScript syntax highlighting tokenizer
   built using [`createTokenizer`](#createTokenizer).
-- [`omit`](#omit):
-  Creates a new object excluding the specified keys
-  from the source object.
-- [`pick`](#pick):
-  Creates a new object containing only the specified keys
-  from the source object.
 - [`rwd`](#rwd):
-  A responsive web design helper
-  that generates CSS rules for a grid-like layout.
+  A responsive web design helper that generates CSS rules
+  for a grid-like layout.
 - [`s`](#s):
-  A lightweight *HyperScript*-style helper
-  for creating and modifying `SVGElement`s
-  (see also [`h`](#h)).
+  A lightweight _HyperScript_-style helper for creating and
+  modifying `SVGElement`s (see also [`h`](#h)).
 - [`svgUse`](#svgUse):
-  Shorthand for creating an SVG element
-  with a `<use>` child referencing an icon by ID.
+  Shorthand for creating an SVG element with a `<use>`
+  child referencing an icon by ID.
 - [`uuidV1`](#uuidV1):
   Generates a UUID v1 (time-based) identifier.
 - [`vivify`](#vivify):
-  A Proxy-based helper for auto-vivification
-  of nested object structures.
+  A Proxy-based helper for auto-vivification of nested
+  object structures.
 
 ### CNode
 
@@ -134,17 +92,8 @@ type CNode = {
 };
 ```
 
-Represents a CSS rule node for the [`c`](#c) helper.
-Keys are CSS properties or nested selectors.
-
-### CRoot
-
-```ts
-type CRoot = Record<PropertyKey, CNode>;
-```
-
-Represents the root CSS object for the [`c`](#c) helper.
-Keys are top-level selectors or at-rules.
+Represents a CSS rule node for the [`c`](#c) helper. Keys
+are CSS properties or nested selectors.
 
 ### HArgs
 
@@ -167,46 +116,32 @@ helpers.
 ### c
 
 ```ts
-const c: (root: CRoot, splitter?: string) => string;
+const c: (node: CNode, splitter?: string) => string;
 ```
 
-A minimal CSS-in-JS helper
-that converts a JavaScript object hierarchy
-into a CSS string.
+A minimal CSS-in-JS helper that converts a JavaScript
+object hierarchy into a CSS string.
 
-#### root
+#### node
 
-An object describing CSS rules.
-Keys are selectors or at-rules;
-values are either CSS property values
-or nested rule objects.
+An object describing CSS rules. Keys are
+selectors or at-rules; values are either CSS property
+values or nested rule objects. A selector key may
+contain comma-separated alternatives (e.g. `'.b,.c'`);
+when nested, each alternative is combined with each
+parent alternative (cartesian product), producing a
+comma-joined selector list (e.g. `'a.b,a.c'`).
 
 #### splitter
 
-A delimiter used to create unique keys (default: `'$$'`).
-The substring from `splitter` to the end of a key
-is ignored (e.g., `src$$1` → `src`).
+A delimiter used to create unique keys
+(default: `'$$'`). The substring from `splitter` to the
+end of a key is ignored (e.g., `src$$1` → `src`).
 
 #### Returns
 
 A CSS string representing the compiled rules.
 
-#### Remarks
-
-- Keys whose values are primitives (`string` | `number`)
-  are treated as CSS properties.
-- In property keys, uppercase letters
-  become lowercase with a `-` prefix
-  (e.g., `fontFamily` → `font-family`);
-  underscores become hyphens
-  (e.g., `font_family` → `font-family`).
-- Comma-separated selector keys
-  expand into multiple selectors
-  (e.g., `{ div: { '.a,.b': { margin: 1 } } }` →
-  `div.a,div.b{margin:1}`).
-- Top-level keys starting with `@` (at-rules)
-  are not concatenated with child selectors.
-
 #### Usage Examples
 
 ```ts
@@ -262,16 +197,16 @@ expect(actual2).to.equal(expected2)
 
 const actual3 = c({
   '@font-face$$1': {
-    fontFamily: 'Jackens',
+    'font-family': '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-weight': 'normal',
     'font-style': 'normal',
   },
   '@font-face$$2': {
-    font_family: 'C64',
+    'font-family': 'C64',
     src: 'url(fonts/C64_Pro_Mono-STYLE.woff)',
   },
   '@keyframes spin': {
@@ -281,8 +216,8 @@ const actual3 = c({
   div: {
     border: 'solid red 1px',
     '.c1': { 'background-color': '#000' },
-    ' .c1': { background_color: 'black' },
-    '.c2': { backgroundColor: 'rgb(0,0,0)' },
+    ' .c1': { 'background-color': 'black' },
+    '.c2': { 'background-color': 'rgb(0,0,0)' },
   },
   '@media(min-width:200px)': {
     div: { margin: 0, padding: 0 },
@@ -392,6 +327,94 @@ const expected6 = `
 }`.replace(/\n\s*/g, '')
 
 expect(actual6).to.equal(expected6)
+
+const actual7 = c({
+  ':root$$monokai': {
+    '--': {
+      bg: '#faf4f2',
+      fg: '#29242a',
+      comment: '#918c8e',
+      identifier: {
+        1: '#7058be',
+        2: '#269d69',
+        3: '#1c8ca8',
+        4: '#29242a',
+      },
+      keyword: {
+        1: '#e14775',
+        2: '#7058be',
+        3: '#1c8ca8',
+      },
+      number: '#7058be',
+      operator: '#e14775',
+      punctuation: '#918c8e',
+      string: '#cc7a0a',
+    },
+  },
+  '@media only screen and (prefers-color-scheme: dark)$$monokai':
+    {
+      ':root': {
+        '--': {
+          bg: '#2d2a2e',
+          fg: '#fcfcfa',
+          comment: '#727072',
+          identifier: {
+            1: '#ae81ff',
+            2: '#a9dc76',
+            3: '#66d9ef',
+            4: '#fcfcfa',
+          },
+          keyword: {
+            1: '#ff6188',
+            2: '#ae81ff',
+            3: '#66d9ef',
+          },
+          number: '#ae81ff',
+          operator: '#ff6188',
+          punctuation: '#727072',
+          string: '#ffd866',
+        },
+      },
+    },
+})
+
+const expected7 = `
+  :root{
+    --bg:#faf4f2;
+    --fg:#29242a;
+    --comment:#918c8e;
+    --identifier1:#7058be;
+    --identifier2:#269d69;
+    --identifier3:#1c8ca8;
+    --identifier4:#29242a;
+    --keyword1:#e14775;
+    --keyword2:#7058be;
+    --keyword3:#1c8ca8;
+    --number:#7058be;
+    --operator:#e14775;
+    --punctuation:#918c8e;
+    --string:#cc7a0a
+  }
+  @media only screen and (prefers-color-scheme: dark){
+    :root{
+      --bg:#2d2a2e;
+      --fg:#fcfcfa;
+      --comment:#727072;
+      --identifier1:#ae81ff;
+      --identifier2:#a9dc76;
+      --identifier3:#66d9ef;
+      --identifier4:#fcfcfa;
+      --keyword1:#ff6188;
+      --keyword2:#ae81ff;
+      --keyword3:#66d9ef;
+      --number:#ae81ff;
+      --operator:#ff6188;
+      --punctuation:#727072;
+      --string:#ffd866
+    }
+  }`.replace(/\n\s*/g, '')
+
+expect(actual7).to.equal(expected7)
 ```
 
 ### createEscape
@@ -400,24 +423,24 @@ expect(actual6).to.equal(expected6)
 const createEscape: (escapeFn: (value: any) => string) => (template: TemplateStringsArray, ...values: unknown[]) => string;
 ```
 
-Creates a tag function
-for escaping interpolated values in template literals.
+Creates a tag function for escaping interpolated values
+in template literals.
 
 #### escapeFn
 
-A function that takes a value
-and returns its escaped string representation.
+A function that takes a value and returns
+its escaped string representation.
 
 #### Returns
 
 A tag function that escapes interpolated values
-using the provided escape map.
+using the provided escape function.
 
 #### Usage Examples
 
 ```ts
 const escapeFn = (value: any): string =>
-  isArray(value)
+  Array.isArray(value)
     ? value.map(escapeFn).join(', ')
     : value === true || value === false
       ? `b'${+value}'`
@@ -425,9 +448,9 @@ const escapeFn = (value: any): string =>
         ? `'${value
             .toISOString()
             .replace(/^(.+)T(.+)\..*$/, '$1 $2')}'`
-        : isFiniteNumber(value)
+        : Number.isFinite(value)
           ? `${value}`
-          : isString(value)
+          : typeof value === 'string'
             ? `'${value.replace(/'/g, "''")}'`
             : 'NULL'
 
@@ -467,40 +490,41 @@ expect(actual).to.equal(expected)
 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)).
+A helper for building simple tokenizers (see also
+[`nanolightTs`](#nanolightTs)).
+
+#### 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.
 
 #### decorator
 
-A function that wraps each matched chunk.
-It receives the matched text (`chunk`)
-and optionally the `metadata`
-associated with the pattern that produced the match.
-For unmatched text between patterns,
-`metadata` is `undefined`.
+A function that wraps each matched
+chunk. It receives the matched text (`chunk`) and
+optionally the `metadata` associated with the pattern
+that produced the match. For unmatched text between
+patterns, `metadata` is `undefined`.
 
 #### specs
 
-An array of tuples `[metadata, pattern]` where:
+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.
+- `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
@@ -615,8 +639,8 @@ expect(result9).to.deep.equal(['a', 'a', 'b', 'b'])
 const csvParse: (csv: string, separator?: string) => string[][];
 ```
 
-Parses a CSV string
-into a two-dimensional array of strings.
+Parses a CSV string into a two-dimensional array of
+strings.
 
 Supports quoted fields with escaped double quotes (`""`).
 Carriage returns are normalized.
@@ -631,8 +655,8 @@ The field delimiter (default: `','`).
 
 #### Returns
 
-A 2D array where each inner array
-represents a row of fields.
+A 2D array where each inner array represents a
+row of fields.
 
 #### Usage Examples
 
@@ -659,23 +683,25 @@ expect(csvParse(text)).to.deep.equal([
 const fixPlTypography: (node: Node) => void;
 ```
 
-Applies Polish-specific typographic corrections
-to a DOM subtree.
+Applies Polish-specific typographic corrections to a DOM
+subtree.
 
 This function prevents orphaned conjunctions
 (single-letter words like “a”, “i”, “o”, “u”, “w”, “z”)
-from appearing at the end of a line
-by wrapping them with the following word
-in a non-breaking span.
-It also inserts zero-width spaces
-after slashes and dots to allow line breaks.
+and the em dash (“—”) from appearing at the end of a
+line. It wraps each such character together with the
+whitespace that follows it in a `white-space:nowrap`
+span, removing the only line-break opportunity between it
+and the next word so the two stay glued together. It also
+inserts zero-width spaces after slashes and dots to allow
+line breaks.
 
 #### node
 
-The root DOM node to process.
-All descendant text nodes are corrected recursively,
-except those inside `IFRAME`, `NOSCRIPT`, `PRE`,
-`SCRIPT`, `STYLE`, or `TEXTAREA` elements.
+The root DOM node to process. All descendant
+text nodes are corrected recursively, except those
+inside `IFRAME`, `NOSCRIPT`, `PRE`, `SCRIPT`, `STYLE`,
+or `TEXTAREA` elements.
 
 #### Usage Examples
 
@@ -711,28 +737,33 @@ const h: {
 };
 ```
 
-A lightweight *HyperScript*-style helper
-for creating and modifying `HTMLElement`s
-(see also [`s`](#s)).
+A lightweight _HyperScript_-style helper for creating and
+modifying `HTMLElement`s (see also [`s`](#s)).
 
 #### tagOrNode
 
-If a `string`, it is treated as the tag name
-for a new element.
-If a `Node`, that node is modified in place.
+If a `string`, it is treated as the tag
+name for a new element. If a `Node`, that node is
+modified in place.
 
 #### args
 
 Additional arguments processed as follows:
-- `Object`: maps attributes/properties.
-  Keys starting with `$` set element properties
-  (without the `$` prefix);
-  other keys set attributes via `setAttribute`.
-  A value of `false` removes the attribute.
+
+- `Object`: maps attributes/properties. Keys starting
+  with `$` set element properties (without the `$`
+  prefix); if the value is a plain object, it is
+  shallow-merged into the existing property instead of
+  replacing it (useful e.g. for `$style`). Other keys
+  set attributes: a key prefixed with `xlink:` sets the
+  attribute via `setAttributeNS` in the XLink
+  namespace; any other key (without a colon) sets it
+  via `setAttribute`. A value of `false` removes the
+  attribute.
 - `null`/`undefined`: ignored.
 - `Node`: appended as a child.
-- `string`/`number`: converted to a `Text` node
-  and appended.
+- `string`/`number`: converted to a `Text` node and
+  appended.
 - [`HArgs`](#HArgs) array: processed recursively.
 
 #### Returns
@@ -855,376 +886,14 @@ expect(elemWithNested.outerHTML).to.equal(
 )
 ```
 
-### hasOwn
-
-```ts
-const hasOwn: (ref: unknown, key: unknown) => boolean;
-```
-
-Checks whether an object has the specified key
-as its own property.
-
-A null-safe wrapper around `Object.hasOwn`.
-
-#### ref
-
-The object to check.
-
-#### key
-
-The property key to look for.
-
-#### Returns
-
-`true` if `ref` is not nullish
-and has `key` as an own property, `false` otherwise.
-
-#### Usage Examples
-
-```ts
-const obj = { 42: null, null: 'k,e,y', 'k,e,y': 42 }
-
-expect(42 in obj).to.be.true
-expect(hasOwn(obj, 42)).to.be.true
-
-expect('42' in obj).to.be.true
-expect(hasOwn(obj, '42')).to.be.true
-
-expect('null' in obj).to.be.true
-expect(hasOwn(obj, 'null')).to.be.true
-
-expect(null in obj).to.be.true
-expect(hasOwn(obj, null)).to.be.true
-
-expect('k,e,y' in obj).to.be.true
-expect(hasOwn(obj, 'k,e,y')).to.be.true
-
-expect(['k', 'e', 'y'] in obj).to.be.true
-expect(hasOwn(obj, ['k', 'e', 'y'])).to.be.true
-
-expect('toString' in obj).to.be.true
-expect(hasOwn(obj, 'toString')).to.be.false
-
-expect(() => 'key' in null).to.throw
-expect(hasOwn(null, 'key')).to.be.false
-
-expect(() => 'key' in undefined).to.throw
-expect(hasOwn(undefined, 'key')).to.be.false
-```
-
-### isArray
-
-```ts
-const isArray: (arg: unknown) => arg is unknown[];
-```
-
-Checks whether the argument is an array.
-
-#### arg
-
-The value to check.
-
-#### Returns
-
-`true` if `arg` is an array, `false` otherwise.
-
-#### Usage Examples
-
-```ts
-expect(isArray([])).to.be.true
-
-const fakeArray1 = Object.create({ constructor: Array })
-
-expect(isArray(fakeArray1)).to.be.false
-
-const fakeArray2 = Object.create({
-  [Symbol.toStringTag]: Array.name,
-})
-
-expect(isArray(fakeArray2)).to.be.false
-```
-
-### isFiniteNumber
-
-```ts
-const isFiniteNumber: (arg: unknown) => arg is number;
-```
-
-Checks whether the argument is a finite number
-(excludes `±Infinity` and `NaN`).
-
-#### arg
-
-The value to check.
-
-#### Returns
-
-`true` if `arg` is a finite number, `false` otherwise.
-
-#### Usage Examples
-
-```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
-```
-
-### isInteger
-
-```ts
-const isInteger: (arg: unknown) => arg is number;
-```
-
-Checks whether the argument is an integer number.
-
-#### arg
-
-The value to check.
-
-#### Returns
-
-`true` if `arg` is an integer number, `false` otherwise.
-
-#### Usage Examples
-
-```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
-```
-
-### isNumber
-
-```ts
-const isNumber: (arg: unknown) => arg is number;
-```
-
-Checks whether the argument is of type `number`
-(includes `NaN` and `±Infinity`).
-
-#### arg
-
-The value to check.
-
-#### Returns
-
-`true` if `typeof arg === 'number'`, `false` otherwise.
-
-#### Usage Examples
-
-```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
-```
-
-### isRecord
-
-```ts
-const isRecord: (arg: unknown) => arg is Record<PropertyKey, unknown>;
-```
-
-Checks whether the argument is a plain object
-(not `null` and not an array).
-
-#### arg
-
-The value to check.
-
-#### Returns
-
-`true` if `arg` is a plain object, `false` otherwise.
-
-#### Usage Examples
-
-```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;
+const monokai: CNode;
 ```
 
-A Monokai-inspired color scheme
-for use with the [`c`](#c) helper
-and [`nanolightTs`](#nanolightTs) tokenizer.
+A Monokai-inspired color scheme for use with the [`c`](#c)
+helper and [`nanolightTs`](#nanolightTs) tokenizer.
 
 ### nanolightTs
 
@@ -1241,8 +910,8 @@ The source code string to tokenize.
 
 #### Returns
 
-An array of [`HArgs1`](#HArgs1) elements
-suitable for rendering with [`h`](#h).
+An array of [`HArgs1`](#HArgs1) elements suitable for
+rendering with [`h`](#h).
 
 #### Usage Examples
 
@@ -1252,11 +921,11 @@ const codeJs =
   "{ 42: 42 }['42'] /* 42 */"
 
 expect(nanolightTs(codeJs)).to.deep.equal([
-  ['span', { class: 'keyword-1' }, 'const'],
+  ['span', { class: 'keyword1' }, 'const'],
   ' ',
   [
     'span',
-    { class: 'identifier-4' },
+    { class: 'identifier4' },
     'answerToLifeTheUniverseAndEverything',
   ],
   ' ',
@@ -1278,87 +947,19 @@ expect(nanolightTs(codeJs)).to.deep.equal([
 ])
 ```
 
-### omit
-
-```ts
-const omit: <T, K extends keyof T>(ref: T, keys: unknown[]) => Omit<T, K>;
-```
-
-Creates a new object excluding the specified keys
-from the source object.
-
-A runtime equivalent
-of TypeScript’s `Omit<T, K>` utility type.
-See also [`pick`](#pick).
-
-#### ref
-
-The source object.
-
-#### keys
-
-An array of keys to exclude from the result.
-
-#### Returns
-
-A new object without the specified keys.
-
-#### Usage Examples
-
-```ts
-const ref = { a: 42, b: '42', c: 17 }
-
-expect(omit(ref, ['c'])).to.deep.equal({ a: 42, b: '42' })
-```
-
-### pick
-
-```ts
-const pick: <T, K extends keyof T>(ref: T, keys: unknown[]) => Pick<T, K>;
-```
-
-Creates a new object containing only the specified keys
-from the source object.
-
-A runtime equivalent
-of TypeScript’s `Pick<T, K>` utility type.
-See also [`omit`](#omit).
-
-#### ref
-
-The source object.
-
-#### keys
-
-An array of keys to include in the result.
-
-#### Returns
-
-A new object with only the specified keys.
-
-#### Usage Examples
-
-```ts
-const ref = { a: 42, b: '42', c: 17 }
-
-expect(pick(ref, ['a', 'b'])).to.deep.equal({
-  a: 42,
-  b: '42',
-})
-```
-
 ### rwd
 
 ```ts
-const rwd: (root: CRoot, selector: string, cellWidthPx: number, cellHeightPx: number, ...specs: [number, number?, number?][]) => void;
+const rwd: (root: CNode, selector: string, cellWidthPx: number, cellHeightPx: number, ...specs: [number, number?, number?][]) => void;
 ```
 
-A responsive web design helper
-that generates CSS rules for a grid-like layout.
+A responsive web design helper that generates CSS rules
+for a grid-like layout.
 
 #### root
 
-The CSS root object to populate (see [`c`](#c)).
+The CSS root object to populate (see
+[`c`](#c)).
 
 #### selector
 
@@ -1374,18 +975,20 @@ The base cell height in pixels.
 
 #### specs
 
-An array of breakpoint specifications, each a tuple of:
-- `maxWidth`: maximum number of cells per row
-  (defines the viewport breakpoint).
-- `width` (optional, default `1`):
-  number of horizontal cells the element spans.
-- `height` (optional, default `1`):
-  number of vertical cells the element spans.
+An array of breakpoint specifications, each
+a tuple of:
+
+- `maxWidth`: maximum number of cells per row (defines
+  the viewport breakpoint).
+- `width` (optional, default `1`): number of horizontal
+  cells the element spans.
+- `height` (optional, default `1`): number of vertical
+  cells the element spans.
 
 #### Usage Examples
 
 ```ts
-const style: CRoot = {
+const style: CNode = {
   body: {
     margin: 0,
   },
@@ -1439,28 +1042,32 @@ const s: {
 };
 ```
 
-A lightweight *HyperScript*-style helper
-for creating and modifying `SVGElement`s
-(see also [`h`](#h)).
+A lightweight _HyperScript_-style helper for creating and
+modifying `SVGElement`s (see also [`h`](#h)).
 
 #### tagOrNode
 
-If a `string`, it is treated as the tag name
-for a new element.
-If a `Node`, that node is modified in place.
+If a `string`, it is treated as the tag
+name for a new element. If a `Node`, that node is
+modified in place.
 
 #### args
 
 Additional arguments processed as follows:
-- `Object`: maps attributes/properties.
-  Keys starting with `$` set element properties
-  (without the `$` prefix);
-  other keys set attributes via `setAttributeNS`.
-  A value of `false` removes the attribute.
+
+- `Object`: maps attributes/properties. Keys starting
+  with `$` set element properties (without the `$`
+  prefix); if the value is a plain object, it is
+  shallow-merged into the existing property instead of
+  replacing it. Other keys set attributes: a key
+  prefixed with `xlink:` sets the attribute via
+  `setAttributeNS` in the XLink namespace; any other
+  key (without a colon) sets it via `setAttribute`. A
+  value of `false` removes the attribute.
 - `null`/`undefined`: ignored.
 - `Node`: appended as a child.
-- `string`/`number`: converted to a `Text` node
-  and appended.
+- `string`/`number`: converted to a `Text` node and
+  appended.
 - [`HArgs`](#HArgs) array: processed recursively.
 
 #### Returns
@@ -1501,20 +1108,28 @@ expect(svg4.getAttributeNS(XLINK_NS, 'title')).to.equal(
 const svgUse: (id: string, ...args: HArgs1[]) => SVGSVGElement;
 ```
 
-Shorthand for creating an SVG element
-with a `<use>` child referencing an icon by ID.
+Shorthand for creating an SVG element with a `<use>`
+child referencing an icon by ID.
 
 Equivalent to:
-`s('svg', ['use', { 'xlink:href': '#' + id }], ...args)`.
+
+```ts
+s(
+  'svg',
+  ['use', { 'xlink:href': '#' + id }],
+  ...args
+)
+```
 
 #### id
 
-The ID of the symbol to reference
-(without the `#` prefix).
+The ID of the symbol to reference (without the
+`#` prefix).
 
 #### args
 
-Additional arguments passed to the outer `<svg>` element.
+Additional arguments passed to the outer
+`<svg>` element.
 
 #### Returns
 
@@ -1606,10 +1221,9 @@ The date to use for the timestamp portion
 #### node
 
 A hexadecimal `string` for the node portion
-(default: random).
-Must match `/^[0-9a-f]*$/`;
-it is trimmed to the last 12 characters
-and left-padded with zeros if shorter.
+(default: random). Must match `/^[0-9a-f]*$/`; it is
+trimmed to the last 12 characters and left-padded with
+zeros if shorter.
 
 #### Returns
 
@@ -1672,36 +1286,48 @@ expect(
 const vivify: (ref: unknown) => any;
 ```
 
-A Proxy-based helper for auto-vivification
-of nested object structures.
-
-Accessing, assigning, or deleting any nested property
-on the returned proxy
-automatically creates intermediate objects
-(or arrays for numeric-string keys matching
-`^(0|[1-9]\d*)$`) as needed,
-allowing deep operations without explicit null checks.
-
-Intermediates of the last level
-in a get-only property chain are NOT auto-created.
-For example, `vivify(ref).one.two` will create
-`ref.one` as `{}`, but will NOT create `ref.one.two`.
-Only when a deeper access, assignment, or deletion occurs
-(e.g. `delete vivify(ref).one.two.three`
-or `vivify(ref).one.two.three = 4`)
-will `ref.one.two` be materialized.
-
-When traversal reaches a primitive value,
-no auto-creation happens;
-the primitive’s own property is returned instead
-(e.g. accessing `.toString.name` on a number yields
-`'toString'` without modifying the underlying structure).
-
-Deletion on a non-existing intermediate path
-will auto-create intermediates up to the parent
-of the deleted key
-(e.g. `delete vivify(ref).one.two.three`
-will create `ref.one.two` as `{}` if it does not exist).
+A Proxy-based helper for auto-vivification of nested
+object structures.
+
+Accessing, assigning, or deleting any nested property on
+the returned proxy automatically creates intermediate
+objects (or arrays for numeric-string keys matching
+`^(0|[1-9]\d*)$`) as needed, allowing deep operations
+without explicit null checks.
+
+Intermediates of the last level in a get-only property
+chain are NOT auto-created. For example,
+`vivify(ref).one.two` will create `ref.one` as `{}`, but
+will NOT create `ref.one.two`. Only when a deeper access,
+assignment, or deletion occurs, e.g.
+
+```ts
+delete vivify(ref).one.two.three
+```
+
+or
+
+```ts
+vivify(ref).one.two.three = 4
+```
+
+Will `ref.one.two` be materialized.
+
+When traversal reaches a primitive value, no
+auto-creation happens; the primitive’s own property is
+returned instead (e.g. accessing `.toString.name` on a
+number yields `'toString'` without modifying the
+underlying structure).
+
+Deletion on a non-existing intermediate path will
+auto-create intermediates up to the parent of the deleted
+key, e.g.
+
+```ts
+delete vivify(ref).one.two.three
+```
+
+Will create `ref.one.two` as `{}` if it does not exist.
 
 #### ref