@jackens/nnn 2026.9.30 → 2026.10.1

package/README.md

@@ -1,6 +1,6 @@
 # nnn
 
-A collection of Jackens’ JavaScript helper utilities (version: `2026.9.30`).
+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
@@ -452,210 +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
-
-Tokenizing keywords and strings with `RegExp` patterns:
-
-```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' },
-])
-```
-
-String patterns are matched literally and unmatched text gets `undefined` metadata:
-
-```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'])
-```
-
-Empty input produces an empty result:
-
-```ts
-const lexer = createLexer(chunk => chunk, ['test', /test/])
-
-const result = lexer('')
-
-expect(result).toEqual([])
-```
-
-`^` anchors to the start of the whole input:
-
-```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 },
-])
-```
-
-Matches starting earlier take precedence regardless of spec order:
-
-```ts
-const lexer = createLexer((chunk, metadata) => metadata, ['later', /x/], ['earlier', /y/])
-
-const result = lexer('yx')
-
-expect(result).toEqual(['earlier', 'later'])
-```
-
-The longer match wins at the same position:
-
-```ts
-const lexer = createLexer(chunk => chunk, ['short', 'a'], ['long', 'abc'])
-
-const result = lexer('abc')
-
-expect(result).toEqual(['abc'])
-```
-
-Empty string patterns are ignored:
-
-```ts
-const lexer = createLexer(chunk => chunk, ['empty', ''], ['word', /\w+/])
-
-const result = lexer('hello')
-
-expect(result).toEqual(['hello'])
-```
-
-Input without any match is returned as a single chunk:
-
-```ts
-const lexer = createLexer(chunk => chunk, ['test', /xyz/])
-
-const result = lexer('abc')
-
-expect(result).toEqual(['abc'])
-```
-
-Consecutive matches are returned as separate chunks:
-
-```ts
-const lexer = createLexer((_chunk, metadata) => metadata, ['a', 'a'], ['b', 'b'])
-
-const result = lexer('aabb')
-
-expect(result).toEqual(['a', 'a', 'b', 'b'])
-```
-
-Entering and leaving states with `push` and `pop`:
-
-```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)'])
-```
-
-Nested states with a spec active in multiple states:
-
-```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:}'])
-```
-
-Lookbehinds see the text preceding the current position:
-
-```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'])
-```
-
-Sticky patterns match only at the current position:
-
-```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'])
-```
-
-Empty `RegExp` matches are skipped:
-
-```ts
-const lexer = createLexer((chunk, metadata) => `${metadata}:${chunk}`, ['digits', /\d*/])
-
-const result = lexer('ab12')
-
-expect(result).toEqual(['undefined:ab', 'digits:12'])
-```
-
 ### h
 
 ```ts
@@ -806,358 +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
-
-Styling `nanolightTs` output:
-
-```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('code>span.regexp{color:var(--regexp)}')
-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
-
-Keywords, identifiers, operators, numbers, punctuation, strings and comments:
-
-```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 */'],
-])
-```
-
-Line comments:
-
-```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'],
-])
-```
-
-Regex literals vs division:
-
-```ts
-expect(nanolightTs('x = /a\\/b[/]c/gi.test(y) / 2')).toEqual([
-  ['span', { class: 'identifier4' }, 'x'],
-  ' ',
-  ['span', { class: 'operator' }, '='],
-  ' ',
-  ['span', { class: 'regexp' }, '/'],
-  ['span', { class: 'regexp' }, 'a'],
-  ['span', { class: 'keyword2' }, '\\/'],
-  ['span', { class: 'regexp' }, 'b'],
-  ['span', { class: 'punctuation' }, '['],
-  ['span', { class: 'regexp' }, '/'],
-  ['span', { class: 'punctuation' }, ']'],
-  ['span', { class: 'regexp' }, 'c'],
-  ['span', { class: 'regexp' }, '/'],
-  ['span', { class: 'keyword1' }, '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: 'regexp' }, '/'],
-  ['span', { class: 'regexp' }, ' x '],
-  ['span', { class: 'regexp' }, '/'],
-])
-
-expect(nanolightTs('x = /=/g')).toEqual([
-  ['span', { class: 'identifier4' }, 'x'],
-  ' ',
-  ['span', { class: 'operator' }, '='],
-  ' ',
-  ['span', { class: 'regexp' }, '/='],
-  ['span', { class: 'regexp' }, '/'],
-  ['span', { class: 'keyword1' }, 'g'],
-])
-```
-
-Nested template literals with substitutions:
-
-```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'],
-])
-```
-
-Comment markers inside strings and unterminated comments:
-
-```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'],
-])
-```
-
-Hexadecimal, BigInt, numeric separators and exponents:
-
-```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'],
-])
-```
-
-Division after `++` and optional chaining vs ternary with decimals:
-
-```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'],
-])
-```
-
-Keywords as property names and method calls:
-
-```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' }, ')'],
-])
-```
-
-Hashbang, decorators and private class members:
-
-```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' }, '}'],
-])
-```
-
-Escapes, anchors, quantifiers, groups, character sets and flags inside regex literals:
-
-```ts
-expect(nanolightTs('/^(?:\\d{1,3}|[^a-z\\]])+?\\b(?<year>\\d{4})-\\k<year>\\1$/u')).toEqual([
-  ['span', { class: 'regexp' }, '/'],
-  ['span', { class: 'keyword1' }, '^'],
-  ['span', { class: 'punctuation' }, '(?:'],
-  ['span', { class: 'keyword3' }, '\\d'],
-  ['span', { class: 'operator' }, '{1,3}'],
-  ['span', { class: 'operator' }, '|'],
-  ['span', { class: 'punctuation' }, '['],
-  ['span', { class: 'operator' }, '^'],
-  ['span', { class: 'regexp' }, 'a'],
-  ['span', { class: 'operator' }, '-'],
-  ['span', { class: 'regexp' }, 'z'],
-  ['span', { class: 'keyword2' }, '\\]'],
-  ['span', { class: 'punctuation' }, ']'],
-  ['span', { class: 'punctuation' }, ')'],
-  ['span', { class: 'operator' }, '+?'],
-  ['span', { class: 'keyword1' }, '\\b'],
-  ['span', { class: 'punctuation' }, '(?<'],
-  ['span', { class: 'identifier2' }, 'year'],
-  ['span', { class: 'punctuation' }, '>'],
-  ['span', { class: 'keyword3' }, '\\d'],
-  ['span', { class: 'operator' }, '{4}'],
-  ['span', { class: 'punctuation' }, ')'],
-  ['span', { class: 'regexp' }, '-'],
-  ['span', { class: 'identifier2' }, '\\k<year>'],
-  ['span', { class: 'identifier2' }, '\\1'],
-  ['span', { class: 'keyword1' }, '$'],
-  ['span', { class: 'regexp' }, '/'],
-  ['span', { class: 'keyword1' }, 'u'],
-])
-
-expect(nanolightTs('/(?<=\\$)(?!0)\\p{L}+\\.\\u{1F600}|\\x41[.\\b-]/v')).toEqual([
-  ['span', { class: 'regexp' }, '/'],
-  ['span', { class: 'punctuation' }, '(?<='],
-  ['span', { class: 'keyword2' }, '\\$'],
-  ['span', { class: 'punctuation' }, ')'],
-  ['span', { class: 'punctuation' }, '(?!'],
-  ['span', { class: 'regexp' }, '0'],
-  ['span', { class: 'punctuation' }, ')'],
-  ['span', { class: 'keyword3' }, '\\p{L}'],
-  ['span', { class: 'operator' }, '+'],
-  ['span', { class: 'keyword2' }, '\\.'],
-  ['span', { class: 'keyword2' }, '\\u{1F600}'],
-  ['span', { class: 'operator' }, '|'],
-  ['span', { class: 'keyword2' }, '\\x41'],
-  ['span', { class: 'punctuation' }, '['],
-  ['span', { class: 'regexp' }, '.'],
-  ['span', { class: 'keyword2' }, '\\b'],
-  ['span', { class: 'regexp' }, '-'],
-  ['span', { class: 'punctuation' }, ']'],
-  ['span', { class: 'regexp' }, '/'],
-  ['span', { class: 'keyword1' }, 'v'],
-])
-```
-
 ### rwd
 
 ```ts

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,123 +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",
-      regexp: "#e16032",
-      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)" },
-    regexp: { color: "var(--regexp)" },
-    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",
-        regexp: "#fc9867",
-        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 REGEXP = "regexp";
-var STRING = "string";
-var ROOT2 = "root";
-var TEMPLATE = "template";
-var REGEXP_BODY = "regexpBody";
-var REGEXP_FLAGS = "regexpFlags";
-var REGEXP_GROUP_NAME = "regexpGroupName";
-var REGEXP_SET = "regexpSet";
-var REGEXP_SET_NEGATION = "regexpSetNegation";
-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 }], [
-  REGEXP,
-  /(?<=(?:^|[!%&(*,:;<=>?[^{|}~]|(?<!\+)\+|(?<!-)-|(?<!\.)\b(?:await|case|delete|do|else|in|instanceof|new|of|return|throw|typeof|void|yield))\s*)\/(?![*/])(?=(?:[^\\/[\n]|\\.|\[(?:[^\\\]\n]|\\.)*\])+\/)=?/,
-  { push: REGEXP_BODY }
-], [REGEXP, /\/(?=[dgimsuvy])/y, { in: REGEXP_BODY, pop: true, push: REGEXP_FLAGS }], [REGEXP, /\/(?![dgimsuvy])/y, { in: REGEXP_BODY, pop: true }], [KEYWORD1, /[dgimsuvy]+/y, { in: REGEXP_FLAGS, pop: true }], [IDENTIFIER2, /\\[1-9]\d*|\\k<[\p{L}_$][\p{L}\d_$]*>/uy, { in: REGEXP_BODY }], [KEYWORD1, /\\[bB]/y, { in: REGEXP_BODY }], [KEYWORD3, /\\[dDsSwW]|\\[pP]\{[\w=]*\}/y, { in: [REGEXP_BODY, REGEXP_SET] }], [KEYWORD2, /\\(?:c[A-Za-z]|x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|.)/uy, { in: [REGEXP_BODY, REGEXP_SET] }], [KEYWORD1, /[$^]/y, { in: REGEXP_BODY }], [KEYWORD3, ".", { in: REGEXP_BODY }], [OPERATOR, /(?:[*+?]|\{\d+(?:,\d*)?\})\??/y, { in: REGEXP_BODY }], [OPERATOR, "|", { in: REGEXP_BODY }], [PUNCTUATION, /\((?:\?(?:[:=!]|<[=!]))?/y, { in: REGEXP_BODY }], [PUNCTUATION, /\(\?<(?=[\p{L}_$][\p{L}\d_$]*>)/uy, { in: REGEXP_BODY, push: REGEXP_GROUP_NAME }], [IDENTIFIER2, /[\p{L}_$][\p{L}\d_$]*/uy, { in: REGEXP_GROUP_NAME }], [PUNCTUATION, ">", { in: REGEXP_GROUP_NAME, pop: true }], [PUNCTUATION, ")", { in: REGEXP_BODY }], [PUNCTUATION, /\[(?!\^)/y, { in: REGEXP_BODY, push: REGEXP_SET }], [PUNCTUATION, /\[(?=\^)/y, { in: REGEXP_BODY, push: REGEXP_SET_NEGATION }], [OPERATOR, "^", { in: REGEXP_SET_NEGATION, pop: true, push: REGEXP_SET }], [OPERATOR, /(?<!(?<!\\)\[\^?)-(?!\])/y, { in: REGEXP_SET }], [PUNCTUATION, "]", { in: REGEXP_SET, pop: true }], [REGEXP, /[^\\/[()|?*+{^$.\n]+/uy, { in: REGEXP_BODY }], [REGEXP, /[^\\\]\-\n]+/uy, { in: REGEXP_SET }], [REGEXP, /[^\n]/uy, { in: [REGEXP_BODY, REGEXP_SET] }], [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] ??= {};
@@ -323,10 +133,7 @@ var rwd = (root, selector, cellWidthPx, cellHeightPx, ...specs) => {
 };
 export {
   c,
-  createLexer,
   h,
-  monokai,
-  nanolightTs,
   rwd,
   s,
   svgUse

package/package.json

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