@ruckc/truss-code 0.0.0-stage → 1.12.0

package/dist/files.js

@@ -0,0 +1,57 @@
+import { diffLines, diffStats } from './diff.js';
+import { filePath, parsePatch } from './patch.js';
+const STATUS = { added: 'added', modified: 'modified', deleted: 'deleted', renamed: 'renamed', copied: 'added' };
+/** The files of a `git diff` as entries. */
+export const entriesFromPatch = (patch) => parsePatch(patch).map((f) => ({
+    path: filePath(f),
+    oldPath: f.status === 'renamed' || f.status === 'copied' ? f.oldPath : undefined,
+    status: STATUS[f.status],
+    binary: f.binary,
+    additions: f.additions,
+    deletions: f.deletions,
+    file: f
+}));
+/** An input file as an entry, counting its changes with the same options the diff view will use. */
+export function entryFromInput(f, opts = {}) {
+    const status = f.status ?? (f.oldPath && f.oldPath !== f.path ? 'renamed' : 'modified');
+    if (f.patch !== undefined) {
+        const parsed = parsePatch(f.patch)[0];
+        return { path: f.path, oldPath: f.oldPath, status, binary: !!(f.binary || parsed?.binary), additions: parsed?.additions ?? 0, deletions: parsed?.deletions ?? 0, file: parsed };
+    }
+    const binary = !!f.binary;
+    const s = binary ? { additions: 0, deletions: 0 } : diffStats(diffLines(f.old ?? '', f.new ?? '', opts));
+    return { path: f.path, oldPath: f.oldPath, status, binary, ...s, old: f.old ?? '', new: f.new ?? '' };
+}
+export const statusLetter = (s) => ({ added: 'A', modified: 'M', deleted: 'D', renamed: 'R' })[s];
+export function totals(entries) {
+    return { files: entries.length, additions: entries.reduce((n, e) => n + e.additions, 0), deletions: entries.reduce((n, e) => n + e.deletions, 0) };
+}
+/** A folder tree of the changed files: folders first, then files, each sorted by name. Folder ids are `dir:` plus their path; file ids are the file's path. */
+export function buildTree(entries) {
+    const top = { node: { id: '', label: '', children: [] }, dirs: new Map() };
+    for (const e of entries) {
+        const parts = e.path.split('/');
+        let at = top;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const id = 'dir:' + parts.slice(0, i + 1).join('/');
+            let d = at.dirs.get(id);
+            if (!d) {
+                d = { node: { id, label: parts[i], icon: 'folder', children: [] }, dirs: new Map() };
+                at.dirs.set(id, d);
+                at.node.children.push(d.node);
+            }
+            at = d;
+        }
+        at.node.children.push({ id: e.path, label: parts[parts.length - 1], icon: 'file', badge: statusLetter(e.status), description: `${e.status}, ${e.additions} added, ${e.deletions} removed` });
+    }
+    const sort = (list) => {
+        list.sort((a, b) => Number(!!b.children) - Number(!!a.children) || a.label.localeCompare(b.label));
+        for (const n of list)
+            if (n.children)
+                sort(n.children);
+    };
+    sort(top.node.children);
+    return top.node.children;
+}
+/** Ids of every folder in a tree, so the whole tree can start expanded. */
+export const folderIds = (nodes) => nodes.flatMap((n) => (n.children ? [n.id, ...folderIds(n.children)] : []));

package/dist/highlight.d.ts

@@ -0,0 +1,27 @@
+import type { MonacoApi } from './monaco.js';
+import { type Role, type Palette } from './theme.js';
+/** A run of text with one syntax role (`undefined` is plain text). */
+export interface Seg {
+    text: string;
+    role?: Role;
+}
+/** Splits one line at its token offsets and merges neighbours that share a role. */
+export declare function segmentLine(line: string, tokens?: {
+    offset: number;
+    type: string;
+}[]): Seg[];
+/** The line is split on any line ending, exactly like Monaco's models do. */
+export declare const splitLines: (text: string) => string[];
+/** Tokenizes `text` with Monaco's tokenizers (loading the language on demand). Unknown languages and blank text come back as plain text. */
+export declare function highlight(monaco: MonacoApi, text: string, language: string): Promise<Seg[][]>;
+/** A run with a syntax role and, for diffs, whether an intra-line change covers it. */
+export interface Piece extends Seg {
+    changed?: boolean;
+}
+/** Lays intra-line change marks over syntax segments of the same line text, splitting runs where the two disagree. */
+export declare function overlay(base: Seg[], marks?: {
+    text: string;
+    changed: boolean;
+}[]): Piece[];
+/** CSS custom properties that colour `.seg-<role>` text from a palette. Set them on the element that holds the code. */
+export declare const paletteVars: (p: Palette) => string;

package/dist/highlight.js

@@ -0,0 +1,84 @@
+import { scopeRole } from './theme.js';
+/** Splits one line at its token offsets and merges neighbours that share a role. */
+export function segmentLine(line, tokens = []) {
+    const out = [];
+    const push = (text, role) => {
+        if (!text)
+            return;
+        const last = out[out.length - 1];
+        if (last && last.role === role)
+            last.text += text;
+        else
+            out.push({ text, role });
+    };
+    if (!tokens.length) {
+        push(line);
+        return out;
+    }
+    if (tokens[0].offset > 0)
+        push(line.slice(0, tokens[0].offset));
+    tokens.forEach((t, i) => push(line.slice(t.offset, tokens[i + 1]?.offset ?? line.length), scopeRole(t.type)));
+    return out;
+}
+/** The line is split on any line ending, exactly like Monaco's models do. */
+export const splitLines = (text) => text.split(/\r\n|\r|\n/);
+const typed = (t) => t.some((l) => l.some((x) => x.type));
+const prepared = new Map();
+/**
+ * Waits until Monaco can tokenize `language`. Monarch languages are ready once `colorize` resolves; JSON and HTML only get their tokenizer
+ * after a model of that language exists, so one is made and the tokenizer awaited (at most about 1.6 s, once per language).
+ */
+function prepare(monaco, language, sample) {
+    let p = prepared.get(language);
+    if (!p) {
+        p = (async () => {
+            await monaco.editor.colorize('', language, {});
+            if (typed(monaco.editor.tokenize(sample, language)))
+                return;
+            const probe = monaco.editor.createModel('', language);
+            try {
+                for (let i = 0; i < 40 && !typed(monaco.editor.tokenize(sample, language)); i++)
+                    await new Promise((r) => setTimeout(r, 40));
+            }
+            finally {
+                probe.dispose();
+            }
+        })();
+        prepared.set(language, p);
+    }
+    return p;
+}
+/** Tokenizes `text` with Monaco's tokenizers (loading the language on demand). Unknown languages and blank text come back as plain text. */
+export async function highlight(monaco, text, language) {
+    const lines = splitLines(text);
+    if (language === 'plaintext' || !/\S/.test(text) || !monaco.languages.getLanguages().some((l) => l.id === language))
+        return lines.map((l) => segmentLine(l, []));
+    await prepare(monaco, language, text);
+    const tokens = monaco.editor.tokenize(text, language);
+    return lines.map((l, i) => segmentLine(l, tokens[i]));
+}
+/** Lays intra-line change marks over syntax segments of the same line text, splitting runs where the two disagree. */
+export function overlay(base, marks) {
+    if (!marks)
+        return base;
+    const out = [];
+    let bi = 0, off = 0;
+    for (const m of marks) {
+        for (let left = m.text.length; left > 0;) {
+            const b = base[bi];
+            if (!b)
+                return out; // base shorter than the marks: nothing more to colour
+            const take = Math.min(left, b.text.length - off);
+            out.push({ text: b.text.slice(off, off + take), role: b.role, changed: m.changed || undefined });
+            off += take;
+            left -= take;
+            if (off === b.text.length) {
+                bi++;
+                off = 0;
+            }
+        }
+    }
+    return out;
+}
+/** CSS custom properties that colour `.seg-<role>` text from a palette. Set them on the element that holds the code. */
+export const paletteVars = (p) => Object.entries(p.roles).map(([r, c]) => `--code-${r}:${c}`).join(';') + `;--code-bg:${p.bg};--code-fg:${p.fg};--code-added:${p.added};--code-removed:${p.removed};--code-added-strong:${p.addedStrong};--code-removed-strong:${p.removedStrong}`;

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { default as CodeEditor } from './CodeEditor.svelte';
+export { default as CodeBlock } from './CodeBlock.svelte';
+export { default as DiffView } from './DiffView.svelte';
+export { default as DiffFiles } from './DiffFiles.svelte';
+export { default as DiffEditor } from './DiffEditor.svelte';
+export { detectLanguage, resolveLanguage } from './lang.js';
+export { loadMonaco } from './monaco.js';
+export { buildPalette, monacoTheme, ensureContrast, contrast, parseColor } from './theme.js';
+export { diffLines, diffSeq, intraline, annotateIntraline, toHunks, formatHunks, unifiedPatch, foldItems, expandFold, splitRows, splitDocument, changeStarts, diffStats } from './diff.js';
+export { parsePatch, patchLines, unquotePath, filePath } from './patch.js';
+export { entriesFromPatch, buildTree } from './files.js';
+export type { CodeMarker, MarkerSeverity, CompletionItem, CompletionKind, CompletionContext, DiffAnnotation } from './types.js';
+export type { Palette, Role, Mode } from './theme.js';
+export type { DiffLine, Hunk, DiffOptions, IntraSeg, Expansion } from './diff.js';
+export type { PatchFile, FileStatus } from './patch.js';
+export type { DiffFileInput, DiffStatus } from './files.js';

package/dist/index.js

@@ -0,0 +1,12 @@
+export { default as CodeEditor } from './CodeEditor.svelte';
+export { default as CodeBlock } from './CodeBlock.svelte';
+export { default as DiffView } from './DiffView.svelte';
+export { default as DiffFiles } from './DiffFiles.svelte';
+export { default as DiffEditor } from './DiffEditor.svelte';
+export { detectLanguage, resolveLanguage } from './lang.js';
+export { loadMonaco } from './monaco.js';
+export { buildPalette, monacoTheme, ensureContrast, contrast, parseColor } from './theme.js';
+// pure diff and patch logic, usable without any component
+export { diffLines, diffSeq, intraline, annotateIntraline, toHunks, formatHunks, unifiedPatch, foldItems, expandFold, splitRows, splitDocument, changeStarts, diffStats } from './diff.js';
+export { parsePatch, patchLines, unquotePath, filePath } from './patch.js';
+export { entriesFromPatch, buildTree } from './files.js';

package/dist/lang.d.ts

@@ -0,0 +1,4 @@
+/** The Monaco language id for a file path, or `undefined` when the extension is unknown. */
+export declare function detectLanguage(path?: string): string | undefined;
+/** The language a component uses: an explicit one wins, then the path's, else plain text. */
+export declare const resolveLanguage: (language?: string, path?: string) => string;

package/dist/lang.js

@@ -0,0 +1,36 @@
+/** Language ids are Monaco's. Extensions and a few well-known file names map to them. */
+const EXT = {
+    ts: 'typescript', tsx: 'typescript', mts: 'typescript', cts: 'typescript',
+    js: 'javascript', jsx: 'javascript', mjs: 'javascript', cjs: 'javascript',
+    json: 'json', jsonc: 'json', json5: 'json', webmanifest: 'json',
+    yaml: 'yaml', yml: 'yaml',
+    md: 'markdown', markdown: 'markdown', mdx: 'markdown',
+    html: 'html', htm: 'html', svelte: 'html', vue: 'html',
+    css: 'css', scss: 'scss', less: 'less',
+    sql: 'sql', pgsql: 'pgsql', mysql: 'mysql',
+    py: 'python', pyw: 'python',
+    rs: 'rust', go: 'go', java: 'java', kt: 'kotlin', swift: 'swift', rb: 'ruby', php: 'php', lua: 'lua',
+    c: 'c', h: 'c', cc: 'cpp', cpp: 'cpp', cxx: 'cpp', hpp: 'cpp', hh: 'cpp', cs: 'csharp',
+    sh: 'shell', bash: 'shell', zsh: 'shell', ps1: 'powershell',
+    xml: 'xml', svg: 'xml', xsl: 'xml',
+    toml: 'ini', ini: 'ini', conf: 'ini', cfg: 'ini', properties: 'ini',
+    graphql: 'graphql', gql: 'graphql', proto: 'protobuf', tf: 'hcl', hcl: 'hcl',
+    dockerfile: 'dockerfile', bat: 'bat', cmd: 'bat', r: 'r', scala: 'scala', dart: 'dart', ex: 'elixir', exs: 'elixir',
+    txt: 'plaintext', log: 'plaintext', text: 'plaintext'
+};
+const NAMES = {
+    dockerfile: 'dockerfile', makefile: 'makefile', gemfile: 'ruby', rakefile: 'ruby', '.bashrc': 'shell', '.zshrc': 'shell', '.env': 'ini',
+    '.gitignore': 'plaintext', '.editorconfig': 'ini', '.babelrc': 'json', '.eslintrc': 'json'
+};
+/** The Monaco language id for a file path, or `undefined` when the extension is unknown. */
+export function detectLanguage(path) {
+    if (!path)
+        return undefined;
+    const base = path.replace(/^.*[\\/]/, '').toLowerCase();
+    if (NAMES[base])
+        return NAMES[base];
+    const dot = base.lastIndexOf('.');
+    return dot < 0 ? undefined : EXT[base.slice(dot + 1)];
+}
+/** The language a component uses: an explicit one wins, then the path's, else plain text. */
+export const resolveLanguage = (language, path) => language || detectLanguage(path) || 'plaintext';

package/dist/monaco.d.ts

@@ -0,0 +1,15 @@
+import type * as Monaco from 'monaco-editor';
+import { type Theme } from './theme.js';
+export type MonacoApi = typeof Monaco;
+/** A worker constructor, as produced by Vite's `?worker` imports. */
+export type WorkerFactory = () => Worker;
+/** Monaco's worker label to the kind of worker that serves it. */
+export declare const workerKind: (label: string) => string;
+/**
+ * Loads Monaco once (a separate chunk, never during SSR) and wires its workers through the bundler:
+ * every language service worker is its own lazy chunk that is fetched only when that language is used.
+ * If the app already set `self.MonacoEnvironment`, it is left alone.
+ */
+export declare function loadMonaco(): Promise<MonacoApi>;
+/** Defines and selects the Truss theme for the tokens in effect at `host`. Monaco themes are global, so the last editor to call this wins. */
+export declare function applyTheme(monaco: MonacoApi, host: Element): Theme;

package/dist/monaco.js

@@ -0,0 +1,40 @@
+import { readTheme, monacoTheme } from './theme.js';
+let pending;
+const workers = {
+    json: () => import('monaco-editor/language/json/json.worker.js?worker').then((m) => () => new m.default()),
+    css: () => import('monaco-editor/language/css/css.worker.js?worker').then((m) => () => new m.default()),
+    html: () => import('monaco-editor/language/html/html.worker.js?worker').then((m) => () => new m.default()),
+    typescript: () => import('monaco-editor/language/typescript/ts.worker.js?worker').then((m) => () => new m.default()),
+    editor: () => import('monaco-editor/editor/editor.worker.js?worker').then((m) => () => new m.default())
+};
+/** Monaco's worker label to the kind of worker that serves it. */
+export const workerKind = (label) => label === 'json' ? 'json' : ['css', 'scss', 'less'].includes(label) ? 'css' : ['html', 'handlebars', 'razor'].includes(label) ? 'html' : ['typescript', 'javascript'].includes(label) ? 'typescript' : 'editor';
+/**
+ * Loads Monaco once (a separate chunk, never during SSR) and wires its workers through the bundler:
+ * every language service worker is its own lazy chunk that is fetched only when that language is used.
+ * If the app already set `self.MonacoEnvironment`, it is left alone.
+ */
+export function loadMonaco() {
+    if (!pending) {
+        pending = (async () => {
+            const g = globalThis;
+            if (!g.MonacoEnvironment) {
+                const cache = new Map();
+                const ready = Promise.all(Object.entries(workers).map(async ([k, load]) => cache.set(k, await load())));
+                await ready;
+                g.MonacoEnvironment = { getWorker: (_id, label) => cache.get(workerKind(label))() };
+            }
+            return (await import('monaco-editor'));
+        })();
+        pending.catch(() => { pending = undefined; }); // a failed load (offline, blocked chunk) can be retried by the next mount
+    }
+    return pending;
+}
+/** Defines and selects the Truss theme for the tokens in effect at `host`. Monaco themes are global, so the last editor to call this wins. */
+export function applyTheme(monaco, host) {
+    const theme = readTheme(host);
+    const name = `truss-${theme.mode}`;
+    monaco.editor.defineTheme(name, monacoTheme(theme.palette));
+    monaco.editor.setTheme(name);
+    return theme;
+}

package/dist/patch.d.ts

@@ -0,0 +1,24 @@
+import { type DiffLine, type Hunk } from './diff.js';
+export type FileStatus = 'added' | 'modified' | 'deleted' | 'renamed' | 'copied';
+/** One file of a patch. */
+export interface PatchFile {
+    oldPath?: string;
+    newPath?: string;
+    status: FileStatus;
+    binary: boolean;
+    /** Percent, for renames and copies. */
+    similarity?: number;
+    oldMode?: string;
+    newMode?: string;
+    hunks: Hunk[];
+    additions: number;
+    deletions: number;
+}
+/** The path to show for a file: the new one, or the old one for a deletion. */
+export declare const filePath: (f: Pick<PatchFile, "oldPath" | "newPath">) => string;
+/** Decodes a path as `git diff` writes it: plain, or in double quotes with C escapes and UTF-8 bytes as octal (`\303\251`). */
+export declare function unquotePath(raw: string): string;
+/** Parses unified diff text, including `git diff` / `git format-patch` output with renames, mode changes, binary files, CRLF and "". */
+export declare function parsePatch(text: string): PatchFile[];
+/** The lines of a parsed file in display order, with a `gap` line for the unchanged lines a patch leaves out between (and before) hunks. */
+export declare function patchLines(file: Pick<PatchFile, 'hunks'>): DiffLine[];

package/dist/patch.js

@@ -0,0 +1,185 @@
+import { diffStats } from './diff.js';
+/** The path to show for a file: the new one, or the old one for a deletion. */
+export const filePath = (f) => f.newPath ?? f.oldPath ?? '';
+const OCTAL = /\\([0-7]{3}|[abfnrtv"\\])/g;
+const SIMPLE = { a: '\x07', b: '\b', f: '\f', n: '\n', r: '\r', t: '\t', v: '\v', '"': '"', '\\': '\\' };
+/** Decodes a path as `git diff` writes it: plain, or in double quotes with C escapes and UTF-8 bytes as octal (`\303\251`). */
+export function unquotePath(raw) {
+    const s = raw.trim();
+    if (!(s.length >= 2 && s.startsWith('"') && s.endsWith('"')))
+        return s;
+    const bytes = [];
+    let last = 0;
+    const body = s.slice(1, -1);
+    const flush = (upto) => { for (const b of new TextEncoder().encode(body.slice(last, upto)))
+        bytes.push(b); };
+    for (const m of body.matchAll(OCTAL)) {
+        flush(m.index);
+        last = m.index + m[0].length;
+        bytes.push(m[1].length === 3 ? parseInt(m[1], 8) : SIMPLE[m[1]].charCodeAt(0));
+    }
+    flush(body.length);
+    return new TextDecoder().decode(new Uint8Array(bytes));
+}
+/** A `---`/`+++` path: unquoted, minus the `a/` or `b/` prefix and a trailing tab-separated timestamp; `/dev/null` is `undefined`. */
+function sidePath(raw, prefix) {
+    let p = raw.replace(/\t.*$/, '').trimEnd();
+    p = unquotePath(p);
+    if (p === '/dev/null')
+        return undefined;
+    return p.startsWith(prefix) ? p.slice(2) : p;
+}
+/** The two paths of a `diff --git a/x b/y` line (spaces and quoting included). The `---`/`+++` and rename lines that follow correct any doubt. */
+function gitHeaderPaths(rest) {
+    const strip = (p, prefix) => (p.startsWith(prefix) ? p.slice(2) : p);
+    if (rest.includes('"')) {
+        const t = rest.match(/"(?:[^"\\]|\\.)*"|\S+/g); // a quote is a non-space, so there is always a match
+        return [strip(unquotePath(t[0] ?? ''), 'a/'), strip(unquotePath(t[1] ?? ''), 'b/')];
+    }
+    const len = (rest.length - 5) / 2; // `a/X b/X`: equal paths, the usual case, even with spaces in them
+    if (Number.isInteger(len) && len > 0 && rest.slice(2, 2 + len) === rest.slice(len + 5))
+        return [rest.slice(2, 2 + len), rest.slice(len + 5)];
+    const at = rest.indexOf(' b/');
+    return at < 0 ? [strip(rest, 'a/'), undefined] : [strip(rest.slice(0, at), 'a/'), rest.slice(at + 3)];
+}
+/** "" applies to the line just above it. */
+const markNoEol = (h) => { const last = h.lines[h.lines.length - 1]; if (last)
+    last.noEol = true; };
+const HUNK = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@ ?(.*)$/;
+/** Parses unified diff text, including `git diff` / `git format-patch` output with renames, mode changes, binary files, CRLF and "". */
+export function parsePatch(text) {
+    const rows = text.split('\n');
+    if (rows[rows.length - 1] === '')
+        rows.pop();
+    const files = [];
+    let f;
+    let git = false;
+    const start = () => {
+        const n = { status: 'modified', binary: false, hunks: [], additions: 0, deletions: 0 };
+        files.push(n);
+        return n;
+    };
+    const head = (s) => s.replace(/\r$/, '');
+    for (let i = 0; i < rows.length; i++) {
+        const row = head(rows[i]);
+        if (row.startsWith('diff --git ')) {
+            f = start();
+            git = true;
+            [f.oldPath, f.newPath] = gitHeaderPaths(row.slice(11));
+            continue;
+        }
+        if (!f && (row.startsWith('--- ') || row.startsWith('Binary files '))) {
+            f = start();
+            git = false;
+        }
+        if (!f)
+            continue; // text before the first file (a mail header, a commit message)
+        let m;
+        if (row.startsWith('--- ') && !f.hunks.length) {
+            f.oldPath = sidePath(row.slice(4), 'a/');
+            if (f.oldPath === undefined)
+                f.status = 'added';
+            continue;
+        }
+        if (row.startsWith('+++ ') && !f.hunks.length) {
+            f.newPath = sidePath(row.slice(4), 'b/');
+            if (f.newPath === undefined)
+                f.status = 'deleted';
+            continue;
+        }
+        if (row.startsWith('--- ') && f.hunks.length && !git) {
+            f = start();
+            i--;
+            continue;
+        } // a second file in a plain unified diff
+        if ((m = /^new file mode (\d+)/.exec(row))) {
+            f.status = 'added';
+            f.newMode = m[1];
+            f.oldPath = undefined;
+            continue;
+        }
+        if ((m = /^deleted file mode (\d+)/.exec(row))) {
+            f.status = 'deleted';
+            f.oldMode = m[1];
+            f.newPath = undefined;
+            continue;
+        }
+        if ((m = /^old mode (\d+)/.exec(row))) {
+            f.oldMode = m[1];
+            continue;
+        }
+        if ((m = /^new mode (\d+)/.exec(row))) {
+            f.newMode = m[1];
+            continue;
+        }
+        if ((m = /^similarity index (\d+)%/.exec(row))) {
+            f.similarity = +m[1];
+            continue;
+        }
+        if ((m = /^(rename|copy) from (.*)$/.exec(row))) {
+            f.status = m[1] === 'rename' ? 'renamed' : 'copied';
+            f.oldPath = unquotePath(m[2]);
+            continue;
+        }
+        if ((m = /^(rename|copy) to (.*)$/.exec(row))) {
+            f.newPath = unquotePath(m[2]);
+            continue;
+        }
+        if (row.startsWith('Binary files ') || row === 'GIT binary patch') {
+            f.binary = true;
+            continue;
+        }
+        if (!(m = HUNK.exec(row)))
+            continue;
+        // a hunk: read exactly as many lines as its header promises, so content that looks like a header cannot end it early
+        const h = { oldStart: +m[1], oldLines: m[2] === undefined ? 1 : +m[2], newStart: +m[3], newLines: m[4] === undefined ? 1 : +m[4], section: m[5] || undefined, lines: [] };
+        let oldNo = h.oldLines ? h.oldStart : h.oldStart + 1, newNo = h.newLines ? h.newStart : h.newStart + 1;
+        let ro = h.oldLines, rn = h.newLines;
+        while ((ro > 0 || rn > 0) && i + 1 < rows.length) {
+            const raw = rows[++i];
+            const tag = raw[0] ?? ' ';
+            const body = raw.slice(1);
+            const cr = body.endsWith('\r');
+            const t = cr ? body.slice(0, -1) : body;
+            if (tag === '\\') {
+                markNoEol(h);
+                continue;
+            } // "\ No newline" in the middle of a hunk belongs to the line above it
+            if (tag === '-') {
+                h.lines.push({ type: 'del', oldNo: oldNo++, text: t, cr });
+                ro--;
+            }
+            else if (tag === '+') {
+                h.lines.push({ type: 'add', newNo: newNo++, text: t, cr });
+                rn--;
+            }
+            else {
+                h.lines.push({ type: 'ctx', oldNo: oldNo++, newNo: newNo++, text: t, cr });
+                ro--;
+                rn--;
+            }
+        }
+        while (i + 1 < rows.length && rows[i + 1].startsWith('\\')) {
+            i++;
+            markNoEol(h);
+        }
+        f.hunks.push(h);
+        const s = diffStats(h.lines);
+        f.additions += s.additions;
+        f.deletions += s.deletions;
+    }
+    return files;
+}
+/** The lines of a parsed file in display order, with a `gap` line for the unchanged lines a patch leaves out between (and before) hunks. */
+export function patchLines(file) {
+    const out = [];
+    let prevEnd = 0; // the last old line the previous hunk reached
+    for (const h of file.hunks) {
+        const first = h.oldLines ? h.oldStart : h.oldStart + 1;
+        if (first - 1 > prevEnd)
+            out.push({ type: 'gap', text: '', count: first - 1 - prevEnd });
+        out.push(...h.lines);
+        prevEnd = h.oldLines ? h.oldStart + h.oldLines - 1 : h.oldStart;
+    }
+    return out;
+}

package/dist/theme.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Turns the design tokens into an editor palette. Everything here is pure except `readTheme`, which reads the live tokens.
+ * The syntax colours come from the chart categorical palette (--trc-s1..8) and are nudged until they reach WCAG AA (4.5:1)
+ * on every background the text can sit on (editor, current line, selection), so any brand's tokens stay readable.
+ */
+export type RGBA = [number, number, number, number];
+export type Mode = 'light' | 'dark';
+export type Role = 'keyword' | 'string' | 'number' | 'type' | 'function' | 'variable' | 'constant' | 'operator' | 'tag' | 'attribute' | 'regexp' | 'comment' | 'invalid' | 'delimiter' | 'meta';
+/** Raw custom-property values by name, e.g. `{ '--tr-surface': '#fbfbfe' }`. */
+export type Tokens = Record<string, string | undefined>;
+export declare const MIN_CONTRAST = 4.5;
+/** Parses `#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa`, `rgb()` and `rgba()` (comma or space syntax). Anything else is `null`. */
+export declare function parseColor(input?: string | null): RGBA | null;
+/** `#rrggbb`, or `#rrggbbaa` when the colour is translucent. */
+export declare const toHex: ([r, g, b, a]: RGBA) => string;
+/** Blends `a` toward `b` by `t` (0 = a, 1 = b); the result is opaque. */
+export declare const mix: (a: RGBA, b: RGBA, t: number) => RGBA;
+/** Paints a translucent colour over an opaque one. */
+export declare const over: (fg: RGBA, bg: RGBA) => RGBA;
+export declare function luminance([r, g, b]: RGBA): number;
+export declare function contrast(a: RGBA, b: RGBA): number;
+/** The colour closest to `fg` (blended toward black or white) that reaches `min`:1 on every background. */
+export declare function ensureContrast(fg: RGBA, bgs: RGBA[], min?: number): RGBA;
+export declare const TOKEN_VARS: readonly ["--tr-surface", "--tr-surface-container-low", "--tr-surface-container", "--tr-surface-container-high", "--tr-on-surface", "--tr-on-surface-variant", "--tr-outline", "--tr-outline-variant", "--tr-primary", "--tr-danger", "--tr-warning", "--tr-success", "--trc-s1", "--trc-s2", "--trc-s3", "--trc-s4", "--trc-s5", "--trc-s6", "--trc-s7", "--trc-s8", "--tr-syntax-keyword", "--tr-syntax-string", "--tr-syntax-number", "--tr-syntax-comment", "--tr-syntax-function", "--tr-syntax-type", "--tr-syntax-variable", "--tr-syntax-constant", "--tr-syntax-operator", "--tr-syntax-punctuation", "--tr-syntax-tag", "--tr-syntax-attr", "--tr-syntax-regexp"];
+/** Built-in values, used for any token that is not defined (the charts stylesheet is optional). They match tokens.css and charts.css. */
+export declare const FALLBACK: Record<Mode, Record<string, string>>;
+export declare const ROLES: Role[];
+export interface Palette {
+    mode: Mode;
+    bg: string;
+    fg: string;
+    lineHighlight: string;
+    selection: string;
+    cursor: string;
+    muted: string;
+    border: string;
+    widget: string;
+    /** Diff backgrounds: a line, and the stronger mark for the changed words inside it. */
+    added: string;
+    removed: string;
+    addedStrong: string;
+    removedStrong: string;
+    roles: Record<Role, string>;
+    /** the lowest contrast ratio of any syntax colour on any editor background, for tests and the docs */
+    minContrast: number;
+}
+export declare function buildPalette(tokens: Tokens, mode: Mode): Palette;
+/** Monaco token types (and their dotted prefixes) to a role. The longest matching prefix wins, so `string.key.json` beats `string`. */
+export declare const SCOPES: [prefix: string, role: Role, style?: 'italic' | 'bold'][];
+/** The role of a Monaco token type such as `keyword.sql`, or `undefined` for plain text. */
+export declare function scopeRole(type: string): Role | undefined;
+export interface ThemeData {
+    base: 'vs' | 'vs-dark';
+    inherit: boolean;
+    rules: {
+        token: string;
+        foreground?: string;
+        background?: string;
+        fontStyle?: string;
+    }[];
+    colors: Record<string, string>;
+}
+/** The Monaco theme for a palette. */
+export declare function monacoTheme(p: Palette): ThemeData;
+export interface Metrics {
+    fontSize: number;
+    lineHeight: number;
+    fontFamily: string;
+}
+/** Editor type metrics from the density-scaled tokens: `--tr-text-md` (px) and `--tr-leading-normal` (a ratio). */
+export declare function fontMetrics(textMd?: string, leading?: string, family?: string): Metrics;
+export interface Theme {
+    mode: Mode;
+    palette: Palette;
+    metrics: Metrics;
+}
+/** The theme in effect at `el`: nearest `data-theme`, else the OS preference; tokens and density as computed there. */
+export declare function readTheme(el: Element): Theme;
+/** Calls `cb` whenever the theme or density can have changed (`data-theme`, `data-density`, class or style on any ancestor, or the OS scheme). Returns a stop function. */
+export declare function watchTheme(el: Element, cb: () => void): () => void;