@otto-code/highlight 0.7.5 → 0.8.0

package/dist/detect.d.ts

@@ -1,2 +1,12 @@
+/**
+ * Every extension `detectLanguage` can return.
+ *
+ * Exported so the invariant in this file's header - that each one is a key in
+ * parsers.ts's table - can actually be tested. It stopped being true once
+ * before: the v0.2.5 merge dropped the shell and SQL rows from that table while
+ * these rules kept scoring both, so detection claimed a language the renderer
+ * could not colour.
+ */
+export declare const DETECTABLE_EXTENSIONS: readonly string[];
 export declare function detectLanguage(code: string): string | null;
 //# sourceMappingURL=detect.d.ts.map

package/dist/detect.js

@@ -1,12 +1,12 @@
 // Lightweight, dependency-free language guesser for code fences that arrive
 // without an info string. Agents emit bare ``` blocks constantly, so this
-// recovers highlighting for them — but it is deliberately conservative: when
+// recovers highlighting for them - but it is deliberately conservative: when
 // the signals are weak or two languages tie, it returns null and the caller
 // renders plain monospace rather than confidently mis-coloring the block.
 //
 // Every returned extension is a key in parsers.ts's table, so the result plugs
 // straight into highlightCode(`x.${ext}`).
-// Only look at the head of large blocks — the language is obvious well before
+// Only look at the head of large blocks - the language is obvious well before
 // 4k chars, and detection runs on every streamed chunk.
 const SAMPLE_LIMIT = 4000;
 // A guess only wins if it clears this score AND beats the runner-up by the
@@ -28,7 +28,7 @@ const RULES = [
     { ext: "sh", re: /^\s*(if|then|fi|for|do|done|while|case|esac|function)\b.*;?\s*$/m, weight: 1 },
     { ext: "sh", re: /\|\s*(grep|awk|sed|xargs|head|tail|sort|uniq|wc)\b/, weight: 2 },
     { ext: "sh", re: /^\s*export\s+\w+=/m, weight: 2 },
-    // SQL — keyword-insensitive; combos are what make it unambiguous.
+    // SQL - keyword-insensitive; combos are what make it unambiguous.
     { ext: "sql", re: /\bSELECT\b[\s\S]*\bFROM\b/i, weight: 4 },
     { ext: "sql", re: /\bINSERT\s+INTO\b/i, weight: 4 },
     { ext: "sql", re: /\bUPDATE\b[\s\S]*\bSET\b/i, weight: 4 },
@@ -45,7 +45,7 @@ const RULES = [
     { ext: "py", re: /\bprint\s*\(/, weight: 1 },
     { ext: "py", re: /\b(True|False|None)\b/, weight: 1 },
     { ext: "py", re: /^\s*@\w+/m, weight: 1 },
-    // JavaScript / TypeScript (folded to ts — its parser handles plain JS)
+    // JavaScript / TypeScript (folded to ts - its parser handles plain JS)
     { ext: "ts", re: /\b(const|let)\s+\w+\s*=/, weight: 2 },
     { ext: "ts", re: /\bfunction\s*\*?\s*\w*\s*\(/, weight: 2 },
     { ext: "ts", re: /=>\s*[{([]/, weight: 2 },
@@ -107,6 +107,16 @@ function scoreRules(sample) {
     }
     return scores;
 }
+/**
+ * Every extension `detectLanguage` can return.
+ *
+ * Exported so the invariant in this file's header - that each one is a key in
+ * parsers.ts's table - can actually be tested. It stopped being true once
+ * before: the v0.2.5 merge dropped the shell and SQL rows from that table while
+ * these rules kept scoring both, so detection claimed a language the renderer
+ * could not colour.
+ */
+export const DETECTABLE_EXTENSIONS = [...new Set(RULES.map((rule) => rule.ext))];
 // Best-effort guess of the language extension for a code block, or null when
 // there isn't enough signal to be confident.
 export function detectLanguage(code) {
@@ -114,7 +124,7 @@ export function detectLanguage(code) {
     const trimmed = sample.trim();
     if (trimmed.length < 3)
         return null;
-    // Shebang — the single strongest signal, short-circuit on it.
+    // Shebang - the single strongest signal, short-circuit on it.
     if (trimmed.startsWith("#!")) {
         const firstLine = trimmed.slice(0, trimmed.indexOf("\n") === -1 ? undefined : trimmed.indexOf("\n"));
         if (/\b(bash|zsh|ksh|sh)\b/.test(firstLine))
@@ -124,14 +134,14 @@ export function detectLanguage(code) {
         if (/\bnode\b/.test(firstLine))
             return "ts";
     }
-    // JSON — structural and cheaply verifiable, so a successful parse is decisive.
+    // JSON - structural and cheaply verifiable, so a successful parse is decisive.
     if (/^[[{]/.test(trimmed) && /[\]}]$/.test(trimmed)) {
         try {
             JSON.parse(trimmed);
             return "json";
         }
         catch {
-            // Not valid JSON — likely a JS object literal or a fragment; keep scoring.
+            // Not valid JSON - likely a JS object literal or a fragment; keep scoring.
         }
     }
     const scores = scoreRules(sample);

package/dist/highlighter.js

@@ -1,48 +1,6 @@
-import { highlightTree, tagHighlighter, tags } from "@lezer/highlight";
+import { highlightTree } from "@lezer/highlight";
 import { getParserForFile } from "./parsers.js";
-const highlighter = tagHighlighter([
-    { tag: tags.keyword, class: "keyword" },
-    { tag: tags.controlKeyword, class: "keyword" },
-    { tag: tags.operatorKeyword, class: "keyword" },
-    { tag: tags.definitionKeyword, class: "keyword" },
-    { tag: tags.moduleKeyword, class: "keyword" },
-    { tag: tags.comment, class: "comment" },
-    { tag: tags.lineComment, class: "comment" },
-    { tag: tags.blockComment, class: "comment" },
-    { tag: tags.docComment, class: "comment" },
-    { tag: tags.string, class: "string" },
-    { tag: tags.special(tags.string), class: "string" },
-    { tag: tags.number, class: "number" },
-    { tag: tags.integer, class: "number" },
-    { tag: tags.float, class: "number" },
-    { tag: tags.bool, class: "literal" },
-    { tag: tags.null, class: "literal" },
-    { tag: tags.function(tags.variableName), class: "function" },
-    { tag: tags.function(tags.propertyName), class: "function" },
-    { tag: tags.definition(tags.variableName), class: "definition" },
-    { tag: tags.definition(tags.propertyName), class: "definition" },
-    { tag: tags.definition(tags.function(tags.variableName)), class: "definition" },
-    { tag: tags.className, class: "class" },
-    { tag: tags.definition(tags.className), class: "class" },
-    { tag: tags.typeName, class: "type" },
-    { tag: tags.tagName, class: "tag" },
-    { tag: tags.attributeName, class: "attribute" },
-    { tag: tags.attributeValue, class: "string" },
-    { tag: tags.propertyName, class: "property" },
-    { tag: tags.variableName, class: "variable" },
-    { tag: tags.local(tags.variableName), class: "variable" },
-    { tag: tags.special(tags.variableName), class: "variable" },
-    { tag: tags.operator, class: "operator" },
-    { tag: tags.punctuation, class: "punctuation" },
-    { tag: tags.bracket, class: "punctuation" },
-    { tag: tags.separator, class: "punctuation" },
-    { tag: tags.regexp, class: "regexp" },
-    { tag: tags.escape, class: "escape" },
-    { tag: tags.meta, class: "meta" },
-    { tag: tags.heading, class: "heading" },
-    { tag: tags.link, class: "link" },
-    { tag: tags.url, class: "link" },
-]);
+import { staticSyntaxHighlighter } from "./syntax-roles.js";
 export function highlightCode(code, filename) {
     const parser = getParserForFile(filename);
     if (!parser) {
@@ -56,7 +14,7 @@ export function highlightCode(code, filename) {
     }
     // Build a map of character positions to styles
     const styleMap = Array.from({ length: code.length }, () => null);
-    highlightTree(tree, highlighter, (from, to, classes) => {
+    highlightTree(tree, staticSyntaxHighlighter, (from, to, classes) => {
         for (let i = from; i < to && i < styleMap.length; i++) {
             styleMap[i] = classes;
         }

package/dist/index.d.ts

@@ -1,10 +1,13 @@
 export type { HighlightStyle, HighlightToken } from "./types.js";
-export { getParserForFile, isLanguageSupported, getSupportedExtensions } from "./parsers.js";
+export { getLanguageForFile, getParserForFile, isLanguageSupported, getSupportedExtensions, } from "./parsers.js";
+export { createCodeMirrorHighlightStyle } from "./syntax-roles.js";
 export { getLanguageDisplayName } from "./language-names.js";
 export { highlightCode, highlightLine } from "./highlighter.js";
 export { detectLanguage } from "./detect.js";
 export { extractSymbols } from "./symbols.js";
 export type { CodeSymbol, SymbolKind } from "./symbols.js";
+export { extractMarkdownHeadings } from "./markdown-headings.js";
+export type { MarkdownHeading } from "./markdown-headings.js";
 export { darkHighlightColors, lightHighlightColors } from "./colors.js";
 export type { SyntaxThemeId, SyntaxThemeOption, SyntaxColors } from "./themes.js";
 export { SYNTAX_THEME_IDS, SYNTAX_THEME_OPTIONS, isSyntaxThemeId, resolveSyntaxColors, } from "./themes.js";

package/dist/index.js

@@ -1,8 +1,10 @@
-export { getParserForFile, isLanguageSupported, getSupportedExtensions } from "./parsers.js";
+export { getLanguageForFile, getParserForFile, isLanguageSupported, getSupportedExtensions, } from "./parsers.js";
+export { createCodeMirrorHighlightStyle } from "./syntax-roles.js";
 export { getLanguageDisplayName } from "./language-names.js";
 export { highlightCode, highlightLine } from "./highlighter.js";
 export { detectLanguage } from "./detect.js";
 export { extractSymbols } from "./symbols.js";
+export { extractMarkdownHeadings } from "./markdown-headings.js";
 export { darkHighlightColors, lightHighlightColors } from "./colors.js";
 export { SYNTAX_THEME_IDS, SYNTAX_THEME_OPTIONS, isSyntaxThemeId, resolveSyntaxColors, } from "./themes.js";
 //# sourceMappingURL=index.js.map

package/dist/language-names.d.ts

@@ -1,5 +1,5 @@
 /**
- * A label for the editor status bar — never empty. Unknown extensions fall back
+ * A label for the editor status bar - never empty. Unknown extensions fall back
  * to the extension itself in caps ("TOML" before it was listed above), which
  * still tells the user more than "Unknown" would.
  */

package/dist/language-names.js

@@ -115,7 +115,7 @@ const NAMES_BY_FILENAME = {
     notice: "Plain Text",
 };
 /**
- * A label for the editor status bar — never empty. Unknown extensions fall back
+ * A label for the editor status bar - never empty. Unknown extensions fall back
  * to the extension itself in caps ("TOML" before it was listed above), which
  * still tells the user more than "Unknown" would.
  */

package/dist/markdown-headings.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Markdown headings, for the document outline and for link autocompletion
+ * against a document's own anchors.
+ *
+ * **This is deliberately not part of `extractSymbols`.** A heading is not a
+ * `SymbolKind`, and adding one would mean adding a value to
+ * `CodeSymbolKindSchema` - a `z.enum` on the wire. A six-month-old client
+ * parsing a `code.outline.response` carrying `kind: "heading"` would reject the
+ * whole message, which the protocol contract forbids. Headings therefore stay
+ * **client-side**: the client already holds the document it wants an outline of,
+ * so there is nothing to ask the daemon for. That also lets a heading carry its
+ * level, which the flat symbol shape cannot express and a real table of contents
+ * needs.
+ */
+export interface MarkdownHeading {
+    /** 1 through 6, from the marker count (ATX) or the underline character (Setext). */
+    level: number;
+    /**
+     * The heading text with its markers removed. Inline markup is left exactly as
+     * written: an outline row showing `**Setup**` is honest about the source, and
+     * stripping emphasis here would mean a second, partial markdown parser.
+     */
+    text: string;
+    /** 1-based line the heading starts on. */
+    line: number;
+    /** 0-based offset of the heading node, for scrolling straight to it. */
+    from: number;
+}
+/**
+ * Extract the headings of a markdown document, in document order.
+ *
+ * This parses rather than scanning for `#` because only a parse knows that a
+ * `#` opening a line inside a fenced code block is a comment, not a heading -
+ * the single most common way a regex-based outline goes wrong on a README.
+ */
+export declare function extractMarkdownHeadings(code: string): MarkdownHeading[];
+//# sourceMappingURL=markdown-headings.d.ts.map

package/dist/markdown-headings.js

@@ -0,0 +1,64 @@
+import { parser as markdownParser } from "@lezer/markdown";
+const HEADING_NODE = /^(?:ATX|Setext)Heading([1-6])$/;
+// `## Title ##` - the leading run, and the optional closing run ATX allows.
+// The closing run must be preceded by whitespace, per CommonMark, which is what
+// keeps `# C#` from becoming "C".
+const ATX_LEADING = /^[ \t]*#{1,6}[ \t]*/;
+const ATX_TRAILING = /\s#+[ \t]*$/;
+function buildLineStarts(code) {
+    const starts = [0];
+    for (let index = 0; index < code.length; index += 1) {
+        if (code.charCodeAt(index) === 10) {
+            starts.push(index + 1);
+        }
+    }
+    return starts;
+}
+// Binary search for the 0-based line index whose start is <= offset.
+function lineIndexForOffset(lineStarts, offset) {
+    let low = 0;
+    let high = lineStarts.length - 1;
+    while (low < high) {
+        const mid = (low + high + 1) >> 1;
+        if (lineStarts[mid] <= offset) {
+            low = mid;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return low;
+}
+/**
+ * Extract the headings of a markdown document, in document order.
+ *
+ * This parses rather than scanning for `#` because only a parse knows that a
+ * `#` opening a line inside a fenced code block is a comment, not a heading -
+ * the single most common way a regex-based outline goes wrong on a README.
+ */
+export function extractMarkdownHeadings(code) {
+    const tree = markdownParser.parse(code);
+    const lineStarts = buildLineStarts(code);
+    const headings = [];
+    const cursor = tree.cursor();
+    do {
+        const match = HEADING_NODE.exec(cursor.name);
+        if (!match) {
+            continue;
+        }
+        const level = Number(match[1]);
+        const raw = code.slice(cursor.from, cursor.to);
+        // A Setext heading spans its text line and its underline; the underline is
+        // the marker, so only the first line is the text.
+        const firstLine = raw.split("\n", 1)[0] ?? "";
+        const text = firstLine.replace(ATX_LEADING, "").replace(ATX_TRAILING, "").trim();
+        headings.push({
+            level,
+            text,
+            line: lineIndexForOffset(lineStarts, cursor.from) + 1,
+            from: cursor.from,
+        });
+    } while (cursor.next());
+    return headings;
+}
+//# sourceMappingURL=markdown-headings.js.map

package/dist/parsers.d.ts

@@ -1,4 +1,6 @@
+import { Language } from "@codemirror/language";
 import type { Parser } from "@lezer/common";
+export declare function getLanguageForFile(filename: string): Language | null;
 export declare function getParserForFile(filename: string): Parser | null;
 export declare function isLanguageSupported(filename: string): boolean;
 export declare function getSupportedExtensions(): string[];

package/dist/parsers.js

@@ -1,8 +1,8 @@
-import { StreamLanguage } from "@codemirror/language";
+import { defineLanguageFacet, Language, StreamLanguage } from "@codemirror/language";
 import { dart } from "@codemirror/legacy-modes/mode/clike";
-import { swift } from "@codemirror/legacy-modes/mode/swift";
 import { shell } from "@codemirror/legacy-modes/mode/shell";
 import { standardSQL } from "@codemirror/legacy-modes/mode/sql";
+import { swift } from "@codemirror/legacy-modes/mode/swift";
 import { parser as jsParser } from "@lezer/javascript";
 import { parser as jsonParser } from "@lezer/json";
 import { parser as cssParser } from "@lezer/css";
@@ -18,79 +18,90 @@ import { parser as xmlParser } from "@lezer/xml";
 import { parser as yamlParser } from "@lezer/yaml";
 import { csharpLanguage } from "@replit/codemirror-lang-csharp";
 import { parser as elixirParser } from "lezer-elixir";
+function language(parser) {
+    return new Language(defineLanguageFacet(), parser);
+}
 // Shared instance so the four shell fence aliases don't each build a grammar.
-const shellParser = StreamLanguage.define(shell).parser;
-const parsersByExtension = {
+const shellLanguage = StreamLanguage.define(shell);
+const languagesByExtension = {
     // JavaScript/TypeScript
-    js: jsParser,
-    jsx: jsParser.configure({ dialect: "jsx" }),
-    ts: jsParser.configure({ dialect: "ts" }),
-    tsx: jsParser.configure({ dialect: "ts jsx" }),
-    mjs: jsParser,
-    cjs: jsParser,
+    js: language(jsParser),
+    jsx: language(jsParser.configure({ dialect: "jsx" })),
+    ts: language(jsParser.configure({ dialect: "ts" })),
+    tsx: language(jsParser.configure({ dialect: "ts jsx" })),
+    mjs: language(jsParser),
+    cjs: language(jsParser),
     // C / C++ / Objective-C
-    c: cppParser,
-    h: cppParser,
-    cc: cppParser,
-    cpp: cppParser,
-    cxx: cppParser,
-    hpp: cppParser,
-    hxx: cppParser,
-    m: cppParser,
-    mm: cppParser,
+    c: language(cppParser),
+    h: language(cppParser),
+    cc: language(cppParser),
+    cpp: language(cppParser),
+    cxx: language(cppParser),
+    hpp: language(cppParser),
+    hxx: language(cppParser),
+    m: language(cppParser),
+    mm: language(cppParser),
     // JSON
-    json: jsonParser,
+    json: language(jsonParser),
     // CSS
-    css: cssParser,
-    scss: cssParser,
+    css: language(cssParser),
+    scss: language(cssParser),
     // HTML
-    html: htmlParser,
-    htm: htmlParser,
+    html: language(htmlParser),
+    htm: language(htmlParser),
     // XML
-    xml: xmlParser,
+    xml: language(xmlParser),
     // Java
-    java: javaParser,
+    java: language(javaParser),
     // Python
-    py: pythonParser,
+    py: language(pythonParser),
     // Go
-    go: goParser,
+    go: language(goParser),
     // PHP
-    php: phpParser,
+    php: language(phpParser),
     // YAML
-    yaml: yamlParser,
-    yml: yamlParser,
+    yaml: language(yamlParser),
+    yml: language(yamlParser),
     // Rust
-    rs: rustParser,
+    rs: language(rustParser),
     // Swift
-    swift: StreamLanguage.define(swift).parser,
+    swift: StreamLanguage.define(swift),
     // Dart
-    dart: StreamLanguage.define(dart).parser,
-    // Shell (fence tags bash/sh/zsh/shell all map here)
-    sh: shellParser,
-    bash: shellParser,
-    zsh: shellParser,
-    shell: shellParser,
-    // SQL
-    sql: StreamLanguage.define(standardSQL).parser,
+    dart: StreamLanguage.define(dart),
     // C#
-    cs: csharpLanguage.parser,
+    cs: csharpLanguage,
     // Elixir
-    ex: elixirParser,
-    exs: elixirParser,
+    ex: language(elixirParser),
+    exs: language(elixirParser),
     // Markdown
-    md: markdownParser,
-    mdx: markdownParser,
+    md: language(markdownParser),
+    mdx: language(markdownParser),
+    // Shell. `detect.ts` has scored shell since it was written and can return
+    // "sh", so without these rows we classified a snippet as shell and then had
+    // nothing to colour it with. Lost in the Paseo v0.2.5 merge when this table
+    // took upstream's shape; see projects/paseo-v025-merge/audit-findings.md.
+    // All four fence tags (sh/bash/zsh/shell) map here.
+    sh: shellLanguage,
+    bash: shellLanguage,
+    zsh: shellLanguage,
+    shell: shellLanguage,
+    // SQL. Same story: "sql" is a detect.ts verdict. `standardSQL` is the dialect
+    // -neutral mode, which is the right default for snippets of unknown origin.
+    sql: StreamLanguage.define(standardSQL),
 };
-export function getParserForFile(filename) {
+export function getLanguageForFile(filename) {
     const ext = filename.split(".").pop()?.toLowerCase();
     if (!ext)
         return null;
-    return parsersByExtension[ext] ?? null;
+    return languagesByExtension[ext] ?? null;
+}
+export function getParserForFile(filename) {
+    return getLanguageForFile(filename)?.parser ?? null;
 }
 export function isLanguageSupported(filename) {
     return getParserForFile(filename) !== null;
 }
 export function getSupportedExtensions() {
-    return Object.keys(parsersByExtension);
+    return Object.keys(languagesByExtension);
 }
 //# sourceMappingURL=parsers.js.map

package/dist/syntax-roles.d.ts

@@ -0,0 +1,10 @@
+import { HighlightStyle as CodeMirrorHighlightStyle } from "@codemirror/language";
+import { type Tag } from "@lezer/highlight";
+import type { HighlightStyle } from "./types.js";
+export declare const syntaxRoleTags: ReadonlyArray<{
+    tag: Tag;
+    role: HighlightStyle;
+}>;
+export declare const staticSyntaxHighlighter: import("@lezer/highlight").Highlighter;
+export declare function createCodeMirrorHighlightStyle(colors: Record<HighlightStyle, string>): CodeMirrorHighlightStyle;
+//# sourceMappingURL=syntax-roles.d.ts.map

package/dist/syntax-roles.js

@@ -0,0 +1,50 @@
+import { HighlightStyle as CodeMirrorHighlightStyle } from "@codemirror/language";
+import { tagHighlighter, tags } from "@lezer/highlight";
+export const syntaxRoleTags = [
+    { tag: tags.keyword, role: "keyword" },
+    { tag: tags.controlKeyword, role: "keyword" },
+    { tag: tags.operatorKeyword, role: "keyword" },
+    { tag: tags.definitionKeyword, role: "keyword" },
+    { tag: tags.moduleKeyword, role: "keyword" },
+    { tag: tags.comment, role: "comment" },
+    { tag: tags.lineComment, role: "comment" },
+    { tag: tags.blockComment, role: "comment" },
+    { tag: tags.docComment, role: "comment" },
+    { tag: tags.string, role: "string" },
+    { tag: tags.special(tags.string), role: "string" },
+    { tag: tags.number, role: "number" },
+    { tag: tags.integer, role: "number" },
+    { tag: tags.float, role: "number" },
+    { tag: tags.bool, role: "literal" },
+    { tag: tags.null, role: "literal" },
+    { tag: tags.function(tags.variableName), role: "function" },
+    { tag: tags.function(tags.propertyName), role: "function" },
+    { tag: tags.definition(tags.variableName), role: "definition" },
+    { tag: tags.definition(tags.propertyName), role: "definition" },
+    { tag: tags.definition(tags.function(tags.variableName)), role: "definition" },
+    { tag: tags.className, role: "class" },
+    { tag: tags.definition(tags.className), role: "class" },
+    { tag: tags.typeName, role: "type" },
+    { tag: tags.tagName, role: "tag" },
+    { tag: tags.attributeName, role: "attribute" },
+    { tag: tags.attributeValue, role: "string" },
+    { tag: tags.propertyName, role: "property" },
+    { tag: tags.variableName, role: "variable" },
+    { tag: tags.local(tags.variableName), role: "variable" },
+    { tag: tags.special(tags.variableName), role: "variable" },
+    { tag: tags.operator, role: "operator" },
+    { tag: tags.punctuation, role: "punctuation" },
+    { tag: tags.bracket, role: "punctuation" },
+    { tag: tags.separator, role: "punctuation" },
+    { tag: tags.regexp, role: "regexp" },
+    { tag: tags.escape, role: "escape" },
+    { tag: tags.meta, role: "meta" },
+    { tag: tags.heading, role: "heading" },
+    { tag: tags.link, role: "link" },
+    { tag: tags.url, role: "link" },
+];
+export const staticSyntaxHighlighter = tagHighlighter(syntaxRoleTags.map(({ tag, role }) => ({ tag, class: role })));
+export function createCodeMirrorHighlightStyle(colors) {
+    return CodeMirrorHighlightStyle.define(syntaxRoleTags.map(({ tag, role }) => ({ tag, color: colors[role] })));
+}
+//# sourceMappingURL=syntax-roles.js.map

package/dist/themes.js

@@ -55,7 +55,7 @@ function expandRolePalette(r) {
         diffRemovedEmphasis: withAlpha(r.diffRemoved, 0.35),
     };
 }
-// --- Default (high-contrast primary hues — the CGA-basic baseline) -------
+// --- Default (high-contrast primary hues - the CGA-basic baseline) -------
 const defaultLight = {
     base: "#000000",
     keyword: "#0000aa",
@@ -171,7 +171,7 @@ const monokaiDark = {
     diffAdded: "rgba(166, 226, 46, 0.18)",
     diffRemoved: "rgba(248, 53, 53, 0.18)",
 };
-// --- Nightshade (Light / Dark — gothic pink/purple/cyan, formerly "Dracula";
+// --- Nightshade (Light / Dark - gothic pink/purple/cyan, formerly "Dracula";
 // renamed once it grew a light variant the original theme never had) --------
 const nightshadeLight = {
     base: "#282a36",
@@ -201,7 +201,7 @@ const nightshadeDark = {
     diffAdded: "rgba(80, 250, 123, 0.18)",
     diffRemoved: "rgba(255, 85, 85, 0.18)",
 };
-// --- Neotokyo (Light / Dark — cyber yellow, hot pink, neon cyan) ----------
+// --- Neotokyo (Light / Dark - cyber yellow, hot pink, neon cyan) ----------
 const neotokyoLight = {
     base: "#1a1025",
     keyword: "#c2188f",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/highlight",
-  "version": "0.7.5",
+  "version": "0.8.0",
   "license": "AGPL-3.0-or-later",
   "files": [
     "dist",
@@ -28,7 +28,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@codemirror/language": "^6.12.3",
+    "@codemirror/language": "6.12.4",
     "@codemirror/legacy-modes": "^6.5.3",
     "@lezer/common": "^1.5.0",
     "@lezer/cpp": "^1.1.5",