@nexrall/code-core 1.4.76 → 1.4.77

package/dist/context/contextFiles.js

@@ -0,0 +1,310 @@
+"use strict";
+// `/pin` and `/exclude` — the two lists that decide which project files ride
+// along WITHOUT the user retyping them:
+//
+//   /pin src/auth.ts     keep this file in front of the model even after a
+//                        /compact rewrites the conversation away
+//   /exclude generated/  never suggest it in the @ menu, never attach it
+//
+// Both lists live per project in ~/.nexrall/cli-context/<name>-<hash>.json so
+// they survive restarts (the whole point of a pin is that it is durable, and an
+// exclusion the user has to retype every morning is worse than useless).
+// Pure string/path logic plus a couple of tiny fs helpers, so every rule here
+// is unit-testable — see test/contextFiles.test.ts.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_CONTEXT_SET = void 0;
+exports.contextSetPath = contextSetPath;
+exports.loadContextSet = loadContextSet;
+exports.saveContextSet = saveContextSet;
+exports.relInProject = relInProject;
+exports.globToRegExp = globToRegExp;
+exports.isExcluded = isExcluded;
+exports.addPinned = addPinned;
+exports.removePinned = removePinned;
+exports.addExcluded = addExcluded;
+exports.removeExcluded = removeExcluded;
+exports.clearPinned = clearPinned;
+exports.clearExcluded = clearExcluded;
+exports.readPinned = readPinned;
+exports.describeContextSet = describeContextSet;
+// Lives in core (moved from the CLI's ui/contextFiles.ts, 2026-10-04) so the
+// VS Code panel manages the same per-project pinned/excluded set; the
+// CLI module is a re-export shim.
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+exports.EMPTY_CONTEXT_SET = { pinned: [], excluded: [] };
+// ─── Storage ─────────────────────────────────────────────────────────────────
+// NEXRALL_CLI_CONTEXT_DIR overrides the store root — used by tests so they never
+// touch the real ~/.nexrall/cli-context (same pattern as NEXRALL_CLI_SESSIONS_DIR).
+function contextRoot() {
+    return process.env.NEXRALL_CLI_CONTEXT_DIR || path.join(os.homedir(), '.nexrall', 'cli-context');
+}
+/**
+ * One file per project directory. The hash is of the resolved path, so two
+ * projects that happen to share a folder name ("api", "app") cannot read each
+ * other's list; the readable prefix is there for a human poking at the folder.
+ */
+function contextSetPath(workDir) {
+    const abs = path.resolve(workDir);
+    const key = crypto.createHash('sha1').update(abs).digest('hex').slice(0, 12);
+    const label = path
+        .basename(abs)
+        .replace(/[^\w.-]+/g, '-')
+        .slice(0, 24) || 'project';
+    return path.join(contextRoot(), `${label}-${key}.json`);
+}
+function cleanList(v) {
+    if (!Array.isArray(v))
+        return [];
+    return [...new Set(v.filter((x) => typeof x === 'string' && x.trim() !== '').map((x) => x.trim()))];
+}
+/** Missing or corrupt file → an empty set: a bad file must not stop the CLI. */
+function loadContextSet(workDir) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(contextSetPath(workDir), 'utf-8'));
+        return { pinned: cleanList(raw.pinned), excluded: cleanList(raw.excluded) };
+    }
+    catch {
+        return { ...exports.EMPTY_CONTEXT_SET };
+    }
+}
+function saveContextSet(workDir, set) {
+    try {
+        const file = contextSetPath(workDir);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify({ pinned: set.pinned, excluded: set.excluded }, null, 2), 'utf-8');
+    }
+    catch {
+        /* non-fatal: the in-memory lists still work for this session */
+    }
+}
+// ─── Paths ───────────────────────────────────────────────────────────────────
+/**
+ * `@src/a.ts` / `src/a.ts` / `./src/a.ts` → `src/a.ts`. Null when the path is
+ * empty, IS the project root, or escapes it (`../secrets`, `/etc/passwd`) — a
+ * pin is fed back to the model, so it may only ever name something inside.
+ * Purely lexical (no fs): a not-yet-created file can still be pinned.
+ */
+function relInProject(input, workDir) {
+    const raw = input.trim().replace(/^@/, '').trim();
+    if (!raw)
+        return null;
+    const root = path.resolve(workDir);
+    const rel = path.relative(root, path.resolve(root, raw));
+    if (!rel || rel.startsWith('..') || path.isAbsolute(rel))
+        return null;
+    return rel.split(path.sep).join('/');
+}
+// ─── The /exclude matcher ────────────────────────────────────────────────────
+const compiled = new Map();
+/**
+ * Glob for an `/exclude` pattern:
+ *   • a trailing "/" is decoration — "generated/" and "generated" mean the same
+ *     thing here, because a match on the directory already covers its contents;
+ *   • a pattern WITHOUT a "/" matches a path segment at any depth
+ *     ("node_modules" hides every one of them, exactly like .gitignore);
+ *   • a pattern WITH a "/" is anchored to the project root
+ *     ("src/generated" does not hide "vendor/src/generated");
+ *   • either way the match ends at a path boundary, so a pattern naming a
+ *     DIRECTORY hides everything inside it ("src/generated" hides
+ *     "src/generated/x.ts"), while "node_modules" still never matches
+ *     "node_modules_backup";
+ *   • "*" stops at a "/", "**" crosses them, "?" is one character.
+ */
+function globToRegExp(pattern) {
+    const hit = compiled.get(pattern);
+    if (hit)
+        return hit;
+    const p = pattern.trim().replace(/^\.\//, '').replace(/\/+$/, '');
+    const anchored = p.includes('/');
+    let re = '';
+    for (let i = 0; i < p.length; i++) {
+        const ch = p[i];
+        if (ch === '*') {
+            if (p[i + 1] === '*') {
+                re += '.*';
+                i++;
+            }
+            else
+                re += '[^/]*';
+        }
+        else if (ch === '?')
+            re += '[^/]';
+        else
+            re += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    }
+    const rx = new RegExp(anchored ? `^${re}(/|$)` : `(^|/)${re}(/|$)`);
+    compiled.set(pattern, rx);
+    return rx;
+}
+/** True when `rel` (project-relative, POSIX) is hidden by any of `patterns`. */
+function isExcluded(rel, patterns) {
+    if (!patterns.length)
+        return false;
+    const norm = rel.replace(/^\.\//, '');
+    return patterns.some((p) => {
+        try {
+            return globToRegExp(p).test(norm);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function sorted(list) {
+    return [...list].sort((a, b) => a.localeCompare(b));
+}
+function addPinned(set, rel) {
+    if (isExcluded(rel, set.excluded)) {
+        return { ok: false, message: `${rel} is excluded — /unexclude it first`, set };
+    }
+    if (set.pinned.includes(rel)) {
+        return { ok: false, message: `${rel} is already pinned`, set };
+    }
+    return { ok: true, message: `Pinned ${rel}`, set: { ...set, pinned: [...set.pinned, rel] } };
+}
+function removePinned(set, rel) {
+    if (!set.pinned.includes(rel)) {
+        return { ok: false, message: `${rel} is not pinned`, set };
+    }
+    return { ok: true, message: `Unpinned ${rel}`, set: { ...set, pinned: set.pinned.filter((p) => p !== rel) } };
+}
+function addExcluded(set, pattern) {
+    const p = pattern.trim().replace(/^@/, '').replace(/\/+$/, '');
+    if (!p)
+        return { ok: false, message: 'Nothing to exclude', set };
+    if (set.excluded.includes(p))
+        return { ok: false, message: `${p} is already excluded`, set };
+    // An exclusion overrides a pin — say so instead of silently leaving a file
+    // pinned AND excluded, which would read as "it is still in context".
+    const dropped = set.pinned.filter((rel) => isExcluded(rel, [p]));
+    const edit = {
+        ok: true,
+        message: `Excluded ${p}` + (dropped.length ? ` — unpinned ${dropped.join(', ')}` : ''),
+        set: { ...set, excluded: [...set.excluded, p], pinned: set.pinned.filter((rel) => !dropped.includes(rel)) },
+    };
+    return edit;
+}
+function removeExcluded(set, pattern) {
+    const p = pattern.trim().replace(/^@/, '').replace(/\/+$/, '');
+    if (!set.excluded.includes(p))
+        return { ok: false, message: `${p} is not excluded`, set };
+    return { ok: true, message: `Unexcluded ${p}`, set: { ...set, excluded: set.excluded.filter((x) => x !== p) } };
+}
+/** Bare `/unpin` / `/unexclude` clear the matching list. */
+function clearPinned(set) {
+    return set.pinned.length
+        ? { ok: true, message: `Unpinned all ${set.pinned.length} file(s)`, set: { ...set, pinned: [] } }
+        : { ok: false, message: 'Nothing is pinned', set };
+}
+function clearExcluded(set) {
+    return set.excluded.length
+        ? { ok: true, message: `Cleared ${set.excluded.length} exclusion(s)`, set: { ...set, excluded: [] } }
+        : { ok: false, message: 'Nothing is excluded', set };
+}
+/**
+ * Contents of the pinned files, shaped like an `@` attachment so the model sees
+ * the same framing it already knows. Budgets mirror expandMentions': per file,
+ * and for the batch, because pinned paths accumulate over weeks and a runaway
+ * 200 KB JSON would otherwise be re-sent on every compaction.
+ */
+function readPinned(workDir, pinned, maxBytes = 100000, maxTotal = 300000) {
+    const out = { attachments: [], notes: [] };
+    let total = 0;
+    for (const rel of pinned) {
+        if (total >= maxTotal) {
+            out.notes.push(`${rel} skipped — pinned size limit reached`);
+            continue;
+        }
+        const abs = path.join(workDir, rel);
+        let st;
+        try {
+            st = fs.statSync(abs);
+        }
+        catch {
+            out.notes.push(`${rel} is missing — /unpin it or restore the file`);
+            continue;
+        }
+        if (!st.isFile()) {
+            out.notes.push(`${rel} is not a file`);
+            continue;
+        }
+        let buf;
+        try {
+            const fd = fs.openSync(abs, 'r');
+            try {
+                const want = Math.min(maxBytes, Math.max(0, maxTotal - total), st.size);
+                buf = Buffer.alloc(want);
+                fs.readSync(fd, buf, 0, want, 0);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        catch {
+            out.notes.push(`${rel} could not be read`);
+            continue;
+        }
+        if (buf.subarray(0, 8000).includes(0)) {
+            out.notes.push(`${rel} is a binary file — not attached`);
+            continue;
+        }
+        const content = buf.toString('utf-8');
+        total += buf.length;
+        out.attachments.push({
+            rel,
+            kind: 'file',
+            content,
+            truncated: st.size > buf.length,
+            lines: content.split('\n').length,
+        });
+    }
+    return out;
+}
+/** Human-facing summary of what each list currently holds. */
+function describeContextSet(set) {
+    const lines = [];
+    lines.push(set.pinned.length
+        ? `Pinned (kept through /compact): ${sorted(set.pinned).join(', ')}`
+        : 'Nothing pinned. /pin <path> keeps a file in context across /compact.');
+    lines.push(set.excluded.length
+        ? `Excluded from context: ${sorted(set.excluded).join(', ')}`
+        : 'Nothing excluded. /exclude <glob> hides paths from the @ menu and attachments.');
+    return lines;
+}
+//# sourceMappingURL=contextFiles.js.map

package/dist/diff/collect.d.ts

@@ -0,0 +1,25 @@
+import { type DiffFile } from './diffView';
+/**
+ * Raw `git diff` of everything uncommitted (staged + unstaged, vs HEAD) plus the list of
+ * untracked files, or null outside a repo. Colour and external diff drivers are forced off
+ * so the parser in diffView.ts always sees plain unified diff.
+ */
+export declare function gitDiffRaw(cwd: string): {
+    diff: string;
+    untracked: string[];
+} | null;
+/**
+ * The whole uncommitted changeset as DiffFiles: the parsed diff first, then the
+ * untracked files (inlined while reasonable, listed-only when huge or binary).
+ * Null when the directory is not a git repository.
+ */
+export declare function collectChangedFiles(workDir: string): DiffFile[] | null;
+/**
+ * Current branch (or 7-char sha when detached) read straight from `.git/HEAD` — no
+ * process spawn, so it is cheap enough to refresh after every turn. Walks up from
+ * `cwd` like git does, and follows the `gitdir:` pointer that worktrees and
+ * submodules use instead of a `.git` directory. Null outside a repo or on any
+ * read problem: a status bar must never throw.
+ */
+export declare function gitBranch(cwd: string): string | null;
+//# sourceMappingURL=collect.d.ts.map

package/dist/diff/collect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect.d.ts","sourceRoot":"","sources":["../../src/diff/collect.ts"],"names":[],"mappings":"AAaA,OAAO,EAAsD,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE/F;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAmCpF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,EAAE,GAAG,IAAI,CAqBtE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA+BpD"}

package/dist/diff/collect.js

@@ -0,0 +1,169 @@
+"use strict";
+// Collecting the uncommitted changeset — "everything git would show if you ran
+// `git diff HEAD` plus the untracked files" — as parsed DiffFiles.
+//
+// Moved from two CLI homes (2026-10-04, both re-export/call in through here):
+//   • gitDiffRaw was commands/sessionTools.ts — raw `git diff` + ls-files;
+//   • the collect step was chat.ts's changedFilesIn — parse + fold in untracked.
+// Lives in core so the VS Code panel's /review and /diff render the SAME data
+// the CLI renders, from the same git porcelain invocation (colour and external
+// diff drivers forced off so the parser always sees plain unified diff).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitDiffRaw = gitDiffRaw;
+exports.collectChangedFiles = collectChangedFiles;
+exports.gitBranch = gitBranch;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const diffView_1 = require("./diffView");
+/**
+ * Raw `git diff` of everything uncommitted (staged + unstaged, vs HEAD) plus the list of
+ * untracked files, or null outside a repo. Colour and external diff drivers are forced off
+ * so the parser in diffView.ts always sees plain unified diff.
+ */
+function gitDiffRaw(cwd) {
+    const run = (args) => (0, child_process_1.execFileSync)('git', args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 15000,
+        maxBuffer: 32 * 1024 * 1024,
+    });
+    try {
+        run(['rev-parse', '--is-inside-work-tree']);
+    }
+    catch {
+        return null;
+    }
+    const base = ['-c', 'core.quotepath=off', 'diff', '--no-color', '--no-ext-diff', '--no-textconv'];
+    let diff;
+    try {
+        diff = run([...base, 'HEAD']);
+    }
+    catch {
+        // No commits yet: HEAD does not exist — staged changes are all there is.
+        try {
+            diff = run([...base, '--cached']);
+        }
+        catch {
+            diff = '';
+        }
+    }
+    let untracked = [];
+    try {
+        untracked = run(['-c', 'core.quotepath=off', 'ls-files', '--others', '--exclude-standard'])
+            .split('\n')
+            .filter(Boolean);
+    }
+    catch {
+        /* ignore */
+    }
+    return { diff, untracked };
+}
+/**
+ * The whole uncommitted changeset as DiffFiles: the parsed diff first, then the
+ * untracked files (inlined while reasonable, listed-only when huge or binary).
+ * Null when the directory is not a git repository.
+ */
+function collectChangedFiles(workDir) {
+    const raw = gitDiffRaw(workDir);
+    if (!raw)
+        return null;
+    const files = (0, diffView_1.parseUnifiedDiff)(raw.diff);
+    const seen = new Set(files.map((f) => f.path));
+    for (const rel of raw.untracked) {
+        if (seen.has(rel))
+            continue;
+        try {
+            const abs = path.resolve(workDir, rel);
+            const st = fs.statSync(abs);
+            if (!st.isFile())
+                continue;
+            files.push(st.size > diffView_1.MAX_UNTRACKED_BYTES
+                ? { path: rel, status: 'added', additions: 0, deletions: 0, hunks: [] }
+                : (0, diffView_1.newFileDiff)(rel, fs.readFileSync(abs, 'utf8')));
+        }
+        catch {
+            /* unreadable — skip */
+        }
+    }
+    return files;
+}
+/**
+ * Current branch (or 7-char sha when detached) read straight from `.git/HEAD` — no
+ * process spawn, so it is cheap enough to refresh after every turn. Walks up from
+ * `cwd` like git does, and follows the `gitdir:` pointer that worktrees and
+ * submodules use instead of a `.git` directory. Null outside a repo or on any
+ * read problem: a status bar must never throw.
+ */
+function gitBranch(cwd) {
+    try {
+        let dir = path.resolve(cwd);
+        for (let i = 0; i < 40; i++) {
+            const dotGit = path.join(dir, '.git');
+            let st = null;
+            try {
+                st = fs.statSync(dotGit);
+            }
+            catch {
+                /* keep walking */
+            }
+            if (st) {
+                let gitDir = dotGit;
+                if (st.isFile()) {
+                    const m = /^gitdir:\s*(.+)\s*$/m.exec(fs.readFileSync(dotGit, 'utf8'));
+                    if (!m)
+                        return null;
+                    gitDir = path.resolve(dir, m[1]);
+                }
+                const head = fs.readFileSync(path.join(gitDir, 'HEAD'), 'utf8').trim();
+                const ref = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
+                if (ref)
+                    return ref[1];
+                return /^[0-9a-f]{7,}$/i.test(head) ? head.slice(0, 7) : null;
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return null;
+            dir = parent;
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    return null;
+}
+//# sourceMappingURL=collect.js.map

package/dist/diff/diffView.d.ts

@@ -0,0 +1,57 @@
+export type DiffLineKind = 'file' | 'meta' | 'hunk' | 'add' | 'del' | 'ctx' | 'note';
+export interface DiffLine {
+    kind: DiffLineKind;
+    text: string;
+}
+export interface DiffHunk {
+    header: string;
+    /** Raw body lines, each starting with '+', '-', ' ' or '\' (no-newline marker). */
+    lines: string[];
+}
+export interface DiffFile {
+    path: string;
+    /** Previous path when the file was renamed. */
+    oldPath?: string;
+    status: 'modified' | 'added' | 'deleted' | 'renamed' | 'binary';
+    additions: number;
+    deletions: number;
+    hunks: DiffHunk[];
+}
+/** A hunk longer than this is folded in the overview (full view never folds hunks). */
+export declare const MAX_HUNK_LINES = 40;
+/** Body lines kept from a folded hunk. */
+export declare const FOLDED_HUNK_KEEP = 30;
+/** Total lines one rendering may emit before it points at `/diff <file>`. */
+export declare const MAX_VIEW_LINES = 400;
+/** Untracked files larger than this are listed, not inlined. */
+export declare const MAX_UNTRACKED_BYTES = 200000;
+/** Parse the output of `git diff` (unified, no colour) into files. */
+export declare function parseUnifiedDiff(text: string): DiffFile[];
+/** Synthesise the diff of an untracked (new) text file so `/diff` can show it too. */
+export declare function newFileDiff(path: string, content: string): DiffFile;
+export declare function totals(files: DiffFile[]): {
+    files: number;
+    additions: number;
+    deletions: number;
+};
+/**
+ * Find the file a user means by `/diff <name>`: exact path, then unique suffix
+ * ("chat.ts"), then unique substring. Returns the matches so the caller can say
+ * "ambiguous" instead of silently picking one.
+ */
+export declare function findFiles(files: DiffFile[], query: string): DiffFile[];
+/** One summary row per file: `  M  path   +12 −3`. */
+export declare function summaryLines(files: DiffFile[]): DiffLine[];
+export interface RenderOptions {
+    /** Fold hunks longer than MAX_HUNK_LINES (overview). The single-file view passes false. */
+    foldHunks?: boolean;
+    /** Cap on emitted lines; defaults to MAX_VIEW_LINES. */
+    maxLines?: number;
+}
+/** Display lines for one file: header, then each hunk, long ones folded when asked. */
+export declare function renderFile(f: DiffFile, opts?: RenderOptions): DiffLine[];
+/** Whole-tree view: every file rendered, capped overall so a big refactor doesn't flood. */
+export declare function renderAll(files: DiffFile[], opts?: RenderOptions): DiffLine[];
+/** Cap a single-file view; over the cap, tells the user how many lines were left out. */
+export declare function capLines(lines: DiffLine[], max?: number): DiffLine[];
+//# sourceMappingURL=diffView.d.ts.map

package/dist/diff/diffView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diffView.d.ts","sourceRoot":"","sources":["../../src/diff/diffView.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;AAErF,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,mFAAmF;IACnF,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,uFAAuF;AACvF,eAAO,MAAM,cAAc,KAAK,CAAC;AACjC,0CAA0C;AAC1C,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,6EAA6E;AAC7E,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,gEAAgE;AAChE,eAAO,MAAM,mBAAmB,SAAU,CAAC;AAE3C,sEAAsE;AACtE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,CAiEzD;AAED,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,QAAQ,CAYnE;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAMjG;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,EAAE,CAStE;AAUD,sDAAsD;AACtD,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,CAiB1D;AAED,MAAM,WAAW,aAAa;IAC5B,2FAA2F;IAC3F,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,GAAE,aAAkB,GAAG,QAAQ,EAAE,CA+B5E;AAED,4FAA4F;AAC5F,wBAAgB,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,IAAI,GAAE,aAAkB,GAAG,QAAQ,EAAE,CAoBjF;AAED,yFAAyF;AACzF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,GAAG,SAAqB,GAAG,QAAQ,EAAE,CAGhF"}