@jackens/nnn 2026.9.29 → 2026.9.30

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.9.30`).
 
 ## Installation
 
@@ -149,6 +149,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 +178,8 @@ const expected = `
 expect(actual).toBe(expected)
 ```
 
+Selectors can be nested at any depth:
+
 ```ts
 const actual = c({
   a: {
@@ -205,6 +209,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 +286,8 @@ const expected = `
 expect(actual).toBe(expected)
 ```
 
+Comma-separated nested selectors are expanded:
+
 ```ts
 const actual = c({
   a: {
@@ -304,6 +312,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 +336,8 @@ const expected = `
 expect(actual).toBe(expected)
 ```
 
+Comma-separated selectors at both levels produce all combinations:
+
 ```ts
 const actual = c({
   '.a,.b': {
@@ -348,6 +360,8 @@ const expected = `
 expect(actual).toBe(expected)
 ```
 
+CSS custom properties from nested `--` objects:
+
 ```ts
 const actual = c({
   ':root$$monokai': {
@@ -478,6 +492,8 @@ A lexer function that accepts an input string and returns an array of decorated
 
 #### Usage Examples
 
+Tokenizing keywords and strings with `RegExp` patterns:
+
 ```ts
 const lexer = createLexer(
   (chunk, metadata) => ({ chunk, metadata }),
@@ -498,6 +514,8 @@ expect(result).toEqual([
 ])
 ```
 
+String patterns are matched literally and unmatched text gets `undefined` metadata:
+
 ```ts
 const lexer = createLexer((chunk, metadata) => `${metadata}:${chunk}`, ['tag', 'BEGIN'], ['end', 'END'])
 
@@ -506,6 +524,8 @@ 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/])
 
@@ -514,6 +534,8 @@ const result = lexer('')
 expect(result).toEqual([])
 ```
 
+`^` anchors to the start of the whole input:
+
 ```ts
 const lexer = createLexer((chunk, metadata) => ({ chunk, metadata }), ['start', /^test/])
 
@@ -525,6 +547,8 @@ expect(result).toEqual([
 ])
 ```
 
+Matches starting earlier take precedence regardless of spec order:
+
 ```ts
 const lexer = createLexer((chunk, metadata) => metadata, ['later', /x/], ['earlier', /y/])
 
@@ -533,6 +557,8 @@ 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'])
 
@@ -541,6 +567,8 @@ const result = lexer('abc')
 expect(result).toEqual(['abc'])
 ```
 
+Empty string patterns are ignored:
+
 ```ts
 const lexer = createLexer(chunk => chunk, ['empty', ''], ['word', /\w+/])
 
@@ -549,6 +577,8 @@ 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/])
 
@@ -557,6 +587,8 @@ 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'])
 
@@ -565,6 +597,8 @@ 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}`,
@@ -578,6 +612,8 @@ 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}`,
@@ -590,6 +626,8 @@ 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/])
 
@@ -598,6 +636,8 @@ 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'])
 
@@ -606,6 +646,8 @@ 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*/])
 
@@ -650,6 +692,8 @@ The created `HTMLElement` or the modified node.
 
 #### Usage Examples
 
+Creating elements, appending children and setting properties:
+
 ```ts
 const b = h('b')
 
@@ -670,6 +714,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 +726,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 +738,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 +751,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 +772,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 +788,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' })
 
@@ -761,11 +817,14 @@ It styles `pre` and `code>span` elements with the class names produced by [`nano
 
 #### 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>' +
@@ -795,6 +854,8 @@ An array of [`HArgs1`](#HArgs1) elements suitable for rendering with [`h`](#h):
 
 #### Usage Examples
 
+Keywords, identifiers, operators, numbers, punctuation, strings and comments:
+
 ```ts
 const codeJs = 'const answerToLifeTheUniverseAndEverything = ' + "{ 42: 42 }['42'] /* 42 */"
 
@@ -821,6 +882,8 @@ expect(nanolightTs(codeJs)).toEqual([
 ])
 ```
 
+Line comments:
+
 ```ts
 const codeJs = 'const x = 42 // answer'
 
@@ -837,13 +900,24 @@ expect(nanolightTs(codeJs)).toEqual([
 ])
 ```
 
+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: 'string' }, '/a\\/b[/]c/gi'],
+  ['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' }, '('],
@@ -870,10 +944,24 @@ expect(nanolightTs('a / b / c')).toEqual([
 expect(nanolightTs('return / x /')).toEqual([
   ['span', { class: 'keyword1' }, 'return'],
   ' ',
-  ['span', { class: 'string' }, '/ x /'],
+  ['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 '],
@@ -910,6 +998,8 @@ expect(nanolightTs('`${x}` / 2')).toEqual([
 ])
 ```
 
+Comment markers inside strings and unterminated comments:
+
 ```ts
 expect(nanolightTs('"a // b" // c')).toEqual([
   ['span', { class: 'string' }, '"a // b"'],
@@ -924,6 +1014,8 @@ expect(nanolightTs("'it\\'s' /* x")).toEqual([
 ])
 ```
 
+Hexadecimal, BigInt, numeric separators and exponents:
+
 ```ts
 expect(nanolightTs('0xFF + 1_000n + .5e-3')).toEqual([
   ['span', { class: 'number' }, '0xFF'],
@@ -938,6 +1030,8 @@ expect(nanolightTs('0xFF + 1_000n + .5e-3')).toEqual([
 ])
 ```
 
+Division after `++` and optional chaining vs ternary with decimals:
+
 ```ts
 expect(nanolightTs('a++ / 2 / b')).toEqual([
   ['span', { class: 'identifier4' }, 'a'],
@@ -963,6 +1057,8 @@ expect(nanolightTs('x?.5:a?.b')).toEqual([
 ])
 ```
 
+Keywords as property names and method calls:
+
 ```ts
 expect(nanolightTs('p.catch(obj.in, ...this)')).toEqual([
   ['span', { class: 'identifier4' }, 'p'],
@@ -980,6 +1076,8 @@ expect(nanolightTs('p.catch(obj.in, ...this)')).toEqual([
 ])
 ```
 
+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'],
@@ -1002,6 +1100,64 @@ expect(nanolightTs('#!/usr/bin/env bun\n@sealed class A { #x = 1 }')).toEqual([
 ])
 ```
 
+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
@@ -1043,6 +1199,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 +1282,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 +1342,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.js

@@ -201,6 +201,7 @@ var monokai = {
       number: "#7058be",
       operator: "#e14775",
       punctuation: "#918c8e",
+      regexp: "#e16032",
       string: "#cc7a0a"
     }
   },
@@ -233,6 +234,7 @@ var monokai = {
     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": {
@@ -255,6 +257,7 @@ var monokai = {
         number: "#ae81ff",
         operator: "#ff6188",
         punctuation: "#727072",
+        regexp: "#fc9867",
         string: "#ffd866"
       }
     }
@@ -280,13 +283,20 @@ 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 }], [
-  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]);
+  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] ??= {};

package/package.json

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