@promptctl/rich-js 0.18.1 → 0.19.0

package/dist/core/highlighter.d.ts

@@ -24,10 +24,10 @@ export declare class ReprHighlighter extends RegexHighlighter {
 }
 export declare class JSONHighlighter extends RegexHighlighter {
     static baseStyle: string;
-    static highlights: string[];
+    static highlights: RegExp[];
     highlight(text: RichText): void;
 }
 export declare class ISO8601Highlighter extends RegexHighlighter {
     static baseStyle: string;
-    static highlights: RegExp[];
+    static highlights: string[];
 }

package/dist/core/highlighter.js

@@ -31,71 +31,100 @@ export class RegexHighlighter extends Highlighter {
         // Literal mode: "bold red" → applied directly to every match
         const isNamespace = baseStyle.endsWith(".");
         for (const pattern of ctor.highlights) {
-            const re = pattern instanceof RegExp
-                ? new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g")
-                : new RegExp(pattern, "g");
-            let match;
-            while ((match = re.exec(text.plain)) !== null) {
-                if (match[0].length === 0) {
-                    re.lastIndex++;
-                    continue;
-                }
-                if (match.groups) {
-                    let searchFrom = 0;
-                    for (const [groupName, groupValue] of Object.entries(match.groups)) {
-                        if (groupValue !== undefined) {
-                            const posInMatch = match[0].indexOf(groupValue, searchFrom);
-                            if (posInMatch >= 0) {
-                                const start = match.index + posInMatch;
-                                const style = isNamespace
-                                    ? `${baseStyle}${groupName}`
-                                    : baseStyle || groupName;
-                                text.stylize(style, start, start + groupValue.length);
-                                searchFrom = posInMatch + groupValue.length;
-                            }
-                        }
-                    }
+            // `d` reports where each group matched, as Python's `match.span(name)`
+            // does; searching the match for the group's text finds the first copy
+            // of it, which is not always the one the group captured.
+            const source = pattern instanceof RegExp ? pattern.source : pattern;
+            const flags = new Set([...(pattern instanceof RegExp ? pattern.flags : ""), "g", "d"]);
+            for (const match of text.plain.matchAll(new RegExp(source, [...flags].join("")))) {
+                if (match.indices === undefined)
+                    throw new Error("a match of a `d`-flag pattern carries indices");
+                // Group definition order, as Rich's `groupdict()`: a later group's span
+                // lands on top of an earlier one's.
+                for (const [groupName, span] of Object.entries(match.indices.groups ?? {})) {
+                    if (span === undefined || span[1] <= span[0])
+                        continue;
+                    const style = isNamespace ? `${baseStyle}${groupName}` : baseStyle || groupName;
+                    text.stylize(style, span[0], span[1]);
                 }
             }
         }
     }
 }
+// --- Python's regex classes ---
+// Rich compiles its patterns on a `str`, where Python's `\w`, `\b` and `\d` are
+// Unicode-aware; JavaScript's are ASCII even under `u`, so `café=1` would lose
+// its attribute name and `étrue` would gain a `true`. These spell Python's for
+// the `u` flag for ReprHighlighter and JSONHighlighter. `.` is spelled `[^\n]`
+// because Python's dot stops only at `\n`, JavaScript's at `\r`, U+2028 and
+// U+2029 too.
+const W = String.raw `\p{L}\p{N}_`;
+const WB = String.raw `(?:(?<=[${W}])(?![${W}])|(?<![${W}])(?=[${W}]))`;
+const NWB = String.raw `(?:(?<=[${W}])(?=[${W}])|(?<![${W}])(?![${W}]))`;
+const D = String.raw `\p{Nd}`;
+// Rich's `[0-9]+\.?[0-9]*`, the digits of a number with an optional fraction,
+// spelled so a digit run has one way to split. Rich's spelling can hand any
+// prefix of a run to `[0-9]+` and the rest to `[0-9]*`, and a run that fails
+// the boundary after it is retried at every split: quadratic in its length.
+// Both spellings match the same strings and try them in the same order.
+const DECIMAL = String.raw `[0-9]+(?:\.[0-9]*)?`;
 // --- ReprHighlighter ---
+// Rich 15.0.0's patterns.
 // [LAW:one-type-per-behavior] All repr patterns use the same RegexHighlighter mechanism
 export class ReprHighlighter extends RegexHighlighter {
     static baseStyle = "repr.";
     static highlights = [
-        // URLs
-        /(?<url>https?:\/\/[^\s<>"']+)/g,
-        // UUIDs
-        /(?<uuid>[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/gi,
-        // Quoted strings
-        /(?<str>'[^']*'|"[^"]*")/g,
-        // Booleans
-        /(?<bool>\btrue\b|\bfalse\b)/g,
-        // None/null/undefined
-        /(?<none>\bnull\b|\bundefined\b|\bNone\b)/g,
-        // Numbers (integers and floats)
-        /(?<number>(?<!\w)-?(?:0x[0-9a-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)(?!\w))/gi,
+        // `tag_contents` runs to the text's last `>`, so only the text's first `<`
+        // can open a tag; the lookbehind starts the match there and nowhere else,
+        // where Rich retries every later `<` and rescans to the end each time. The
+        // lookahead asks once whether any `>` follows; without it, a `<` before a
+        // long name with no `>` rescans to the end for every length of the name.
+        new RegExp(String.raw `(?<tag_start><)(?<=^[^<]*<)(?=[^]*>)(?<tag_name>[\-${W}.:|]*)(?<tag_contents>[^]*)(?<tag_end>>)`, "u"),
+        new RegExp(String.raw `(?<attrib_name>[${W}]{1,50})=(?<attrib_value>"?[${W}]+"?)?`, "u"),
+        new RegExp(String.raw `(?<brace>[\][{}()])`, "u"),
+        // [LAW:dataflow-not-control-flow] One alternation, scanned once, as Rich's
+        // `_combine_regex` joins it: where two could match, the earlier claims it.
+        new RegExp([
+            String.raw `(?<ipv4>[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})`,
+            String.raw `(?<ipv6>([A-Fa-f0-9]{1,4}::?){1,7}[A-Fa-f0-9]{1,4})`,
+            String.raw `(?<eui64>(?:[0-9A-Fa-f]{1,2}-){7}[0-9A-Fa-f]{1,2}|(?:[0-9A-Fa-f]{1,2}:){7}[0-9A-Fa-f]{1,2}|(?:[0-9A-Fa-f]{4}\.){3}[0-9A-Fa-f]{4})`,
+            String.raw `(?<eui48>(?:[0-9A-Fa-f]{1,2}-){5}[0-9A-Fa-f]{1,2}|(?:[0-9A-Fa-f]{1,2}:){5}[0-9A-Fa-f]{1,2}|(?:[0-9A-Fa-f]{4}\.){2}[0-9A-Fa-f]{4})`,
+            String.raw `(?<uuid>[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12})`,
+            // Departs from Rich: a call name starts a word, so the run is scanned
+            // for its `(` once, not again from each of its characters. Rich also
+            // styles a name that starts where another match ended mid-word, the
+            // `foo` of `aa-bb-cc-dd-ee-fffoo(`; this leaves it to the patterns
+            // after this one, so it is plain or, as `true` in `-1.true(`, theirs.
+            String.raw `(?<call>(?<![${W}.])[${W}.]*?)\(`,
+            // JavaScript's `true`, `false`, `null` and `undefined` beside Python's
+            // names: `Pretty` draws JavaScript values through this highlighter.
+            String.raw `${WB}(?<bool_true>True|true)${WB}|${WB}(?<bool_false>False|false)${WB}|${WB}(?<none>None|null|undefined)${WB}`,
+            String.raw `(?<ellipsis>\.\.\.)`,
+            String.raw `(?<number_complex>(?<![${W}])(?:-?${DECIMAL}(?:e[\-+]?${D}+?)?)(?:[\-+](?:${DECIMAL}(?:e[\-+]?${D}+)?))?j)`,
+            String.raw `(?<number>(?<![${W}])-?${DECIMAL}(e[\-+]?${D}+?)?${WB}|0x[0-9a-fA-F]*)`,
+            String.raw `(?<path>${NWB}(\/[\-${W}._+]+)*\/)(?<filename>[\-${W}._+]*)?`,
+            String.raw `(?<![\\${W}])(?<str>b?'''[^\n]*?(?<!\\)'''|b?'[^\n]*?(?<!\\)'|b?"""[^\n]*?(?<!\\)"""|b?"[^\n]*?(?<!\\)")`,
+            String.raw `(?<url>(file|https|http|ws|wss):\/\/[\-0-9a-zA-Z$_+!\x60(),.?\/;:&=%#~@]*)`,
+        ].join("|"), "u"),
     ];
 }
 // --- JSONHighlighter ---
-// A JSON string as Python Rich 9d8f9a3 matches one, `b` bytes prefix included:
-// an opening quote with no backslash or word character before it, through the
+// A JSON string as Rich 15.0.0 matches one, `b` bytes prefix included: an
+// opening quote with no backslash or word character before it, through the
 // first quote with no backslash before it, so an escaped quote stays inside.
-const JSON_STR = String.raw `(?<![\\\w])(?<str>b?".*?(?<!\\)")`;
+const JSON_STR = String.raw `(?<![\\${W}])(?<str>b?"[^\n]*?(?<!\\)")`;
 export class JSONHighlighter extends RegexHighlighter {
     static baseStyle = "json.";
     // [LAW:dataflow-not-control-flow] One alternation, scanned once, as Rich's
     // `_combine_regex` joins it. A token claims its characters where the scan
     // meets it, so the `true` and `12` inside `"true 12"` belong to the string.
     static highlights = [
-        [
+        new RegExp([
             String.raw `(?<brace>[\{\[\(\)\]\}])`,
-            String.raw `\b(?<bool_true>true)\b|\b(?<bool_false>false)\b|\b(?<null>null)\b`,
-            String.raw `(?<number>(?<!\w)\-?[0-9]+\.?[0-9]*(e[\-\+]?\d+?)?\b|0x[0-9a-fA-F]*)`,
+            String.raw `${WB}(?<bool_true>true)${WB}|${WB}(?<bool_false>false)${WB}|${WB}(?<null>null)${WB}`,
+            String.raw `(?<number>(?<![${W}])-?${DECIMAL}(e[\-+]?${D}+?)?${WB}|0x[0-9a-fA-F]*)`,
             JSON_STR,
-        ].join("|"),
+        ].join("|"), "u"),
     ];
     // A string followed by a colon is also a key. Its `json.key` span comes after
     // its `json.str` span, so the key style lands on top. Each string is found on
@@ -105,7 +134,7 @@ export class JSONHighlighter extends RegexHighlighter {
     highlight(text) {
         super.highlight(text);
         const colon = /[ \n\r\t]*:/y;
-        for (const { index, 0: str } of text.plain.matchAll(new RegExp(JSON_STR, "g"))) {
+        for (const { index, 0: str } of text.plain.matchAll(new RegExp(JSON_STR, "gu"))) {
             const end = index + str.length;
             colon.lastIndex = end;
             if (colon.test(text.plain))
@@ -114,11 +143,48 @@ export class JSONHighlighter extends RegexHighlighter {
     }
 }
 // --- ISO8601Highlighter ---
+// Rich 15.0.0's patterns, after the Regular Expressions Cookbook recipes it
+// cites. Each matches a whole string that is one ISO 8601 value, never a value
+// inside other text. Python's `$` also matches before a final `\n`, which
+// JavaScript's does not; `END` is Python's.
+const END = String.raw `(?=\n?$)`;
+const YEAR = String.raw `(?<year>[0-9]{4})`;
+const MONTH = String.raw `(?<month>1[0-2]|0[1-9])`;
+const DAY = String.raw `(?<day>3[01]|0[1-9]|[12][0-9])`;
+const HOUR = String.raw `(?<hour>2[0-3]|[01][0-9])`;
+const MINUTE = String.raw `(?<minute>[0-5][0-9])`;
+const SECOND = String.raw `(?<second>[0-5][0-9])`;
+const WEEK = String.raw `(?<week>5[0-3]|[1-4][0-9]|0[1-9])`;
+const TZ_HOUR = String.raw `[+-](?:2[0-3]|[01][0-9])`;
+const XSD_DATE = String.raw `(?<date>(?<year>-?(?:[1-9][0-9]*)?[0-9]{4})-${MONTH}-${DAY})`;
+const XSD_TZ = String.raw `(?<timezone>Z|${TZ_HOUR}:[0-5][0-9])?`;
+// The cookbook's designator, whose minutes and their colon are both optional.
+const TZ = String.raw `(?<timezone>Z|${TZ_HOUR}(?::?(?:[0-5][0-9]))?)`;
+const COMPACT_TIME = `(?<time>${HOUR}${MINUTE}${SECOND})`;
 export class ISO8601Highlighter extends RegexHighlighter {
     static baseStyle = "iso8601.";
     static highlights = [
-        /(?<date>\d{4}-\d{2}-\d{2})/g,
-        /(?<time>\d{2}:\d{2}:\d{2}(?:\.\d+)?)/g,
-        /(?<timezone>[+-]\d{2}:\d{2}|Z)/g,
+        // Dates
+        `^${YEAR}-${MONTH}${END}`,
+        `^(?<date>${YEAR}${MONTH}${DAY})${END}`,
+        String.raw `^(?<date>${YEAR}-?(?<day>36[0-6]|3[0-5][0-9]|[12][0-9]{2}|0[1-9][0-9]|00[1-9]))${END}`,
+        // Weeks
+        `^(?<date>${YEAR}-?W${WEEK})${END}`,
+        `^(?<date>${YEAR}-?W${WEEK}-?(?<day>[1-7]))${END}`,
+        // Times
+        `^(?<time>${HOUR}:?${MINUTE})${END}`,
+        `^${COMPACT_TIME}${END}`,
+        `^${TZ}${END}`,
+        `^${COMPACT_TIME}${TZ}${END}`,
+        // Date and time. Rich writes this as one pattern whose `-` and `:`
+        // separators are all present or all absent, keyed on a Python conditional
+        // group JavaScript lacks; it is the two spellings here, adjacent, so the
+        // one that matches lays its spans where Rich's single pattern would.
+        `^(?<date>${YEAR}(?<hyphen>-)${MONTH}-${DAY}) (?<time>${HOUR}:${MINUTE}:${SECOND})${END}`,
+        `^(?<date>${YEAR}${MONTH}${DAY}) ${COMPACT_TIME}${END}`,
+        // XML Schema date, time and dateTime
+        `^${XSD_DATE}${XSD_TZ}${END}`,
+        String.raw `^(?<time>${HOUR}:${MINUTE}:${SECOND}(?<frac>\.[0-9]+)?)${XSD_TZ}${END}`,
+        String.raw `^${XSD_DATE}T(?<time>${HOUR}:${MINUTE}:${SECOND}(?<ms>\.[0-9]+)?)${XSD_TZ}${END}`,
     ];
 }

package/dist/core/json.js

@@ -38,7 +38,7 @@ export class JSONRenderable {
             }
             : undefined;
         const jsonStr = JSON.stringify(data, replacer, indent);
-        const text = new RichText(jsonStr, { end: "" });
+        const text = new RichText(jsonStr);
         if (doHighlight) {
             highlighter.highlight(text);
         }

package/dist/core/markup.d.ts

@@ -5,8 +5,8 @@
  * Plugin tags ([LAW:locality-or-seam]): a `MarkupRegistry` lets consumers
  * register tag handlers without forking the parser. When the parser sees
  * `[name attrs...]inner[/name]` and `name` is registered, it parses attrs,
- * recursively renders the inner markup as a child Renderable, and calls the
- * handler — splicing the handler's returned Renderable into the output. The
+ * renders the inner markup as the child `RichText`, and calls the handler —
+ * splicing the `RichText` it returns into the output. The
  * built-in style dialect and the plugin dialect are routed by the registry,
  * which is the single trust boundary between them.
  *
@@ -14,10 +14,12 @@
  * (`[bold]a[italic]b[/bold]c[/italic]`) because a style is an annotation and
  * annotations may overlap freely; a plugin tag is a replacement whose handler
  * takes one contiguous `inner`, so an overlapping pair has no slice to hand it
- * and is rejected with a `MarkupSyntaxError`.
+ * and is rejected with a `MarkupSyntaxError`. For the same reason a style tag
+ * may not open on one side of a plugin tag and close on the other.
  */
 import { Style } from "./style.js";
 import { RichText } from "./text.js";
+import type { RenderOptions as DrawOptions } from "./protocol.js";
 export declare class Tag {
     readonly name: string;
     readonly parameters: string | undefined;
@@ -54,8 +56,7 @@ export declare class MarkupSyntaxError extends MarkupError {
     /** 1-based column of `offset` within its line, in UTF-16 code units. */
     readonly column: number;
     /**
-     * The opening tags still open at `offset`, outermost first, as written. For
-     * overlapping plugin tags, only plugin tags are named.
+     * The opening tags still open at `offset`, outermost first, as written.
      */
     readonly openTags: readonly string[];
     constructor(reason: string, markup: string, offset: number, openTags: readonly string[]);
@@ -113,7 +114,27 @@ export interface RenderMarkupOptions {
  * Plugin-aware markup render. Always returns a `RichText`. Built-in style
  * tags become spans; registered plugin tags are resolved by their handler,
  * whose returned `RichText` stands in the output where its pair stood, under
- * any style tag that encloses the pair. The recursion is into the inner slice
- * of each plugin pair, and every recursion node returns a `RichText`.
+ * any style tag that encloses the pair.
  */
 export declare function renderMarkup(markup: string, options?: RenderMarkupOptions): RichText;
+/**
+ * A string as the text it draws, before any highlighting: read as markup
+ * unless `markup` is false, its emoji codes replaced either way, as Rich's
+ * `render_str` reads one, its `end` the default line end Rich's leaves it.
+ * [LAW:single-enforcer]
+ */
+export declare function readStr(source: string, markup: boolean): RichText;
+/**
+ * The highlighter a string is drawn with under `settings`: its `highlighter`
+ * while `highlight` is not false — Rich's `render_str`, which highlights with
+ * `console.highlighter` when `highlight` is true or left to the console.
+ * [LAW:single-enforcer]
+ */
+export declare function activeHighlighter(settings: Pick<DrawOptions, "highlight" | "highlighter">): DrawOptions["highlighter"];
+/**
+ * A string as the text it draws, the way Rich's `render_str` makes one: read
+ * by `readStr` under `markup`, then highlighted by `activeHighlighter`.
+ * `print` and every renderable that is handed a string both draw it this way,
+ * so a console's settings mean the same thing wherever the string lands.
+ */
+export declare function renderStr(source: string, settings: Pick<DrawOptions, "markup" | "highlight" | "highlighter">): RichText;