@jackens/nnn 2026.2.20 → 2026.2.24

package/readme.md

@@ -1,6 +1,6 @@
 # nnn
 
-A collection of Jackens’ JavaScript helper utilities (version: `2026.2.20`).
+A collection of Jackens’ JavaScript helper utilities (version: `2026.2.24`).
 
 ## Installation
 
@@ -19,28 +19,28 @@ npm i @jackens/nnn
 ```js
 import {
   c,
-  csv_parse,
-  escape_values,
-  fix_pl_typography,
+  csvParse,
+  escapeValues,
+  fixPlTypography,
   h,
-  has_own,
-  is_array,
-  is_finite_number,
-  is_number,
-  is_record,
-  is_string,
-  js_on_parse,
+  hasOwn,
+  isArray,
+  isFiniteNumber,
+  isNumber,
+  isRecord,
+  isString,
+  jsOnParse,
   monokai,
-  nanolight_ts,
-  new_escape,
-  new_noun_form,
-  new_tokenizer,
+  nanolightTs,
+  newEscape,
+  newNounForm,
+  newTokenizer,
   omit,
   pick,
   rwd,
   s,
-  svg_use,
-  uuid_v1,
+  svgUse,
+  uuidV1,
   vivify
 } from '@jackens/nnn' // or './node_modules/@jackens/nnn/nnn.js'
 ```
@@ -53,35 +53,35 @@ import {
 - [`HArgs`](#HArgs): Tuple argument type for the [`h`](#h) and [`s`](#s) helpers.
 - [`HArgs1`](#HArgs1): Single argument type for the [`h`](#h) and [`s`](#s) helpers.
 - [`c`](#c): A minimal CSS-in-JS helper that converts a JavaScript object hierarchy into a CSS string.
-- [`csv_parse`](#csv_parse): Parses a CSV string into a two-dimensional array of strings.
-- [`escape_values`](#escape_values): Escapes an array of values using the provided escape map.
-- [`fix_pl_typography`](#fix_pl_typography): Applies Polish-specific typographic corrections to a DOM subtree.
+- [`csvParse`](#csvParse): Parses a CSV string into a two-dimensional array of strings.
+- [`escapeValues`](#escapeValues): Escapes an array of values using the provided escape map.
+- [`fixPlTypography`](#fixPlTypography): Applies Polish-specific typographic corrections to a DOM subtree.
 - [`h`](#h): A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `HTMLElement`s (see also [`s`](#s)).
-- [`has_own`](#has_own): Checks whether an object has the specified key as its own property.
-- [`is_array`](#is_array): Checks whether the argument is an array.
-- [`is_finite_number`](#is_finite_number): Checks whether the argument is a finite number (excludes `±Infinity` and `NaN`).
-- [`is_number`](#is_number): Checks whether the argument is of type `number` (includes `NaN` and `±Infinity`).
-- [`is_record`](#is_record): Checks whether the argument is a plain object (not `null` and not an array).
-- [`is_string`](#is_string): Checks whether the argument is a string.
-- [`js_on_parse`](#js_on_parse): Parses JSON with support for handler-based value transformation (“JavaScript ON”).
-- [`monokai`](#monokai): A Monokai-inspired color scheme for use with the [`c`](#c) helper and [`nanolight_ts`](#nanolight_ts) tokenizer.
-- [`nanolight_ts`](#nanolight_ts): A TypeScript/JavaScript syntax highlighting tokenizer built using [`new_tokenizer`](#new_tokenizer).
-- [`new_escape`](#new_escape): Creates a tag function for escaping interpolated values in template literals.
-- [`new_noun_form`](#new_noun_form): Creates a function that returns the appropriate noun form based on a numeric value using `Intl.PluralRules`.
-- [`new_tokenizer`](#new_tokenizer): A helper for building simple tokenizers (see also [`nanolight_ts`](#nanolight_ts)).
+- [`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`).
+- [`isNumber`](#isNumber): Checks whether the argument is of type `number` (includes `NaN` and `±Infinity`).
+- [`isRecord`](#isRecord): Checks whether the argument is a plain object (not `null` and not an array).
+- [`isString`](#isString): Checks whether the argument is a string.
+- [`jsOnParse`](#jsOnParse): Parses JSON with support for handler-based value transformation (“JavaScript ON”).
+- [`monokai`](#monokai): A Monokai-inspired color scheme for use with the [`c`](#c) helper and [`nanolightTs`](#nanolightTs) tokenizer.
+- [`nanolightTs`](#nanolightTs): A TypeScript/JavaScript syntax highlighting tokenizer built using [`newTokenizer`](#newTokenizer).
+- [`newEscape`](#newEscape): Creates a tag function for escaping interpolated values in template literals.
+- [`newNounForm`](#newNounForm): Creates a function that returns the appropriate noun form based on a numeric value using `Intl.PluralRules`.
+- [`newTokenizer`](#newTokenizer): A helper for building simple tokenizers (see also [`nanolightTs`](#nanolightTs)).
 - [`omit`](#omit): Creates a new object excluding the specified keys from the source object.
 - [`pick`](#pick): Creates a new object containing only the specified keys from the source object.
 - [`rwd`](#rwd): A responsive web design helper that generates CSS rules for a grid-like layout.
 - [`s`](#s): A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `SVGElement`s (see also [`h`](#h)).
-- [`svg_use`](#svg_use): Shorthand for creating an SVG element with a `<use>` child referencing an icon by ID.
-- [`uuid_v1`](#uuid_v1): Generates a UUID v1 (time-based) identifier.
+- [`svgUse`](#svgUse): Shorthand for creating an SVG element with a `<use>` child referencing an icon by ID.
+- [`uuidV1`](#uuidV1): Generates a UUID v1 (time-based) identifier.
 - [`vivify`](#vivify): A Proxy-based helper for auto-vivification of nested object structures.
 
 ### CNode
 
 ```ts
 type CNode = {
-    [attribute_or_selector: string]: string | number | CNode | undefined;
+    [attributeOrSelector: string]: string | number | CNode | undefined;
 };
 ```
 
@@ -103,7 +103,7 @@ type EscapeMap = Map<unknown, (value?: unknown) => string>;
 
 A map from value constructors (or `null`/`undefined`) to escape functions.
 
-Used by [`escape_values`](#escape_values) and [`new_escape`](#new_escape).
+Used by [`escapeValues`](#escapeValues) and [`newEscape`](#newEscape).
 
 ### HArgs
 
@@ -155,7 +155,7 @@ A CSS string representing the compiled rules.
 #### Usage Examples
 
 ```ts
-const actual_1 = c({
+const actual1 = c({
   a: {
     color: 'red',
     margin: 1,
@@ -164,7 +164,7 @@ const actual_1 = c({
   }
 })
 
-const expected_1 = `
+const expected1 = `
 a{
   color:red;
   margin:1
@@ -177,9 +177,9 @@ a{
   padding:1
 }`.replace(/\n\s*/g, '')
 
-expect(actual_1).to.equal(expected_1)
+expect(actual1).to.equal(expected1)
 
-const actual_2 = c({
+const actual2 = c({
   a: {
     '.b': {
       color: 'red',
@@ -190,7 +190,7 @@ const actual_2 = c({
   }
 })
 
-const expected_2 = `
+const expected2 = `
 a.b{
   color:red;
   margin:1
@@ -203,9 +203,9 @@ a.b{
   padding:1
 }`.replace(/\n\s*/g, '')
 
-expect(actual_2).to.equal(expected_2)
+expect(actual2).to.equal(expected2)
 
-const actual_3 = c({
+const actual3 = c({
   '@font-face$$1': {
     fontFamily: 'Jackens',
     src$$1: 'url(otf/jackens.otf)',
@@ -234,7 +234,7 @@ const actual_3 = c({
   }
 })
 
-const expected_3 = `
+const expected3 = `
 @font-face{
   font-family:Jackens;
   src:url(otf/jackens.otf);
@@ -276,9 +276,9 @@ div.c2{
   }
 }`.replace(/\n\s*/g, '')
 
-expect(actual_3).to.equal(expected_3)
+expect(actual3).to.equal(expected3)
 
-const actual_4 = c({
+const actual4 = c({
   a: {
     '.b,.c': {
       margin: 1,
@@ -289,7 +289,7 @@ const actual_4 = c({
   }
 })
 
-const expected_4 = `
+const expected4 = `
 a.b,a.c{
   margin:1
 }
@@ -297,9 +297,9 @@ a.b.d,a.c.d{
   margin:2
 }`.replace(/\n\s*/g, '')
 
-expect(actual_4).to.equal(expected_4)
+expect(actual4).to.equal(expected4)
 
-const actual_5 = c({
+const actual5 = c({
   '.b,.c': {
     margin: 1,
     '.d': {
@@ -308,7 +308,7 @@ const actual_5 = c({
   }
 })
 
-const expected_5 = `
+const expected5 = `
 .b,.c{
   margin:1
 }
@@ -316,9 +316,9 @@ const expected_5 = `
   margin:2
 }`.replace(/\n\s*/g, '')
 
-expect(actual_5).to.equal(expected_5)
+expect(actual5).to.equal(expected5)
 
-const actual_6 = c({
+const actual6 = c({
   '.a,.b': {
     margin: 1,
     '.c,.d': {
@@ -327,7 +327,7 @@ const actual_6 = c({
   }
 })
 
-const expected_6 = `
+const expected6 = `
 .a,.b{
   margin:1
 }
@@ -335,13 +335,13 @@ const expected_6 = `
   margin:2
 }`.replace(/\n\s*/g, '')
 
-expect(actual_6).to.equal(expected_6)
+expect(actual6).to.equal(expected6)
 ```
 
-### csv_parse
+### csvParse
 
 ```ts
-const csv_parse: (csv: string, separator?: string) => string[][];
+const csvParse: (csv: string, separator?: string) => string[][];
 ```
 
 Parses a CSV string into a two-dimensional array of strings.
@@ -372,22 +372,22 @@ yyy",zzz
 
 `
 
-expect(csv_parse(text)).to.deep.equal([
+expect(csvParse(text)).to.deep.equal([
   ['aaa\n"aaa"\naaa', 'bbb', 'ccc,ccc'],
   ['xxx,xxx', 'yyy\nyyy', 'zzz'],
   [' 42 ', '42', ' 17']
 ])
 ```
 
-### escape_values
+### escapeValues
 
 ```ts
-const escape_values: (escape_map: EscapeMap, values: unknown[]) => string[];
+const escapeValues: (escapeMap: EscapeMap, values: unknown[]) => string[];
 ```
 
 Escapes an array of values using the provided escape map.
 
-#### escape_map
+#### escapeMap
 
 A map where keys are constructors (e.g., `String`, `Number`) and values are escape functions.
 
@@ -399,10 +399,10 @@ The array of values to escape.
 
 An array of escaped strings.
 
-### fix_pl_typography
+### fixPlTypography
 
 ```ts
-const fix_pl_typography: (node: Node) => void;
+const fixPlTypography: (node: Node) => void;
 ```
 
 Applies Polish-specific typographic corrections to a DOM subtree.
@@ -421,7 +421,7 @@ except those inside `IFRAME`, `NOSCRIPT`, `PRE`, `SCRIPT`, `STYLE`, or `TEXTAREA
 ```ts
 const p = h('p', 'Pchnąć w tę łódź jeża lub ośm skrzyń fig (zob. https://pl.wikipedia.org/wiki/Pangram).')
 
-fix_pl_typography(p)
+fixPlTypography(p)
 
 expect(p.innerHTML).to.deep.equal(
   'Pchnąć <span style="white-space:nowrap">w </span>tę łódź jeża lub ośm skrzyń fig ' +
@@ -434,13 +434,13 @@ expect(p.innerHTML).to.deep.equal(
 const h: {
     <T extends keyof HTMLElementTagNameMap>(tag: T, ...args1: HArgs1[]): HTMLElementTagNameMap[T];
     <N extends Node>(node: N, ...args1: HArgs1[]): N;
-    (tag_or_node: string | Node, ...args1: HArgs1[]): Node;
+    (tagOrNode: string | Node, ...args1: HArgs1[]): Node;
 };
 ```
 
 A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `HTMLElement`s (see also [`s`](#s)).
 
-#### tag_or_node
+#### tagOrNode
 
 If a `string`, it is treated as the tag name for a new element.
 If a `Node`, that node is modified in place.
@@ -522,10 +522,10 @@ h(div, { $key: { two: 2 } })
 expect(div.key).to.deep.equal({ one: 1, two: 2 })
 ```
 
-### has_own
+### hasOwn
 
 ```ts
-const has_own: (ref: unknown, key: unknown) => boolean;
+const hasOwn: (ref: unknown, key: unknown) => boolean;
 ```
 
 Checks whether an object has the specified key as its own property.
@@ -550,37 +550,37 @@ The property key to look for.
 const obj = { 42: null, null: 'k,e,y', 'k,e,y': 42 }
 
 expect(42 in obj).to.be.true
-expect(has_own(obj, 42)).to.be.true
+expect(hasOwn(obj, 42)).to.be.true
 
 expect('42' in obj).to.be.true
-expect(has_own(obj, '42')).to.be.true
+expect(hasOwn(obj, '42')).to.be.true
 
 expect('null' in obj).to.be.true
-expect(has_own(obj, 'null')).to.be.true
+expect(hasOwn(obj, 'null')).to.be.true
 
 expect(null in obj).to.be.true
-expect(has_own(obj, null)).to.be.true
+expect(hasOwn(obj, null)).to.be.true
 
 expect('k,e,y' in obj).to.be.true
-expect(has_own(obj, 'k,e,y')).to.be.true
+expect(hasOwn(obj, 'k,e,y')).to.be.true
 
 expect(['k', 'e', 'y'] in obj).to.be.true
-expect(has_own(obj, ['k', 'e', 'y'])).to.be.true
+expect(hasOwn(obj, ['k', 'e', 'y'])).to.be.true
 
 expect('toString' in obj).to.be.true
-expect(has_own(obj, 'toString')).to.be.false
+expect(hasOwn(obj, 'toString')).to.be.false
 
 expect(() => 'key' in null).to.throw
-expect(has_own(null, 'key')).to.be.false
+expect(hasOwn(null, 'key')).to.be.false
 
 expect(() => 'key' in undefined).to.throw
-expect(has_own(undefined, 'key')).to.be.false
+expect(hasOwn(undefined, 'key')).to.be.false
 ```
 
-### is_array
+### isArray
 
 ```ts
-const is_array: (arg: unknown) => arg is unknown[];
+const isArray: (arg: unknown) => arg is unknown[];
 ```
 
 Checks whether the argument is an array.
@@ -596,15 +596,15 @@ The value to check.
 #### Usage Examples
 
 ```ts
-expect(is_array([])).to.be.true
-expect(is_array(Object.create({ constructor: Array }))).to.be.false
-expect(is_array(Object.create({ [Symbol.toStringTag]: Array.name }))).to.be.false
+expect(isArray([])).to.be.true
+expect(isArray(Object.create({ constructor: Array }))).to.be.false
+expect(isArray(Object.create({ [Symbol.toStringTag]: Array.name }))).to.be.false
 ```
 
-### is_finite_number
+### isFiniteNumber
 
 ```ts
-const is_finite_number: (arg: unknown) => arg is number;
+const isFiniteNumber: (arg: unknown) => arg is number;
 ```
 
 Checks whether the argument is a finite number (excludes `±Infinity` and `NaN`).
@@ -620,17 +620,17 @@ The value to check.
 #### Usage Examples
 
 ```ts
-expect(is_finite_number(42)).to.be.true
-expect(is_finite_number(Number(42))).to.be.true
-expect(is_finite_number(new Number(42))).to.be.false
-expect(is_finite_number(NaN)).to.be.false
-expect(is_finite_number(Infinity)).to.be.false
+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
 ```
 
-### is_number
+### isNumber
 
 ```ts
-const is_number: (arg: unknown) => arg is number;
+const isNumber: (arg: unknown) => arg is number;
 ```
 
 Checks whether the argument is of type `number` (includes `NaN` and `±Infinity`).
@@ -646,17 +646,17 @@ The value to check.
 #### Usage Examples
 
 ```ts
-expect(is_number(42)).to.be.true
-expect(is_number(Number(42))).to.be.true
-expect(is_number(new Number(42))).to.be.false
-expect(is_number(NaN)).to.be.true
-expect(is_number(Infinity)).to.be.true
+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
 ```
 
-### is_record
+### isRecord
 
 ```ts
-const is_record: (arg: unknown) => arg is Record<PropertyKey, unknown>;
+const isRecord: (arg: unknown) => arg is Record<PropertyKey, unknown>;
 ```
 
 Checks whether the argument is a plain object (not `null` and not an array).
@@ -672,23 +672,23 @@ The value to check.
 #### Usage Examples
 
 ```ts
-expect(is_record({})).to.be.true
-expect(is_record([])).to.be.false
-expect(is_record(Object.create(null))).to.be.true
-expect(is_record(Object.create({ constructor: Number }))).to.be.true
-expect(is_record(Object.create({ [Symbol.toStringTag]: Number.name }))).to.be.true
-expect(is_record(new Number(42))).to.be.true
-expect(is_record(new String('42'))).to.be.true
+expect(isRecord({})).to.be.true
+expect(isRecord([])).to.be.false
+expect(isRecord(Object.create(null))).to.be.true
+expect(isRecord(Object.create({ constructor: Number }))).to.be.true
+expect(isRecord(Object.create({ [Symbol.toStringTag]: Number.name }))).to.be.true
+expect(isRecord(new Number(42))).to.be.true
+expect(isRecord(new String('42'))).to.be.true
 
-class Foo_Bar { }
+class FooBar { }
 
-expect(is_record(new Foo_Bar())).to.be.true
+expect(isRecord(new FooBar())).to.be.true
 ```
 
-### is_string
+### isString
 
 ```ts
-const is_string: (arg: unknown) => arg is string;
+const isString: (arg: unknown) => arg is string;
 ```
 
 Checks whether the argument is a string.
@@ -704,15 +704,15 @@ The value to check.
 #### Usage Examples
 
 ```ts
-expect(is_string('42')).to.be.true
-expect(is_string(String('42'))).to.be.true
-expect(is_string(new String('42'))).to.be.false
+expect(isString('42')).to.be.true
+expect(isString(String('42'))).to.be.true
+expect(isString(new String('42'))).to.be.false
 ```
 
-### js_on_parse
+### jsOnParse
 
 ```ts
-const js_on_parse: (handlers: Record<PropertyKey, Function>, text: string) => any;
+const jsOnParse: (handlers: Record<PropertyKey, Function>, text: string) => any;
 ```
 
 Parses JSON with support for handler-based value transformation (“JavaScript ON”).
@@ -741,7 +741,7 @@ const handlers = {
   $foo: () => 'bar'
 }
 
-const actual = js_on_parse(handlers, `[
+const actual = jsOnParse(handlers, `[
   {
     "$add": [1, 2]
   },
@@ -790,15 +790,15 @@ expect(actual).to.deep.equal(expected)
 const monokai: CRoot;
 ```
 
-A Monokai-inspired color scheme for use with the [`c`](#c) helper and [`nanolight_ts`](#nanolight_ts) tokenizer.
+A Monokai-inspired color scheme for use with the [`c`](#c) helper and [`nanolightTs`](#nanolightTs) tokenizer.
 
-### nanolight_ts
+### nanolightTs
 
 ```ts
-const nanolight_ts: (code: string) => HArgs1[];
+const nanolightTs: (code: string) => HArgs1[];
 ```
 
-A TypeScript/JavaScript syntax highlighting tokenizer built using [`new_tokenizer`](#new_tokenizer).
+A TypeScript/JavaScript syntax highlighting tokenizer built using [`newTokenizer`](#newTokenizer).
 
 #### code
 
@@ -811,12 +811,12 @@ An array of [`HArgs1`](#HArgs1) elements suitable for rendering with [`h`](#h).
 #### Usage Examples
 
 ```ts
-const code_js = "const answer_to_life_the_universe_and_everything = { 42: 42 }['42'] /* 42 */"
+const codeJs = "const answerToLifeTheUniverseAndEverything = { 42: 42 }['42'] /* 42 */"
 
-expect(nanolight_ts(code_js)).to.deep.equal([
+expect(nanolightTs(codeJs)).to.deep.equal([
   ['span', { class: 'keyword-1' }, 'const'],
   ' ',
-  ['span', { class: 'identifier-4' }, 'answer_to_life_the_universe_and_everything'],
+  ['span', { class: 'identifier-4' }, 'answerToLifeTheUniverseAndEverything'],
   ' ',
   ['span', { class: 'operator' }, '='],
   ' ',
@@ -836,15 +836,15 @@ expect(nanolight_ts(code_js)).to.deep.equal([
 ])
 ```
 
-### new_escape
+### newEscape
 
 ```ts
-const new_escape: (escape_map: EscapeMap) => (template: TemplateStringsArray, ...values: unknown[]) => string;
+const newEscape: (escapeMap: EscapeMap) => (template: TemplateStringsArray, ...values: unknown[]) => string;
 ```
 
 Creates a tag function for escaping interpolated values in template literals.
 
-#### escape_map
+#### escapeMap
 
 A map where keys are constructors and values are escape functions.
 
@@ -855,17 +855,17 @@ A tag function that escapes interpolated values using the provided escape map.
 #### Usage Examples
 
 ```ts
-const escape_map: EscapeMap = new Map([
+const escapeMap: EscapeMap = new Map([
   [null, () => 'NULL'],
   [undefined, () => 'NULL'],
-  [Array, (values: unknown[]) => escape_values(escape_map, values).join(', ')],
+  [Array, (values: unknown[]) => escapeValues(escapeMap, values).join(', ')],
   [Boolean, (value: boolean) => `b'${+value}'`],
   [Date, (value: Date) => `'${value.toISOString().replace(/^(.+)T(.+)\..*$/, '$1 $2')}'`],
   [Number, (value: number) => `${value}`],
   [String, (value: string) => `'${value.replace(/'/g, "''")}'`]
 ])
 
-const sql = new_escape(escape_map)
+const sql = newEscape(escapeMap)
 
 const actual = sql`
   SELECT *
@@ -880,10 +880,10 @@ const expected = `
 expect(actual).to.equal(expected)
 ```
 
-### new_noun_form
+### newNounForm
 
 ```ts
-const new_noun_form: (locale: string, forms: Partial<Record<Intl.LDMLPluralRule, string>>) => (value: number) => string;
+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`.
@@ -914,14 +914,14 @@ A function that takes a numeric value and returns the appropriate noun form.
 #### Usage Examples
 
 ```ts
-const auto = new_noun_form('pl', { one: 'auto', few: 'auta', other: 'aut' })
+const auto = newNounForm('pl', { one: 'auto', few: 'auta', other: 'aut' })
 
 expect(auto(0)).to.equal('aut')
 expect(auto(1)).to.equal('auto')
 expect(auto(17)).to.equal('aut')
 expect(auto(42)).to.equal('auta')
 
-const car = new_noun_form('en', { one: 'car', other: 'cars' })
+const car = newNounForm('en', { one: 'car', other: 'cars' })
 
 expect(car(0)).to.equal('cars')
 expect(car(1)).to.equal('car')
@@ -929,13 +929,13 @@ expect(car(17)).to.equal('cars')
 expect(car(42)).to.equal('cars')
 ```
 
-### new_tokenizer
+### newTokenizer
 
 ```ts
-const new_tokenizer: <M, T>(decorator: (chunk: string, metadata?: M) => T, ...specs: [M, string | RegExp][]) => (code: string) => T[];
+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 [`nanolight_ts`](#nanolight_ts)).
+A helper for building simple tokenizers (see also [`nanolightTs`](#nanolightTs)).
 
 #### decorator
 
@@ -1022,7 +1022,7 @@ expect(pick(ref, ['a', 'b'])).to.deep.equal({ a: 42, b: '42' })
 ### rwd
 
 ```ts
-const rwd: (root: CRoot, selector: string, cell_width_px: number, cell_height_px: number, ...specs: [number, number?, number?][]) => void;
+const rwd: (root: CRoot, selector: string, cellWidthPx: number, cellHeightPx: number, ...specs: [number, number?, number?][]) => void;
 ```
 
 A responsive web design helper that generates CSS rules for a grid-like layout.
@@ -1035,18 +1035,18 @@ The CSS root object to populate (see [`c`](#c)).
 
 The CSS selector for the grid item.
 
-#### cell_width_px
+#### cellWidthPx
 
 The base cell width in pixels.
 
-#### cell_height_px
+#### cellHeightPx
 
 The base cell height in pixels.
 
 #### specs
 
 An array of breakpoint specifications, each a tuple of:
-- `max_width`: maximum number of cells per row (defines the viewport breakpoint).
+- `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.
 
@@ -1103,13 +1103,13 @@ expect(style).to.deep.equal({
 const s: {
     <T extends keyof SVGElementTagNameMap>(tag: T, ...args1: HArgs1[]): SVGElementTagNameMap[T];
     <N extends Node>(node: N, ...args1: HArgs1[]): N;
-    (tag_or_node: string | Node, ...args1: HArgs1[]): Node;
+    (tagOrNode: string | Node, ...args1: HArgs1[]): Node;
 };
 ```
 
 A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `SVGElement`s (see also [`h`](#h)).
 
-#### tag_or_node
+#### tagOrNode
 
 If a `string`, it is treated as the tag name for a new element.
 If a `Node`, that node is modified in place.
@@ -1128,10 +1128,10 @@ Additional arguments processed as follows:
 
 The created or modified `SVGElement`.
 
-### svg_use
+### svgUse
 
 ```ts
-const svg_use: (id: string, ...args: HArgs1[]) => SVGSVGElement;
+const svgUse: (id: string, ...args: HArgs1[]) => SVGSVGElement;
 ```
 
 Shorthand for creating an SVG element with a `<use>` child referencing an icon by ID.
@@ -1150,10 +1150,10 @@ Additional arguments passed to the outer `<svg>` element.
 
 An `SVGSVGElement` containing a `<use>` element.
 
-### uuid_v1
+### uuidV1
 
 ```ts
-const uuid_v1: (date?: Date, node?: string) => string;
+const uuidV1: (date?: Date, node?: string) => string;
 ```
 
 Generates a UUID v1 (time-based) identifier.
@@ -1175,7 +1175,7 @@ A UUID v1 `string` in the standard format `xxxxxxxx-xxxx-1xxx-xxxx-xxxxxxxxxxxx`
 
 ```ts
 for (let i = 1; i <= 22136; ++i) {
-  const uuid = uuid_v1()
+  const uuid = uuidV1()
 
   if (i === 1) {
     expect(uuid.split('-')[3]).to.equal('8001')
@@ -1206,10 +1206,10 @@ for (let i = 1; i <= 22136; ++i) {
   }
 }
 
-expect(uuid_v1(new Date(), '000123456789abc').split('-')[4]).to.equal('123456789abc')
-expect(uuid_v1(new Date(), '123456789').split('-')[4]).to.equal('000123456789')
+expect(uuidV1(new Date(), '000123456789abc').split('-')[4]).to.equal('123456789abc')
+expect(uuidV1(new Date(), '123456789').split('-')[4]).to.equal('000123456789')
 
-expect(uuid_v1(new Date(323325000000)).startsWith('c1399400-9a71-11bd')).to.be.true
+expect(uuidV1(new Date(323325000000)).startsWith('c1399400-9a71-11bd')).to.be.true
 ```
 
 ### vivify