@jackens/nnn 2025.11.11 → 2025.11.28

package/nnn.d.ts

@@ -60,6 +60,16 @@ export declare const h: {
     <N extends Node>(node: N, ...args1: HArgs1[]): N;
     (tag_or_node: string | Node, ...args1: HArgs1[]): Node;
 };
+/**
+ * Generic syntax highlighting helper (see also `nanolight_ts`).
+ *
+ * - Each entry in `config` is a tuple of:
+ *   - CSS class name to apply
+ *   - regular expression pattern to match (should include exactly one capturing group that matches the entire desired text).
+ */
+export declare const nanolight: (...config: [string, RegExp][]) => (code: string) => HArgs1[];
+/** TypeScript syntax highlighting helper (built on `nanolight`). */
+export declare const nanolight_ts: (code: string) => HArgs1[];
 /**
  * A lightweight [HyperScript](https://github.com/hyperhype/hyperscript)-style helper for creating and modifying `SVGElement`s (see also `h`).
  *
@@ -109,10 +119,6 @@ export declare const is_string: (arg: unknown) => arg is string;
  * ```
  */
 export declare const js_on_parse: (handlers: Record<PropertyKey, Function>, text: string) => any;
-/** Generic syntax highlighting helper (see also `nanolight_js`). */
-export declare const nanolight: (pattern: RegExp, highlighters: ((chunk: string, index: number) => HArgs1)[], code: string) => HArgs1[];
-/** JavaScript syntax highlighting helper (built on `nanolight`). */
-export declare const nanolight_js: (code: string) => HArgs1[];
 /** Runtime implementation of TypeScript’s `Pick` (see also `omit`). */
 export declare const pick: <T, K extends keyof T>(ref: T, keys: K[]) => Pick<T, K>;
 /** Runtime implementation of TypeScript’s `Omit` (see also `pick`). */

package/nnn.js

@@ -168,6 +168,21 @@ var _h = (namespace_uri) => {
   return h;
 };
 var h = _h();
+var nanolight = (...config) => {
+  const pattern = new RegExp(config.map((item) => `${item[1]}`.slice(1, -1)).join("|"));
+  const length = config.length + 1;
+  return (code) => {
+    const result = [];
+    code.split(pattern).forEach((chunk, index) => {
+      if (chunk != null && chunk !== "") {
+        index %= length;
+        result.push(index > 0 ? ["span", { class: config[index - 1][0] }, chunk] : chunk);
+      }
+    });
+    return result;
+  };
+};
+var nanolight_ts = nanolight(["yellow", /('.*?'|".*?"|`[\s\S]*?`)/], ["grey", /(\/\/.*?\n|\/\*[\s\S]*?\*\/)/], ["red", /(?<!\w)(as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|export|extends|finally|for|from|function|goto|if|import|in|instanceof|is|keyof|let|new|of|package|return|super|switch|this|throw|try|type|typeof|var|void|while|with|yield)(?!\w)/], ["purple", /(?<!\w)(false|Infinity|NaN|null|true|undefined)(?!\w)/], ["blue", /(?<!\w)(any|bigint|boolean|eval|number|string|symbol|unknown)(?!\w)/], ["red", /([=<>&|!^~*/%+-]|\?\?|\?(?=\s)|(?<=\s):)/], ["grey", /([()[\]{}.,?:;])/], ["purple", /(0x[\dabcdef_]+|0o[01234567_]+|0b[01_]+|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?)/], ["green", /(?<!\w)([$\w]+)(?=\()/], ["purple", /(?<!\w)([A-Z_$][A-Z0-9_$]+)(?!\w)/], ["blue", /(?<!\w)([A-Z][$\w]+)(?!\w)/], ["white", /(?<!\w)([$\w]+)(?!\w)/]);
 var s = _h("http://www.w3.org/2000/svg");
 var svg_use = (id, ...args) => s("svg", ["use", { "xlink:href": "#" + id }], ...args);
 var has_own = (ref, key) => ref != null && Object.hasOwn(ref, key);
@@ -193,26 +208,6 @@ var js_on_parse = (handlers, text) => JSON.parse(text, (key, value) => {
   }
   return value;
 });
-var nanolight = (pattern, highlighters, code) => {
-  const result = [];
-  code.split(pattern).forEach((chunk, index) => {
-    if (chunk != null && chunk !== "") {
-      index %= highlighters.length;
-      result.push(highlighters[index](chunk, index));
-    }
-  });
-  return result;
-};
-var nanolight_js = nanolight.bind(0, /('.*?'|".*?"|`[\s\S]*?`)|(\/\/.*?\n|\/\*[\s\S]*?\*\/)|(any|bigint|break|boolean|case|catch|class|const|continue|debugger|default|delete|do|else|eval|export|extends|false|finally|for|from|function|goto|if|import|in|instanceof|is|keyof|let|NaN|new|number|null|package|return|string|super|switch|symbol|this|throw|true|try|type|typeof|undefined|unknown|var|void|while|with|yield)(?!\w)|([<>=.?:&|!^~*/%+-])|(0x[\dabcdef_]+|0o[01234567_]+|0b[01_]+|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?)|([$\w]+)(?=\()|([$\wąćęłńóśżźĄĆĘŁŃÓŚŻŹ]+)/, [
-  (chunk) => chunk,
-  (chunk) => ["span", { class: "string" }, chunk],
-  (chunk) => ["span", { class: "comment" }, chunk],
-  (chunk) => ["span", { class: "keyword" }, chunk],
-  (chunk) => ["span", { class: "operator" }, chunk],
-  (chunk) => ["span", { class: "number" }, chunk],
-  (chunk) => ["span", { class: "function" }, chunk],
-  (chunk) => ["span", { class: "literal" }, chunk]
-]);
 var pick = (ref, keys) => Object.fromEntries(Object.entries(ref).filter(([key]) => keys.includes(key)));
 var omit = (ref, keys) => Object.fromEntries(Object.entries(ref).filter(([key]) => !keys.includes(key)));
 var pl_ural = (singular, plural_2, plural_5, value) => {
@@ -241,7 +236,7 @@ export {
   pl_ural,
   pick,
   omit,
-  nanolight_js,
+  nanolight_ts,
   nanolight,
   js_on_parse,
   is_string,

package/package.json

@@ -38,5 +38,5 @@
   "name": "@jackens/nnn",
   "type": "module",
   "types": "nnn.d.ts",
-  "version": "2025.11.11"
+  "version": "2025.11.28"
 }

package/readme.md

@@ -46,8 +46,8 @@ import { «something» } from './node_modules/@jackens/nnn/nnn.js'
 - [`is_record`](#is_record): Checks whether the argument is a plain object record.
 - [`is_string`](#is_string): Checks whether the argument is a string.
 - [`js_on_parse`](#js_on_parse): `JSON.parse` with “JavaScript turned on”.
-- [`nanolight`](#nanolight): Generic syntax highlighting helper (see also `nanolight_js`).
-- [`nanolight_js`](#nanolight_js): JavaScript syntax highlighting helper (built on `nanolight`).
+- [`nanolight`](#nanolight): Generic syntax highlighting helper (see also `nanolight_ts`).
+- [`nanolight_ts`](#nanolight_ts): TypeScript syntax highlighting helper (built on `nanolight`).
 - [`omit`](#omit): Runtime implementation of TypeScript’s `Omit` (see also `pick`).
 - [`pick`](#pick): Runtime implementation of TypeScript’s `Pick` (see also `omit`).
 - [`pl_ural`](#pl_ural): Chooses the appropriate Polish noun form based on a numeric value.
@@ -584,7 +584,7 @@ expect(is_number(42)).to.be.true
 expect(is_number(Number(42))).to.be.true
 expect(is_number(new Number(42))).to.be.false
 expect(is_number(NaN)).to.be.true
-expect(is_finite_number(Infinity)).to.be.true
+expect(is_number(Infinity)).to.be.true
 ```
 
 ### is_record
@@ -696,39 +696,48 @@ expect(actual).to.deep.equal(expected)
 ### nanolight
 
 ```ts
-const nanolight: (pattern: RegExp, highlighters: ((chunk: string, index: number) => HArgs1)[], code: string) => HArgs1[];
+const nanolight: (...config: [string, RegExp][]) => (code: string) => HArgs1[];
 ```
 
-Generic syntax highlighting helper (see also `nanolight_js`).
+Generic syntax highlighting helper (see also `nanolight_ts`).
 
-### nanolight_js
+- Each entry in `config` is a tuple of:
+  - CSS class name to apply
+  - regular expression pattern to match (should include exactly one capturing group that matches the entire desired text).
+
+### nanolight_ts
 
 ```ts
-const nanolight_js: (code: string) => HArgs1[];
+const nanolight_ts: (code: string) => HArgs1[];
 ```
 
-JavaScript syntax highlighting helper (built on `nanolight`).
+TypeScript syntax highlighting helper (built on `nanolight`).
 
 #### Usage Examples
 
 ```ts
 const code_js = "const answer_to_life_the_universe_and_everything = { 42: 42 }['42'] /* 42 */"
 
-expect(nanolight_js(code_js)).to.deep.equal([
-  ['span', { class: 'keyword' }, 'const'],
+expect(nanolight_ts(code_js)).to.deep.equal([
+  ['span', { class: 'red' }, 'const'],
+  ' ',
+  ['span', { class: 'white' }, 'answer_to_life_the_universe_and_everything'],
+  ' ',
+  ['span', { class: 'red' }, '='],
+  ' ',
+  ['span', { class: 'grey' }, '{'],
+  ' ',
+  ['span', { class: 'purple' }, '42'],
+  ['span', { class: 'grey' }, ':'],
   ' ',
-  ['span', { class: 'literal' }, 'answer_to_life_the_universe_and_everything'],
+  ['span', { class: 'purple' }, '42'],
   ' ',
-  ['span', { class: 'operator' }, '='],
-  ' { ',
-  ['span', { class: 'number' }, '42'],
-  ['span', { class: 'operator' }, ':'],
+  ['span', { class: 'grey' }, '}'],
+  ['span', { class: 'grey' }, '['],
+  ['span', { class: 'yellow' }, "'42'"],
+  ['span', { class: 'grey' }, ']'],
   ' ',
-  ['span', { class: 'number' }, '42'],
-  ' }[',
-  ['span', { class: 'string' }, "'42'"],
-  '] ',
-  ['span', { class: 'comment' }, '/* 42 */']
+  ['span', { class: 'grey' }, '/* 42 */']
 ])
 ```
 
@@ -846,7 +855,7 @@ A responsive‑web‑design helper that generates CSS rules for a grid layout.
 #### Usage Examples
 
 ```ts
-const css: CRoot = {
+const style: CRoot = {
   body: {
     margin: 0
   },
@@ -858,9 +867,9 @@ const css: CRoot = {
   }
 }
 
-rwd(css, '.r6', 200, 50, [6], [3], [1, 1, 2])
+rwd(style, '.r6', 200, 50, [6], [3], [1, 1, 2])
 
-expect(css).to.deep.equal({
+expect(style).to.deep.equal({
   body: {
     margin: 0
   },