@otto-code/highlight 0.5.0

package/dist/colors.d.ts

@@ -0,0 +1,4 @@
+import type { DiffBackgroundColors, HighlightStyle } from "./types.js";
+export declare const darkHighlightColors: Record<HighlightStyle, string> & DiffBackgroundColors;
+export declare const lightHighlightColors: Record<HighlightStyle, string> & DiffBackgroundColors;
+//# sourceMappingURL=colors.d.ts.map

package/dist/colors.js

@@ -0,0 +1,53 @@
+export const darkHighlightColors = {
+    keyword: "#ff7b72",
+    comment: "#8b949e",
+    string: "#a5d6ff",
+    number: "#79c0ff",
+    literal: "#79c0ff",
+    function: "#d2a8ff",
+    definition: "#d2a8ff",
+    class: "#ffa657",
+    type: "#ff7b72",
+    tag: "#7ee787",
+    attribute: "#79c0ff",
+    property: "#79c0ff",
+    variable: "#c9d1d9",
+    operator: "#79c0ff",
+    punctuation: "#c9d1d9",
+    regexp: "#a5d6ff",
+    escape: "#79c0ff",
+    meta: "#8b949e",
+    heading: "#79c0ff",
+    link: "#a5d6ff",
+    diffAdded: "rgba(46, 160, 67, 0.15)",
+    diffRemoved: "rgba(248, 81, 73, 0.1)",
+    diffAddedEmphasis: "rgba(46, 160, 67, 0.4)",
+    diffRemovedEmphasis: "rgba(248, 81, 73, 0.35)",
+};
+export const lightHighlightColors = {
+    keyword: "#cf222e",
+    comment: "#6e7781",
+    string: "#0a3069",
+    number: "#0550ae",
+    literal: "#0550ae",
+    function: "#8250df",
+    definition: "#8250df",
+    class: "#953800",
+    type: "#cf222e",
+    tag: "#116329",
+    attribute: "#0550ae",
+    property: "#0550ae",
+    variable: "#24292f",
+    operator: "#0550ae",
+    punctuation: "#24292f",
+    regexp: "#0a3069",
+    escape: "#0550ae",
+    meta: "#6e7781",
+    heading: "#0550ae",
+    link: "#0a3069",
+    diffAdded: "rgba(46, 160, 67, 0.15)",
+    diffRemoved: "rgba(248, 81, 73, 0.1)",
+    diffAddedEmphasis: "rgba(46, 160, 67, 0.4)",
+    diffRemovedEmphasis: "rgba(248, 81, 73, 0.35)",
+};
+//# sourceMappingURL=colors.js.map

package/dist/highlighter.d.ts

@@ -0,0 +1,4 @@
+import type { HighlightToken } from "./types.js";
+export declare function highlightCode(code: string, filename: string): HighlightToken[][];
+export declare function highlightLine(line: string, filename: string): HighlightToken[];
+//# sourceMappingURL=highlighter.d.ts.map

package/dist/highlighter.js

@@ -0,0 +1,97 @@
+import { highlightTree, tagHighlighter, tags } 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" },
+]);
+export function highlightCode(code, filename) {
+    const parser = getParserForFile(filename);
+    if (!parser) {
+        return code.split("\n").map((line) => [{ text: line, style: null }]);
+    }
+    const tree = parser.parse(code);
+    const lines = code.split("\n");
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+        result.push([]);
+    }
+    // Build a map of character positions to styles
+    const styleMap = Array.from({ length: code.length }, () => null);
+    highlightTree(tree, highlighter, (from, to, classes) => {
+        for (let i = from; i < to && i < styleMap.length; i++) {
+            styleMap[i] = classes;
+        }
+    });
+    // Convert style map to tokens per line
+    let pos = 0;
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        if (line.length === 0) {
+            result[lineIndex].push({ text: "", style: null });
+            pos++; // skip newline
+            continue;
+        }
+        let currentToken = { text: "", style: styleMap[pos] };
+        for (let i = 0; i < line.length; i++) {
+            const charStyle = styleMap[pos + i];
+            if (charStyle === currentToken.style) {
+                currentToken.text += line[i];
+            }
+            else {
+                if (currentToken.text) {
+                    result[lineIndex].push(currentToken);
+                }
+                currentToken = { text: line[i], style: charStyle };
+            }
+        }
+        if (currentToken.text) {
+            result[lineIndex].push(currentToken);
+        }
+        pos += line.length + 1; // +1 for newline
+    }
+    return result;
+}
+export function highlightLine(line, filename) {
+    const result = highlightCode(line, filename);
+    return result[0] ?? [{ text: line, style: null }];
+}
+//# sourceMappingURL=highlighter.js.map

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export type { HighlightStyle, HighlightToken } from "./types.js";
+export { getParserForFile, isLanguageSupported, getSupportedExtensions } from "./parsers.js";
+export { highlightCode, highlightLine } from "./highlighter.js";
+export { extractSymbols } from "./symbols.js";
+export type { CodeSymbol, SymbolKind } from "./symbols.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";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,6 @@
+export { getParserForFile, isLanguageSupported, getSupportedExtensions } from "./parsers.js";
+export { highlightCode, highlightLine } from "./highlighter.js";
+export { extractSymbols } from "./symbols.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/parsers.d.ts

@@ -0,0 +1,5 @@
+import type { Parser } from "@lezer/common";
+export declare function getParserForFile(filename: string): Parser | null;
+export declare function isLanguageSupported(filename: string): boolean;
+export declare function getSupportedExtensions(): string[];
+//# sourceMappingURL=parsers.d.ts.map

package/dist/parsers.js

@@ -0,0 +1,85 @@
+import { StreamLanguage } from "@codemirror/language";
+import { dart } from "@codemirror/legacy-modes/mode/clike";
+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";
+import { parser as cppParser } from "@lezer/cpp";
+import { parser as goParser } from "@lezer/go";
+import { parser as htmlParser } from "@lezer/html";
+import { parser as javaParser } from "@lezer/java";
+import { parser as pythonParser } from "@lezer/python";
+import { parser as markdownParser } from "@lezer/markdown";
+import { parser as phpParser } from "@lezer/php";
+import { parser as rustParser } from "@lezer/rust";
+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";
+const parsersByExtension = {
+    // JavaScript/TypeScript
+    js: jsParser,
+    jsx: jsParser.configure({ dialect: "jsx" }),
+    ts: jsParser.configure({ dialect: "ts" }),
+    tsx: jsParser.configure({ dialect: "ts jsx" }),
+    mjs: jsParser,
+    cjs: jsParser,
+    // C / C++ / Objective-C
+    c: cppParser,
+    h: cppParser,
+    cc: cppParser,
+    cpp: cppParser,
+    cxx: cppParser,
+    hpp: cppParser,
+    hxx: cppParser,
+    m: cppParser,
+    mm: cppParser,
+    // JSON
+    json: jsonParser,
+    // CSS
+    css: cssParser,
+    scss: cssParser,
+    // HTML
+    html: htmlParser,
+    htm: htmlParser,
+    // XML
+    xml: xmlParser,
+    // Java
+    java: javaParser,
+    // Python
+    py: pythonParser,
+    // Go
+    go: goParser,
+    // PHP
+    php: phpParser,
+    // YAML
+    yaml: yamlParser,
+    yml: yamlParser,
+    // Rust
+    rs: rustParser,
+    // Swift
+    swift: StreamLanguage.define(swift).parser,
+    // Dart
+    dart: StreamLanguage.define(dart).parser,
+    // C#
+    cs: csharpLanguage.parser,
+    // Elixir
+    ex: elixirParser,
+    exs: elixirParser,
+    // Markdown
+    md: markdownParser,
+    mdx: markdownParser,
+};
+export function getParserForFile(filename) {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    if (!ext)
+        return null;
+    return parsersByExtension[ext] ?? null;
+}
+export function isLanguageSupported(filename) {
+    return getParserForFile(filename) !== null;
+}
+export function getSupportedExtensions() {
+    return Object.keys(parsersByExtension);
+}
+//# sourceMappingURL=parsers.js.map

package/dist/symbols.d.ts

@@ -0,0 +1,15 @@
+export type SymbolKind = "function" | "class" | "type" | "variable" | "property";
+export interface CodeSymbol {
+    name: string;
+    kind: SymbolKind;
+    /** 1-based line of the identifier. */
+    line: number;
+    /** 1-based column of the identifier. */
+    column: number;
+}
+/**
+ * Extract definition symbols from source. Returns [] for unsupported
+ * languages (there is no parser) rather than throwing.
+ */
+export declare function extractSymbols(code: string, filename: string): CodeSymbol[];
+//# sourceMappingURL=symbols.d.ts.map

package/dist/symbols.js

@@ -0,0 +1,87 @@
+import { highlightTree, tagHighlighter, tags } from "@lezer/highlight";
+import { getParserForFile } from "./parsers.js";
+// Order matters: more specific tags are listed first so a function definition
+// is classified as "function", not the broader "variable".
+const definitionHighlighter = tagHighlighter([
+    { tag: tags.definition(tags.function(tags.variableName)), class: "function" },
+    { tag: tags.function(tags.definition(tags.variableName)), class: "function" },
+    { tag: tags.definition(tags.className), class: "class" },
+    { tag: tags.definition(tags.propertyName), class: "property" },
+    { tag: tags.definition(tags.variableName), class: "variable" },
+    { tag: tags.definition(tags.typeName), class: "type" },
+    { tag: tags.className, class: "class" },
+    { tag: tags.typeName, class: "type" },
+]);
+const CLASS_TO_KIND = {
+    function: "function",
+    class: "class",
+    type: "type",
+    variable: "variable",
+    property: "property",
+};
+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;
+}
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+/**
+ * Extract definition symbols from source. Returns [] for unsupported
+ * languages (there is no parser) rather than throwing.
+ */
+export function extractSymbols(code, filename) {
+    const parser = getParserForFile(filename);
+    if (!parser) {
+        return [];
+    }
+    const tree = parser.parse(code);
+    const lineStarts = buildLineStarts(code);
+    const symbols = [];
+    const seen = new Set();
+    highlightTree(tree, definitionHighlighter, (from, to, classes) => {
+        const kind = CLASS_TO_KIND[classes];
+        if (!kind) {
+            return;
+        }
+        const name = code.slice(from, to);
+        // Highlight ranges can cover punctuation or multi-token spans; keep only
+        // clean identifiers so the index stays name-addressable.
+        if (!IDENTIFIER.test(name)) {
+            return;
+        }
+        const lineIndex = lineIndexForOffset(lineStarts, from);
+        const dedupeKey = `${name} ${lineIndex} ${kind}`;
+        if (seen.has(dedupeKey)) {
+            return;
+        }
+        seen.add(dedupeKey);
+        symbols.push({
+            name,
+            kind,
+            line: lineIndex + 1,
+            column: from - lineStarts[lineIndex] + 1,
+        });
+    });
+    symbols.sort((a, b) => a.line - b.line || a.column - b.column);
+    return symbols;
+}
+//# sourceMappingURL=symbols.js.map

package/dist/themes.d.ts

@@ -0,0 +1,12 @@
+import type { DiffBackgroundColors, HighlightStyle } from "./types.js";
+export type SyntaxThemeId = "default" | "github" | "vscode" | "jetbrains" | "monokai" | "nightshade" | "neotokyo";
+export declare const SYNTAX_THEME_IDS: readonly SyntaxThemeId[];
+export interface SyntaxThemeOption {
+    id: SyntaxThemeId;
+    label: string;
+}
+export declare const SYNTAX_THEME_OPTIONS: readonly SyntaxThemeOption[];
+export type SyntaxColors = Record<HighlightStyle, string> & DiffBackgroundColors;
+export declare function isSyntaxThemeId(value: string): value is SyntaxThemeId;
+export declare function resolveSyntaxColors(id: SyntaxThemeId, colorScheme: "light" | "dark"): SyntaxColors;
+//# sourceMappingURL=themes.d.ts.map

package/dist/themes.js

@@ -0,0 +1,257 @@
+import { darkHighlightColors, lightHighlightColors } from "./colors.js";
+export const SYNTAX_THEME_IDS = [
+    "default",
+    "github",
+    "vscode",
+    "jetbrains",
+    "monokai",
+    "nightshade",
+    "neotokyo",
+];
+export const SYNTAX_THEME_OPTIONS = [
+    { id: "default", label: "Default" },
+    { id: "github", label: "GitHub" },
+    { id: "vscode", label: "VS Code" },
+    { id: "jetbrains", label: "JetBrains" },
+    { id: "monokai", label: "Monokai" },
+    { id: "nightshade", label: "Nightshade" },
+    { id: "neotokyo", label: "Neotokyo" },
+];
+// Re-derives an rgba() string at a different alpha. Boosts each theme's diff
+// row tints into their intraline emphasis pair without every theme authoring
+// a second color for the same hue.
+function withAlpha(rgbaColor, alpha) {
+    const match = rgbaColor.match(/^rgba\((\d+),\s*(\d+),\s*(\d+),/);
+    if (!match)
+        return rgbaColor;
+    const [, r, g, b] = match;
+    return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}
+function expandRolePalette(r) {
+    return {
+        keyword: r.keyword,
+        comment: r.comment,
+        string: r.string,
+        number: r.number,
+        literal: r.number,
+        function: r.function,
+        definition: r.function,
+        class: r.type,
+        type: r.type,
+        tag: r.tag,
+        attribute: r.attribute,
+        property: r.attribute,
+        variable: r.base,
+        operator: r.operator,
+        punctuation: r.base,
+        regexp: r.string,
+        escape: r.number,
+        meta: r.comment,
+        heading: r.function,
+        link: r.string,
+        diffAdded: r.diffAdded,
+        diffRemoved: r.diffRemoved,
+        diffAddedEmphasis: withAlpha(r.diffAdded, 0.4),
+        diffRemovedEmphasis: withAlpha(r.diffRemoved, 0.35),
+    };
+}
+// --- Default (high-contrast primary hues — the CGA-basic baseline) -------
+const defaultLight = {
+    base: "#000000",
+    keyword: "#0000aa",
+    comment: "#666666",
+    string: "#aa0000",
+    number: "#aa00aa",
+    function: "#aa5500",
+    type: "#00aaaa",
+    tag: "#0000aa",
+    attribute: "#00aa00",
+    operator: "#000000",
+    diffAdded: "rgba(0, 128, 0, 0.12)",
+    diffRemoved: "rgba(170, 0, 0, 0.12)",
+};
+const defaultDark = {
+    base: "#ffffff",
+    keyword: "#5555ff",
+    comment: "#999999",
+    string: "#55ff55",
+    number: "#55ffff",
+    function: "#ffff55",
+    type: "#ff55ff",
+    tag: "#5555ff",
+    attribute: "#55ffff",
+    operator: "#ffffff",
+    diffAdded: "rgba(85, 255, 85, 0.18)",
+    diffRemoved: "rgba(255, 85, 85, 0.18)",
+};
+// --- VS Code (Light+ / Dark+) ---------------------------------------------
+const vscodeLight = {
+    base: "#000000",
+    keyword: "#0000ff",
+    comment: "#008000",
+    string: "#a31515",
+    number: "#098658",
+    function: "#795e26",
+    type: "#267f99",
+    tag: "#800000",
+    attribute: "#e50000",
+    operator: "#000000",
+    diffAdded: "rgba(46, 125, 50, 0.14)",
+    diffRemoved: "rgba(198, 40, 40, 0.14)",
+};
+const vscodeDark = {
+    base: "#d4d4d4",
+    keyword: "#569cd6",
+    comment: "#6a9955",
+    string: "#ce9178",
+    number: "#b5cea8",
+    function: "#dcdcaa",
+    type: "#4ec9b0",
+    tag: "#569cd6",
+    attribute: "#9cdcfe",
+    operator: "#d4d4d4",
+    diffAdded: "rgba(75, 139, 31, 0.22)",
+    diffRemoved: "rgba(190, 17, 0, 0.22)",
+};
+// --- JetBrains (IntelliJ Light / Darcula) ---------------------------------
+const jetbrainsLight = {
+    base: "#000000",
+    keyword: "#0033b3",
+    comment: "#8c8c8c",
+    string: "#067d17",
+    number: "#1750eb",
+    function: "#00627a",
+    type: "#20999d",
+    tag: "#3f7f7f",
+    attribute: "#660000",
+    operator: "#000000",
+    diffAdded: "rgba(56, 142, 60, 0.15)",
+    diffRemoved: "rgba(198, 40, 40, 0.15)",
+};
+const jetbrainsDark = {
+    base: "#a9b7c6",
+    keyword: "#cc7832",
+    comment: "#808080",
+    string: "#6a8759",
+    number: "#6897bb",
+    function: "#ffc66d",
+    type: "#b3ae60",
+    tag: "#e8bf6a",
+    attribute: "#a9b7c6",
+    operator: "#a9b7c6",
+    diffAdded: "rgba(46, 107, 62, 0.3)",
+    diffRemoved: "rgba(107, 46, 46, 0.3)",
+};
+// --- Monokai (Light / Dark) ------------------------------------------------
+const monokaiLight = {
+    base: "#272822",
+    keyword: "#c4133b",
+    comment: "#75715e",
+    string: "#a68a0d",
+    number: "#7c3fb5",
+    function: "#4b8b1f",
+    type: "#0f83a3",
+    tag: "#c4133b",
+    attribute: "#4b8b1f",
+    operator: "#c4133b",
+    diffAdded: "rgba(75, 139, 31, 0.14)",
+    diffRemoved: "rgba(179, 37, 31, 0.14)",
+};
+const monokaiDark = {
+    base: "#f8f8f2",
+    keyword: "#f92672",
+    comment: "#75715e",
+    string: "#e6db74",
+    number: "#ae81ff",
+    function: "#a6e22e",
+    type: "#66d9ef",
+    tag: "#f92672",
+    attribute: "#a6e22e",
+    operator: "#f92672",
+    diffAdded: "rgba(166, 226, 46, 0.18)",
+    diffRemoved: "rgba(248, 53, 53, 0.18)",
+};
+// --- 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",
+    keyword: "#bd2f7a",
+    comment: "#6272a4",
+    string: "#8a7a1f",
+    number: "#7c4fd1",
+    function: "#1f9c4a",
+    type: "#0e93a8",
+    tag: "#bd2f7a",
+    attribute: "#1f9c4a",
+    operator: "#bd2f7a",
+    diffAdded: "rgba(31, 156, 74, 0.14)",
+    diffRemoved: "rgba(179, 54, 54, 0.14)",
+};
+const nightshadeDark = {
+    base: "#f8f8f2",
+    keyword: "#ff79c6",
+    comment: "#6272a4",
+    string: "#f1fa8c",
+    number: "#bd93f9",
+    function: "#50fa7b",
+    type: "#8be9fd",
+    tag: "#ff79c6",
+    attribute: "#50fa7b",
+    operator: "#ff79c6",
+    diffAdded: "rgba(80, 250, 123, 0.18)",
+    diffRemoved: "rgba(255, 85, 85, 0.18)",
+};
+// --- Neotokyo (Light / Dark — cyber yellow, hot pink, neon cyan) ----------
+const neotokyoLight = {
+    base: "#1a1025",
+    keyword: "#c2188f",
+    comment: "#7a7a9c",
+    string: "#8a7600",
+    number: "#0089a3",
+    function: "#a3157a",
+    type: "#7b2fd4",
+    tag: "#c2188f",
+    attribute: "#0089a3",
+    operator: "#0089a3",
+    diffAdded: "rgba(31, 156, 26, 0.14)",
+    diffRemoved: "rgba(194, 31, 61, 0.14)",
+};
+const neotokyoDark = {
+    base: "#e4e4f4",
+    keyword: "#ff2ec4",
+    comment: "#6f6f94",
+    string: "#fcee0a",
+    number: "#0ff0fc",
+    function: "#ff6ec7",
+    type: "#b967ff",
+    tag: "#ff2ec4",
+    attribute: "#0ff0fc",
+    operator: "#0ff0fc",
+    diffAdded: "rgba(57, 255, 20, 0.18)",
+    diffRemoved: "rgba(255, 43, 78, 0.18)",
+};
+export function isSyntaxThemeId(value) {
+    return SYNTAX_THEME_IDS.includes(value);
+}
+// Resolve a theme id + the app's color scheme to a full token palette. Only the
+// light/dark axis is coupled to the app; the theme brand is the user's choice.
+export function resolveSyntaxColors(id, colorScheme) {
+    const dark = colorScheme === "dark";
+    switch (id) {
+        case "default":
+            return expandRolePalette(dark ? defaultDark : defaultLight);
+        case "github":
+            return dark ? darkHighlightColors : lightHighlightColors;
+        case "vscode":
+            return expandRolePalette(dark ? vscodeDark : vscodeLight);
+        case "jetbrains":
+            return expandRolePalette(dark ? jetbrainsDark : jetbrainsLight);
+        case "monokai":
+            return expandRolePalette(dark ? monokaiDark : monokaiLight);
+        case "nightshade":
+            return expandRolePalette(dark ? nightshadeDark : nightshadeLight);
+        case "neotokyo":
+            return expandRolePalette(dark ? neotokyoDark : neotokyoLight);
+    }
+}
+//# sourceMappingURL=themes.js.map

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+export type HighlightStyle = "keyword" | "comment" | "string" | "number" | "literal" | "function" | "definition" | "class" | "type" | "tag" | "attribute" | "property" | "variable" | "operator" | "punctuation" | "regexp" | "escape" | "meta" | "heading" | "link";
+export interface HighlightToken {
+    text: string;
+    style: HighlightStyle | null;
+}
+export interface DiffBackgroundColors {
+    diffAdded: string;
+    diffRemoved: string;
+    diffAddedEmphasis: string;
+    diffRemovedEmphasis: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@otto-code/highlight",
+  "version": "0.5.0",
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "source": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "node ../../scripts/clean-package-dist.mjs",
+    "build": "tsc -p tsconfig.json --incremental false",
+    "build:clean": "npm run clean && npm run build",
+    "prepack": "npm run build:clean",
+    "test": "vitest run",
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@codemirror/language": "^6.12.3",
+    "@codemirror/legacy-modes": "^6.5.3",
+    "@lezer/common": "^1.5.0",
+    "@lezer/cpp": "^1.1.5",
+    "@lezer/css": "^1.3.0",
+    "@lezer/go": "^1.0.1",
+    "@lezer/highlight": "^1.2.3",
+    "@lezer/html": "^1.3.13",
+    "@lezer/java": "^1.1.3",
+    "@lezer/javascript": "^1.5.4",
+    "@lezer/json": "^1.0.3",
+    "@lezer/markdown": "^1.6.2",
+    "@lezer/php": "^1.0.5",
+    "@lezer/python": "^1.1.18",
+    "@lezer/rust": "^1.0.2",
+    "@lezer/xml": "^1.0.6",
+    "@lezer/yaml": "^1.0.4",
+    "@replit/codemirror-lang-csharp": "^6.2.0",
+    "lezer-elixir": "^1.1.2"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2",
+    "vitest": "^4.1.6"
+  }
+}