@jackens/nnn 2026.9.29 → 2026.10.1

package/README.md

@@ -1,6 +1,6 @@
 # nnn
 
-A collection of Jackens’ JavaScript helper utilities (version: `2026.9.29`).
+A collection of Jackens’ JavaScript helper utilities (version: `2026.10.1`).
 
 ## Installation
 
@@ -21,13 +21,8 @@ import {
   CNode,
   HArgs,
   HArgs1,
-  LexerSpec,
-  LexerSpecOptions,
   c,
-  createLexer,
   h,
-  monokai,
-  nanolightTs,
   rwd,
   s,
   svgUse,
@@ -42,20 +37,10 @@ import {
   Tuple argument type for the [`h`](#h) and [`s`](#s) helpers.
 - [`HArgs1`](#HArgs1):
   Single argument type for the [`h`](#h) and [`s`](#s) helpers.
-- [`LexerSpec`](#LexerSpec):
-  A [`createLexer`](#createLexer) spec: a `[metadata, pattern, options?]` tuple.
-- [`LexerSpecOptions`](#LexerSpecOptions):
-  Options of a [`createLexer`](#createLexer) spec controlling the lexer state stack.
 - [`c`](#c):
   A minimal CSS-in-JS helper that converts a JavaScript object hierarchy into a CSS string.
-- [`createLexer`](#createLexer):
-  A helper for building simple stateful lexers (see also [`nanolightTs`](#nanolightTs)).
 - [`h`](#h):
   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) lexer.
-- [`nanolightTs`](#nanolightTs):
-  A TypeScript/JavaScript syntax highlighting lexer built using [`createLexer`](#createLexer).
 - [`rwd`](#rwd):
   A responsive web design helper that generates CSS rules for a grid-like layout of floating elements.
 - [`s`](#s):
@@ -89,38 +74,6 @@ type HArgs1 = Record<PropertyKey, unknown> | null | undefined | Node | string |
 
 Single argument type for the [`h`](#h) and [`s`](#s) helpers.
 
-### LexerSpec
-
-```ts
-type LexerSpec<M> = [metadata: M, pattern: string | RegExp, options?: LexerSpecOptions]
-```
-
-A [`createLexer`](#createLexer) spec: a `[metadata, pattern, options?]` tuple.
-
-### LexerSpecOptions
-
-```ts
-type LexerSpecOptions = {
-  in?: string | string[]
-  pop?: boolean
-  push?: string
-}
-```
-
-Options of a [`createLexer`](#createLexer) spec controlling the lexer state stack.
-
-#### in
-
-State(s) in which the spec is active (default: `'root'`).
-
-#### pop
-
-Whether to pop the current state off the stack after a match (the `'root'` state at the bottom is never popped).
-
-#### push
-
-State to push onto the stack after a match (applied after `pop`).
-
 ### c
 
 ```ts
@@ -149,6 +102,8 @@ A CSS string representing the compiled rules.
 
 #### Usage Examples
 
+Nested selectors split a rule while preserving property order:
+
 ```ts
 const actual = c({
   a: {
@@ -176,6 +131,8 @@ const expected = `
 expect(actual).toBe(expected)
 ```
 
+Selectors can be nested at any depth:
+
 ```ts
 const actual = c({
   a: {
@@ -205,6 +162,8 @@ const expected = `
 expect(actual).toBe(expected)
 ```
 
+At-rules, keyframes, media queries and repeated keys with the `$$` suffix:
+
 ```ts
 const actual = c({
   '@font-face$$1': {
@@ -280,6 +239,8 @@ const expected = `
 expect(actual).toBe(expected)
 ```
 
+Comma-separated nested selectors are expanded:
+
 ```ts
 const actual = c({
   a: {
@@ -304,6 +265,8 @@ const expected = `
 expect(actual).toBe(expected)
 ```
 
+Comma-separated top-level selectors are expanded in nested rules:
+
 ```ts
 const actual = c({
   '.b,.c': {
@@ -326,6 +289,8 @@ const expected = `
 expect(actual).toBe(expected)
 ```
 
+Comma-separated selectors at both levels produce all combinations:
+
 ```ts
 const actual = c({
   '.a,.b': {
@@ -348,6 +313,8 @@ const expected = `
 expect(actual).toBe(expected)
 ```
 
+CSS custom properties from nested `--` objects:
+
 ```ts
 const actual = c({
   ':root$$monokai': {
@@ -438,182 +405,6 @@ const expected = `
 expect(actual).toBe(expected)
 ```
 
-### createLexer
-
-```ts
-const createLexer: <M, T>(
-  decorator: (chunk: string, metadata?: M) => T,
-  ...specs: LexerSpec<M>[]
-) => (code: string) => T[]
-```
-
-A helper for building simple stateful lexers (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.
-4. Only specs active in the current state (the top of the state stack, initially `'root'`) are considered.
-5. Patterns are matched against the whole input, so `^`, `$`, `\b` and lookbehinds see the text around the current position; a sticky (`y`) `RegExp` matches only at the current position.
-6. Empty matches are ignored.
-
-#### decorator
-
-A function that wraps each chunk of the input.
-It receives the matched text (`chunk`) and the `metadata` of the spec whose pattern produced the match.
-For unmatched text between matches, `metadata` is `undefined`.
-
-#### specs
-
-An array of tuples `[metadata, pattern, options?]` where:
-
-- `metadata`: arbitrary data (e.g., a CSS class name) passed to `decorator` when the pattern matches.
-- `pattern`: a `string` (matched literally) or `RegExp` to match against the input.
-- `options`: optional [`LexerSpecOptions`](#LexerSpecOptions) (states in which the spec is active and state transitions).
-
-#### Returns
-
-A lexer function that accepts an input string and returns an array of decorated chunks covering the whole input (in order).
-
-#### Usage Examples
-
-```ts
-const lexer = createLexer(
-  (chunk, metadata) => ({ chunk, metadata }),
-  ['keyword', /\b(if|else|for)\b/],
-  ['string', /"[^"]*"/]
-)
-
-const result = lexer('if "hello" else "world"')
-
-expect(result).toEqual([
-  { 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' },
-])
-```
-
-```ts
-const lexer = createLexer((chunk, metadata) => `${metadata}:${chunk}`, ['tag', 'BEGIN'], ['end', 'END'])
-
-const result = lexer('aBEGINbENDc')
-
-expect(result).toEqual(['undefined:a', 'tag:BEGIN', 'undefined:b', 'end:END', 'undefined:c'])
-```
-
-```ts
-const lexer = createLexer(chunk => chunk, ['test', /test/])
-
-const result = lexer('')
-
-expect(result).toEqual([])
-```
-
-```ts
-const lexer = createLexer((chunk, metadata) => ({ chunk, metadata }), ['start', /^test/])
-
-const result = lexer('test here')
-
-expect(result).toEqual([
-  { chunk: 'test', metadata: 'start' },
-  { chunk: ' here', metadata: undefined },
-])
-```
-
-```ts
-const lexer = createLexer((chunk, metadata) => metadata, ['later', /x/], ['earlier', /y/])
-
-const result = lexer('yx')
-
-expect(result).toEqual(['earlier', 'later'])
-```
-
-```ts
-const lexer = createLexer(chunk => chunk, ['short', 'a'], ['long', 'abc'])
-
-const result = lexer('abc')
-
-expect(result).toEqual(['abc'])
-```
-
-```ts
-const lexer = createLexer(chunk => chunk, ['empty', ''], ['word', /\w+/])
-
-const result = lexer('hello')
-
-expect(result).toEqual(['hello'])
-```
-
-```ts
-const lexer = createLexer(chunk => chunk, ['test', /xyz/])
-
-const result = lexer('abc')
-
-expect(result).toEqual(['abc'])
-```
-
-```ts
-const lexer = createLexer((_chunk, metadata) => metadata, ['a', 'a'], ['b', 'b'])
-
-const result = lexer('aabb')
-
-expect(result).toEqual(['a', 'a', 'b', 'b'])
-```
-
-```ts
-const lexer = createLexer(
-  (chunk, metadata) => `${metadata}:${chunk}`,
-  ['open', '(', { push: 'inner' }],
-  ['word', /\w+/, { in: 'inner' }],
-  ['close', ')', { in: 'inner', pop: true }]
-)
-
-const result = lexer('a(b)c)')
-
-expect(result).toEqual(['undefined:a', 'open:(', 'word:b', 'close:)', 'undefined:c)'])
-```
-
-```ts
-const lexer = createLexer(
-  (chunk, metadata) => `${metadata}:${chunk}`,
-  ['open', '{', { in: ['root', 'nested'], push: 'nested' }],
-  ['close', '}', { in: 'nested', pop: true }]
-)
-
-const result = lexer('{{}}}')
-
-expect(result).toEqual(['open:{', 'open:{', 'close:}', 'close:}', 'undefined:}'])
-```
-
-```ts
-const lexer = createLexer((chunk, metadata) => `${metadata}:${chunk}`, ['a', 'a'], ['b', /(?<=a)b/])
-
-const result = lexer('abcb')
-
-expect(result).toEqual(['a:a', 'b:b', 'undefined:cb'])
-```
-
-```ts
-const lexer = createLexer((chunk, metadata) => `${metadata}:${chunk}`, ['x', /x/y], ['y', 'y'])
-
-const result = lexer('xyx.x')
-
-expect(result).toEqual(['x:x', 'y:y', 'x:x', 'undefined:.x'])
-```
-
-```ts
-const lexer = createLexer((chunk, metadata) => `${metadata}:${chunk}`, ['digits', /\d*/])
-
-const result = lexer('ab12')
-
-expect(result).toEqual(['undefined:ab', 'digits:12'])
-```
-
 ### h
 
 ```ts
@@ -650,6 +441,8 @@ The created `HTMLElement` or the modified node.
 
 #### Usage Examples
 
+Creating elements, appending children and setting properties:
+
 ```ts
 const b = h('b')
 
@@ -670,6 +463,8 @@ expect(i.outerHTML).toBe('<i class="some class">text</i>')
 expect(b.outerHTML).toBe('<b><i class="some class">text</i></b>')
 ```
 
+Text content from strings, numbers and `$innerText`:
+
 ```ts
 expect(h('span', 'text').outerHTML).toBe('<span>text</span>')
 
@@ -680,6 +475,8 @@ expect(h('span', '42').outerHTML).toBe('<span>42</span>')
 expect(h('span', 42).outerHTML).toBe('<span>42</span>')
 ```
 
+`style` attribute vs `$style` property (string or object):
+
 ```ts
 expect(h('div', { style: 'margin:0;padding:0' }).outerHTML).toBe('<div style="margin:0;padding:0"></div>')
 
@@ -690,6 +487,8 @@ expect(h('div', { $style: { margin: 0, padding: 0 } }).outerHTML).toBe(
 )
 ```
 
+`value` attribute vs `$value` property:
+
 ```ts
 const input1 = h('input', { value: 42 })
 const input2 = h('input', { $value: '42' })
@@ -701,6 +500,8 @@ expect(input1.outerHTML).toBe('<input value="42">')
 expect(input2.outerHTML).toBe('<input>')
 ```
 
+`checked` attribute vs `$checked` property:
+
 ```ts
 const checkbox1 = h('input', {
   type: 'checkbox',
@@ -720,6 +521,8 @@ expect(checkbox1.outerHTML).toBe('<input type="checkbox" checked="">')
 expect(checkbox2.outerHTML).toBe('<input type="checkbox">')
 ```
 
+Object values of `$`-prefixed properties are merged:
+
 ```ts
 const div = h('div')
 
@@ -734,6 +537,8 @@ h(div, { $key: { two: 2 } })
 expect(div.key).toEqual({ one: 1, two: 2 })
 ```
 
+Class attribute, appending text and nested children given as arrays:
+
 ```ts
 const elemWithClass = h('div', { class: 'test' })
 
@@ -750,258 +555,6 @@ const elemWithNested = h('div', ['span', 'hello'], ['b', 'world'])
 expect(elemWithNested.outerHTML).toBe('<div><span>hello</span><b>world</b></div>')
 ```
 
-### monokai
-
-```ts
-const monokai: CNode
-```
-
-A Monokai-inspired color scheme for use with the [`c`](#c) helper and [`nanolightTs`](#nanolightTs) lexer.
-It styles `pre` and `code>span` elements with the class names produced by [`nanolightTs`](#nanolightTs) (with light, dark and print variants).
-
-#### Usage Examples
-
-```ts
-const style = h('style', c(monokai))
-const pre = h('pre', ['code', ...nanolightTs('const x = 42')])
-
-expect(style.textContent).toContain('code>span.keyword1{color:var(--keyword1)}')
-expect(style.textContent).toContain('@media only screen and (prefers-color-scheme: dark){:root{--bg:#2d2a2e;')
-expect(pre.outerHTML).toBe(
-  '<pre><code>' +
-    '<span class="keyword1">const</span> ' +
-    '<span class="identifier4">x</span> ' +
-    '<span class="operator">=</span> ' +
-    '<span class="number">42</span>' +
-    '</code></pre>'
-)
-```
-
-### nanolightTs
-
-```ts
-const nanolightTs: (code: string) => HArgs1[]
-```
-
-A TypeScript/JavaScript syntax highlighting lexer built using [`createLexer`](#createLexer).
-
-#### code
-
-The source code string to tokenize.
-
-#### Returns
-
-An array of [`HArgs1`](#HArgs1) elements suitable for rendering with [`h`](#h): plain `string`s for unrecognized text (e.g. whitespace) and `['span', { class }, chunk]` tuples for recognized tokens (class names are styled by [`monokai`](#monokai)).
-
-#### Usage Examples
-
-```ts
-const codeJs = 'const answerToLifeTheUniverseAndEverything = ' + "{ 42: 42 }['42'] /* 42 */"
-
-expect(nanolightTs(codeJs)).toEqual([
-  ['span', { class: 'keyword1' }, 'const'],
-  ' ',
-  ['span', { class: 'identifier4' }, '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 */'],
-])
-```
-
-```ts
-const codeJs = 'const x = 42 // answer'
-
-expect(nanolightTs(codeJs)).toEqual([
-  ['span', { class: 'keyword1' }, 'const'],
-  ' ',
-  ['span', { class: 'identifier4' }, 'x'],
-  ' ',
-  ['span', { class: 'operator' }, '='],
-  ' ',
-  ['span', { class: 'number' }, '42'],
-  ' ',
-  ['span', { class: 'comment' }, '// answer'],
-])
-```
-
-```ts
-expect(nanolightTs('x = /a\\/b[/]c/gi.test(y) / 2')).toEqual([
-  ['span', { class: 'identifier4' }, 'x'],
-  ' ',
-  ['span', { class: 'operator' }, '='],
-  ' ',
-  ['span', { class: 'string' }, '/a\\/b[/]c/gi'],
-  ['span', { class: 'punctuation' }, '.'],
-  ['span', { class: 'identifier2' }, 'test'],
-  ['span', { class: 'punctuation' }, '('],
-  ['span', { class: 'identifier4' }, 'y'],
-  ['span', { class: 'punctuation' }, ')'],
-  ' ',
-  ['span', { class: 'operator' }, '/'],
-  ' ',
-  ['span', { class: 'number' }, '2'],
-])
-
-expect(nanolightTs('a / b / c')).toEqual([
-  ['span', { class: 'identifier4' }, 'a'],
-  ' ',
-  ['span', { class: 'operator' }, '/'],
-  ' ',
-  ['span', { class: 'identifier4' }, 'b'],
-  ' ',
-  ['span', { class: 'operator' }, '/'],
-  ' ',
-  ['span', { class: 'identifier4' }, 'c'],
-])
-
-expect(nanolightTs('return / x /')).toEqual([
-  ['span', { class: 'keyword1' }, 'return'],
-  ' ',
-  ['span', { class: 'string' }, '/ x /'],
-])
-```
-
-```ts
-expect(nanolightTs('`a ${b + `c ${ {d}.d }`} \\${e} $f`')).toEqual([
-  ['span', { class: 'string' }, '`a '],
-  ['span', { class: 'punctuation' }, '${'],
-  ['span', { class: 'identifier4' }, 'b'],
-  ' ',
-  ['span', { class: 'operator' }, '+'],
-  ' ',
-  ['span', { class: 'string' }, '`c '],
-  ['span', { class: 'punctuation' }, '${'],
-  ' ',
-  ['span', { class: 'punctuation' }, '{'],
-  ['span', { class: 'identifier4' }, 'd'],
-  ['span', { class: 'punctuation' }, '}'],
-  ['span', { class: 'punctuation' }, '.'],
-  ['span', { class: 'identifier4' }, 'd'],
-  ' ',
-  ['span', { class: 'punctuation' }, '}'],
-  ['span', { class: 'string' }, '`'],
-  ['span', { class: 'punctuation' }, '}'],
-  ['span', { class: 'string' }, ' \\${e} $f`'],
-])
-
-expect(nanolightTs('`${x}` / 2')).toEqual([
-  ['span', { class: 'string' }, '`'],
-  ['span', { class: 'punctuation' }, '${'],
-  ['span', { class: 'identifier4' }, 'x'],
-  ['span', { class: 'punctuation' }, '}'],
-  ['span', { class: 'string' }, '`'],
-  ' ',
-  ['span', { class: 'operator' }, '/'],
-  ' ',
-  ['span', { class: 'number' }, '2'],
-])
-```
-
-```ts
-expect(nanolightTs('"a // b" // c')).toEqual([
-  ['span', { class: 'string' }, '"a // b"'],
-  ' ',
-  ['span', { class: 'comment' }, '// c'],
-])
-
-expect(nanolightTs("'it\\'s' /* x")).toEqual([
-  ['span', { class: 'string' }, "'it\\'s'"],
-  ' ',
-  ['span', { class: 'comment' }, '/* x'],
-])
-```
-
-```ts
-expect(nanolightTs('0xFF + 1_000n + .5e-3')).toEqual([
-  ['span', { class: 'number' }, '0xFF'],
-  ' ',
-  ['span', { class: 'operator' }, '+'],
-  ' ',
-  ['span', { class: 'number' }, '1_000n'],
-  ' ',
-  ['span', { class: 'operator' }, '+'],
-  ' ',
-  ['span', { class: 'number' }, '.5e-3'],
-])
-```
-
-```ts
-expect(nanolightTs('a++ / 2 / b')).toEqual([
-  ['span', { class: 'identifier4' }, 'a'],
-  ['span', { class: 'operator' }, '++'],
-  ' ',
-  ['span', { class: 'operator' }, '/'],
-  ' ',
-  ['span', { class: 'number' }, '2'],
-  ' ',
-  ['span', { class: 'operator' }, '/'],
-  ' ',
-  ['span', { class: 'identifier4' }, 'b'],
-])
-
-expect(nanolightTs('x?.5:a?.b')).toEqual([
-  ['span', { class: 'identifier4' }, 'x'],
-  ['span', { class: 'operator' }, '?'],
-  ['span', { class: 'number' }, '.5'],
-  ['span', { class: 'operator' }, ':'],
-  ['span', { class: 'identifier4' }, 'a'],
-  ['span', { class: 'punctuation' }, '?.'],
-  ['span', { class: 'identifier4' }, 'b'],
-])
-```
-
-```ts
-expect(nanolightTs('p.catch(obj.in, ...this)')).toEqual([
-  ['span', { class: 'identifier4' }, 'p'],
-  ['span', { class: 'punctuation' }, '.'],
-  ['span', { class: 'identifier2' }, 'catch'],
-  ['span', { class: 'punctuation' }, '('],
-  ['span', { class: 'identifier4' }, 'obj'],
-  ['span', { class: 'punctuation' }, '.'],
-  ['span', { class: 'identifier4' }, 'in'],
-  ['span', { class: 'punctuation' }, ','],
-  ' ',
-  ['span', { class: 'operator' }, '...'],
-  ['span', { class: 'keyword1' }, 'this'],
-  ['span', { class: 'punctuation' }, ')'],
-])
-```
-
-```ts
-expect(nanolightTs('#!/usr/bin/env bun\n@sealed class A { #x = 1 }')).toEqual([
-  ['span', { class: 'comment' }, '#!/usr/bin/env bun'],
-  '\n',
-  ['span', { class: 'identifier2' }, '@sealed'],
-  ' ',
-  ['span', { class: 'keyword1' }, 'class'],
-  ' ',
-  ['span', { class: 'identifier1' }, 'A'],
-  ' ',
-  ['span', { class: 'punctuation' }, '{'],
-  ' ',
-  ['span', { class: 'identifier4' }, '#x'],
-  ' ',
-  ['span', { class: 'operator' }, '='],
-  ' ',
-  ['span', { class: 'number' }, '1'],
-  ' ',
-  ['span', { class: 'punctuation' }, '}'],
-])
-```
-
 ### rwd
 
 ```ts
@@ -1043,6 +596,8 @@ An array of breakpoint specifications, each a tuple of:
 
 #### Usage Examples
 
+Responsive grid cell widths and heights with media queries:
+
 ```ts
 const style: CNode = {
   body: {
@@ -1124,24 +679,32 @@ The created `SVGElement` or the modified node.
 
 #### Usage Examples
 
+Namespaced `xlink:` attribute set to `true` gets an empty value:
+
 ```ts
 const svg = s('svg', { 'xlink:href': true })
 
 expect(svg.getAttributeNS('http://www.w3.org/1999/xlink', 'href')).toBe('')
 ```
 
+Namespaced `xlink:` attribute set to `false` is not set:
+
 ```ts
 const svg = s('svg', { 'xlink:href': false })
 
 expect(svg.getAttributeNS('http://www.w3.org/1999/xlink', 'href')).toBeNull()
 ```
 
+Namespaced `xlink:` attribute with a string value:
+
 ```ts
 const svg = s('svg', { 'xlink:href': 'http://example.com' })
 
 expect(svg.getAttributeNS('http://www.w3.org/1999/xlink', 'href')).toBe('http://example.com')
 ```
 
+Namespaced `xlink:` attribute with a number value:
+
 ```ts
 const svg = s('svg', { 'xlink:title': 42 })
 
@@ -1176,6 +739,8 @@ An `SVGSVGElement` containing a `<use>` element.
 
 #### Usage Examples
 
+SVG `use` element referencing a symbol, with extra attributes:
+
 ```ts
 const svg = svgUse('icon-home')
 

package/nnn.d.ts

@@ -24,62 +24,6 @@ export type CNode = {
  * A CSS string representing the compiled rules.
  */
 export declare const c: (node: CNode, splitter?: string) => string
-/**
- * Options of a {@link createLexer} spec controlling the lexer state stack.
- *
- * @property in
- *
- * State(s) in which the spec is active (default: `'root'`).
- *
- * @property pop
- *
- * Whether to pop the current state off the stack after a match (the `'root'` state at the bottom is never popped).
- *
- * @property push
- *
- * State to push onto the stack after a match (applied after `pop`).
- */
-export type LexerSpecOptions = {
-  in?: string | string[]
-  pop?: boolean
-  push?: string
-}
-/** A {@link createLexer} spec: a `[metadata, pattern, options?]` tuple. */
-export type LexerSpec<M> = [metadata: M, pattern: string | RegExp, options?: LexerSpecOptions]
-/**
- * A helper for building simple stateful lexers (see also {@link 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.
- * 4. Only specs active in the current state (the top of the state stack, initially `'root'`) are considered.
- * 5. Patterns are matched against the whole input, so `^`, `$`, `\b` and lookbehinds see the text around the current position; a sticky (`y`) `RegExp` matches only at the current position.
- * 6. Empty matches are ignored.
- *
- * @param decorator
- *
- * A function that wraps each chunk of the input.
- * It receives the matched text (`chunk`) and the `metadata` of the spec whose pattern produced the match.
- * For unmatched text between matches, `metadata` is `undefined`.
- *
- * @param specs
- *
- * An array of tuples `[metadata, pattern, options?]` where:
- *
- * - `metadata`: arbitrary data (e.g., a CSS class name) passed to `decorator` when the pattern matches.
- * - `pattern`: a `string` (matched literally) or `RegExp` to match against the input.
- * - `options`: optional {@link LexerSpecOptions} (states in which the spec is active and state transitions).
- *
- * @returns
- *
- * A lexer function that accepts an input string and returns an array of decorated chunks covering the whole input (in order).
- */
-export declare const createLexer: <M, T>(
-  decorator: (chunk: string, metadata?: M) => T,
-  ...specs: LexerSpec<M>[]
-) => (code: string) => T[]
 /** Single argument type for the {@link h} and {@link s} helpers. */
 export type HArgs1 = Record<PropertyKey, unknown> | null | undefined | Node | string | number | HArgs
 /** Tuple argument type for the {@link h} and {@link s} helpers. */
@@ -166,23 +110,6 @@ export declare const s: {
  * An `SVGSVGElement` containing a `<use>` element.
  */
 export declare const svgUse: (id: string, ...args: HArgs1[]) => SVGSVGElement
-/**
- * A Monokai-inspired color scheme for use with the {@link c} helper and {@link nanolightTs} lexer.
- * It styles `pre` and `code>span` elements with the class names produced by {@link nanolightTs} (with light, dark and print variants).
- */
-export declare const monokai: CNode
-/**
- * A TypeScript/JavaScript syntax highlighting lexer built using {@link createLexer}.
- *
- * @param code
- *
- * The source code string to tokenize.
- *
- * @returns
- *
- * An array of {@link HArgs1} elements suitable for rendering with {@link h}: plain `string`s for unrecognized text (e.g. whitespace) and `['span', { class }, chunk]` tuples for recognized tokens (class names are styled by {@link monokai}).
- */
-export declare const nanolightTs: (code: string) => HArgs1[]
 /**
  * A responsive web design helper that generates CSS rules for a grid-like layout of floating elements.
  * It modifies `root` in place: it sets base styles for `selector` and adds a `@media(min-width:…px)` rule for each breakpoint.

package/nnn.js

@@ -50,79 +50,6 @@ var _c = (node, splitter = DEFAULT_SPLITTER, prefix = "", flatten = false) => {
   return out.join(flatten ? ";" : "");
 };
 var c = (node, splitter = DEFAULT_SPLITTER) => _c(node, splitter);
-// src/nnn/createLexer.ts
-var ROOT = "root";
-var createLexer = (decorator, ...specs) => {
-  const compiled = specs.map(([metadata, pattern, options]) => ({
-    metadata,
-    pattern: pattern instanceof RegExp ? new RegExp(pattern.source, pattern.sticky ? pattern.flags : pattern.flags.replace("g", "") + "g") : pattern,
-    states: [options?.in ?? ROOT].flat(),
-    pop: options?.pop ?? false,
-    push: options?.push
-  }));
-  const find = (pattern, code, position) => {
-    if (typeof pattern === "string") {
-      const index = pattern.length > 0 ? code.indexOf(pattern, position) : -1;
-      return [index, pattern];
-    }
-    pattern.lastIndex = position;
-    for (let match = pattern.exec(code);match != null; match = pattern.exec(code)) {
-      if (match[0].length > 0) {
-        return [match.index, match[0]];
-      }
-      if (pattern.sticky) {
-        break;
-      }
-      pattern.lastIndex = match.index + 1;
-    }
-    return [-1, ""];
-  };
-  return (code) => {
-    const result = [];
-    const stack = [ROOT];
-    const cache = compiled.map(() => ({ from: -1, index: -1, chunk: "" }));
-    let position = 0;
-    while (position < code.length) {
-      const state = stack.at(-1);
-      let best = -1;
-      let bestIndex = Infinity;
-      let bestChunk = "";
-      compiled.forEach(({ pattern, states }, i) => {
-        if (!states.includes(state)) {
-          return;
-        }
-        const cached = cache[i];
-        const isValid = cached.from >= 0 && (pattern instanceof RegExp && pattern.sticky ? cached.from === position : cached.from <= position && (cached.index < 0 || cached.index >= position));
-        if (!isValid) {
-          [cached.index, cached.chunk] = find(pattern, code, position);
-          cached.from = position;
-        }
-        if (cached.index >= 0 && (cached.index < bestIndex || cached.index === bestIndex && cached.chunk.length > bestChunk.length)) {
-          best = i;
-          bestIndex = cached.index;
-          bestChunk = cached.chunk;
-        }
-      });
-      if (best < 0) {
-        result.push(decorator(code.slice(position)));
-        break;
-      }
-      const { metadata, pop, push } = compiled[best];
-      if (bestIndex > position) {
-        result.push(decorator(code.slice(position, bestIndex)));
-      }
-      result.push(decorator(bestChunk, metadata));
-      position = bestIndex + bestChunk.length;
-      if (pop && stack.length > 1) {
-        stack.pop();
-      }
-      if (push != null) {
-        stack.push(push);
-      }
-    }
-    return result;
-  };
-};
 // src/nnn/h.ts
 var XLINK_NS = "http://www.w3.org/1999/xlink";
 var _h = (createElement, tagOrNode, ...args) => {
@@ -180,113 +107,6 @@ var _h = (createElement, tagOrNode, ...args) => {
 var h = _h.bind(null, (tag) => document.createElement(tag));
 var s = _h.bind(null, (tag) => document.createElementNS("http://www.w3.org/2000/svg", tag));
 var svgUse = (id, ...args) => s("svg", ["use", { "xlink:href": "#" + id }], ...args);
-// src/nnn/monokai.ts
-var monokai = {
-  ":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"
-    }
-  },
-  pre$$monokai: {
-    "background-color": "var(--bg)",
-    color: "var(--fg)",
-    margin: 0,
-    padding: "1em",
-    overflow: "visible",
-    " code": {
-      "font-family": '"Source Code Pro"',
-      padding: 0
-    }
-  },
-  "code>span.$$monokai": {
-    bg: { color: "var(--bg)" },
-    fg: { color: "var(--fg)" },
-    comment: { color: "var(--comment)" },
-    identifier: {
-      1: { color: "var(--identifier1)" },
-      2: { color: "var(--identifier2)" },
-      3: { color: "var(--identifier3)" },
-      4: { color: "var(--identifier4)" }
-    },
-    keyword: {
-      1: { color: "var(--keyword1)" },
-      2: { color: "var(--keyword2)" },
-      3: { color: "var(--keyword3)" }
-    },
-    number: { color: "var(--number)" },
-    operator: { color: "var(--operator)" },
-    punctuation: { color: "var(--punctuation)" },
-    string: { color: "var(--string)" }
-  },
-  "@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"
-      }
-    }
-  },
-  "@media print$$monokai": {
-    pre: {
-      "background-color": "white"
-    },
-    ":root": {
-      "--bg": "white"
-    }
-  }
-};
-// src/nnn/nanolightTs.ts
-var COMMENT = "comment";
-var IDENTIFIER1 = "identifier1";
-var IDENTIFIER2 = "identifier2";
-var IDENTIFIER3 = "identifier3";
-var IDENTIFIER4 = "identifier4";
-var KEYWORD1 = "keyword1";
-var KEYWORD2 = "keyword2";
-var KEYWORD3 = "keyword3";
-var NUMBER = "number";
-var OPERATOR = "operator";
-var PUNCTUATION = "punctuation";
-var STRING = "string";
-var ROOT2 = "root";
-var TEMPLATE = "template";
-var nanolightTs = /* @__PURE__ */ createLexer((chunk, name) => name != null ? ["span", { class: name }, chunk] : chunk, [COMMENT, /^#!.*/], [COMMENT, /\/\*[\s\S]*?(?:\*\/|$)/], [COMMENT, /\/\/.*/], [STRING, /"(?:[^"\\\n]|\\[\s\S])*"?/], [STRING, /'(?:[^'\\\n]|\\[\s\S])*'?/], [STRING, /`(?:[^`\\$]|\\[\s\S]|\$(?!\{))*(?:`|$)/], [STRING, /`(?:[^`\\$]|\\[\s\S]|\$(?!\{))*(?=\$\{)/, { push: TEMPLATE }], [STRING, /(?:[^`\\$]|\\[\s\S]|\$(?!\{))*(?:`|$)/y, { in: TEMPLATE, pop: true }], [STRING, /(?:[^`\\$]|\\[\s\S]|\$(?!\{))+(?=\$\{)/y, { in: TEMPLATE }], [PUNCTUATION, "${", { in: TEMPLATE, push: ROOT2 }], [
-  STRING,
-  /(?<=(?:^|[!%&(*,:;<=>?[^{|}~]|(?<!\+)\+|(?<!-)-|(?<!\.)\b(?:await|case|delete|do|else|in|instanceof|new|of|return|throw|typeof|void|yield))\s*)\/(?![*/])(?:[^\\/[\n]|\\.|\[(?:[^\\\]\n]|\\.)*\]?)+\/[dgimsuvy]*/
-], [NUMBER, /0b[01_]+n?/i], [NUMBER, /0o[0-7_]+n?/i], [NUMBER, /0x[\da-f_]+n?/i], [NUMBER, /(?:\d[\d_]*(?:\.[\d_]+)?|\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?n?/i], [OPERATOR, "!"], [OPERATOR, "!="], [OPERATOR, "!=="], [OPERATOR, "%"], [OPERATOR, "%="], [OPERATOR, "&&"], [OPERATOR, "&&="], [OPERATOR, "&"], [OPERATOR, "&="], [OPERATOR, "*"], [OPERATOR, "**"], [OPERATOR, "**="], [OPERATOR, "*="], [OPERATOR, "+"], [OPERATOR, "++"], [OPERATOR, "+="], [OPERATOR, "-"], [OPERATOR, "--"], [OPERATOR, "-="], [OPERATOR, "..."], [OPERATOR, "/"], [OPERATOR, "/="], [OPERATOR, ":"], [OPERATOR, "<"], [OPERATOR, "<<"], [OPERATOR, "<<="], [OPERATOR, "<="], [OPERATOR, "="], [OPERATOR, "=="], [OPERATOR, "==="], [OPERATOR, "=>"], [OPERATOR, ">"], [OPERATOR, ">="], [OPERATOR, ">>"], [OPERATOR, ">>="], [OPERATOR, ">>>"], [OPERATOR, ">>>="], [OPERATOR, "?"], [OPERATOR, "??"], [OPERATOR, "??="], [OPERATOR, "^"], [OPERATOR, "^="], [OPERATOR, "|"], [OPERATOR, "|="], [OPERATOR, "||"], [OPERATOR, "||="], [OPERATOR, "~"], [OPERATOR, "~="], [OPERATOR, /(?<=\s):/], [PUNCTUATION, "("], [PUNCTUATION, ")"], [PUNCTUATION, ","], [PUNCTUATION, "."], [PUNCTUATION, ":"], [PUNCTUATION, ";"], [PUNCTUATION, /\?\.(?!\d)/], [PUNCTUATION, "["], [PUNCTUATION, "]"], [PUNCTUATION, "{", { push: ROOT2 }], [PUNCTUATION, "}", { pop: true }], [IDENTIFIER2, /(?<=(?<!\.)\.)\p{Ll}[\p{L}\d_$]*(?=[(`])/u], [IDENTIFIER4, /(?<=(?<!\.)\.)\p{Ll}[\p{L}\d_$]*/u], [KEYWORD1, "as"], [KEYWORD1, "async"], [KEYWORD1, "await"], [KEYWORD1, "break"], [KEYWORD1, "case"], [KEYWORD1, "catch"], [KEYWORD1, "class"], [KEYWORD1, "const"], [KEYWORD1, "continue"], [KEYWORD1, "debugger"], [KEYWORD1, "default"], [KEYWORD1, "delete"], [KEYWORD1, "do"], [KEYWORD1, "else"], [KEYWORD1, "export"], [KEYWORD1, "extends"], [KEYWORD1, "finally"], [KEYWORD1, "for"], [KEYWORD1, "from"], [KEYWORD1, "function"], [KEYWORD1, "function*"], [KEYWORD1, "goto"], [KEYWORD1, "if"], [KEYWORD1, "import"], [KEYWORD1, "in"], [KEYWORD1, "instanceof"], [KEYWORD1, "is"], [KEYWORD1, "keyof"], [KEYWORD1, "let"], [KEYWORD1, "new"], [KEYWORD1, "of"], [KEYWORD1, "package"], [KEYWORD1, "return"], [KEYWORD1, "super"], [KEYWORD1, "switch"], [KEYWORD1, "this"], [KEYWORD1, "throw"], [KEYWORD1, "try"], [KEYWORD1, "type"], [KEYWORD1, "typeof"], [KEYWORD1, "var"], [KEYWORD1, "void"], [KEYWORD1, "while"], [KEYWORD1, "with"], [KEYWORD1, "yield"], [KEYWORD1, "yield*"], [KEYWORD2, "false"], [KEYWORD2, "Infinity"], [KEYWORD2, "NaN"], [KEYWORD2, "null"], [KEYWORD2, "true"], [KEYWORD2, "undefined"], [KEYWORD3, "any"], [KEYWORD3, "bigint"], [KEYWORD3, "boolean"], [KEYWORD3, "eval"], [KEYWORD3, "number"], [KEYWORD3, "string"], [KEYWORD3, "symbol"], [KEYWORD3, "unknown"], [IDENTIFIER2, /@[\p{L}_$][\p{L}\d_$]*/u], [IDENTIFIER1, /#?[\p{Lu}_$][\p{Lu}\d_$]*/u], [IDENTIFIER2, /#?[\p{L}_$][\p{L}\d_$]*(?=[(`])/u], [IDENTIFIER3, /#?\p{Lu}[\p{L}\d_$]*/u], [IDENTIFIER4, /#?[\p{L}_$][\p{L}\d_$]*/u]);
 // src/nnn/rwd.ts
 var rwd = (root, selector, cellWidthPx, cellHeightPx, ...specs) => {
   const main = root[selector] ??= {};
@@ -313,10 +133,7 @@ var rwd = (root, selector, cellWidthPx, cellHeightPx, ...specs) => {
 };
 export {
   c,
-  createLexer,
   h,
-  monokai,
-  nanolightTs,
   rwd,
   s,
   svgUse

package/package.json

@@ -1,20 +1,14 @@
 {
   "name": "@jackens/nnn",
-  "version": "2026.9.29",
+  "version": "2026.10.1",
   "description": "Jackens’ JavaScript helpers.",
   "keywords": [
     "CSS-in-JS",
     "HyperScript",
     "JS-to-CSS",
-    "Monokai",
-    "RWD",
-    "Responsive Web Design",
-    "SVG",
-    "highlight",
-    "lexer",
-    "nanolight",
     "nnn",
-    "tokenize"
+    "Responsive Web Design",
+    "RWD"
   ],
   "license": "MIT",
   "author": "Jackens",