@refrakt-md/runes 0.36.0 → 0.38.0

package/dist/lib/languages.d.ts

@@ -0,0 +1,163 @@
+/**
+ * The per-language lexical table (SPEC-131 D15, WORK-597).
+ *
+ * This module is **data**. The state machine that reads it lives in
+ * `mask.ts`, and the split is deliberate — D15 draws the line between what is
+ * declarative (comment prefixes, string delimiters, `symbol=` keywords, token
+ * pairs, heading shapes, tab width) and what stays code (the masker, the depth
+ * counter, continuation lookahead, the balance self-check).
+ *
+ * **Why a table and not a union regex (D10).** The obvious shortcut is to walk
+ * `^\s*(//|#|\*|/\*)` across every language at once. In CSS that eats
+ * `#header { … }` as a comment, and a head that silently swallows a preceding
+ * rule is exactly the failure class SPEC-131 exists to remove. There are zero
+ * such lines in Lumina today, so this repository would never notice — but
+ * refrakt ships to projects whose files we have never seen.
+ *
+ * **A language absent from this table gets no guess.** No comment prefixes
+ * means no head absorption and nothing masked, rather than a plausible default
+ * that is wrong in a format nobody checked.
+ *
+ * **No config surface ships with this (D15).** `refrakt.config.json` gains no
+ * `languages` or `anchors` key in this milestone. What ships is the
+ * {@link mergeLanguages} seam, mirroring `mergeThemeConfig()`, so that
+ * declaring a language later is an additive change rather than a retrofit of a
+ * hard-coded table.
+ */
+/** A string delimiter and whether it may span a line break. */
+export interface StringDelimiter {
+    /** The opening and closing character(s) — the same on both ends. */
+    delim: string;
+    /** When false (the default) an unterminated string ends at the newline. */
+    multiline?: boolean;
+}
+/**
+ * A template delimiter — a string that can contain interpolated code.
+ *
+ * The interpolation tokens are table data rather than a hard-coded `${`,
+ * because the masker must not branch per language (D15).
+ */
+export interface TemplateDelimiter {
+    delim: string;
+    /** Token that re-enters code state, e.g. `'${'`. Omit for no interpolation. */
+    interpolationOpen?: string;
+    /** Token that returns to template state, e.g. `'}'`. */
+    interpolationClose?: string;
+}
+/**
+ * A paired token — WORK-588's `extent="paired"` reads these.
+ *
+ * Declared here now rather than later because retrofitting a hard-coded table
+ * is the expensive part, and the shape is what this module exists to get right.
+ */
+export interface TokenPair {
+    open: string;
+    close: string;
+    /**
+     * `asymmetric` — distinct open/close, nests (`{% tabs %}` / `{% /tabs %}`).
+     * `symmetric` — same token both ends, cannot nest, first recurrence closes
+     * (a ``` fence).
+     * `selfClosing` — no close at all (`{% snippet /%}`, `<img>`); a `paired`
+     * scan anchored on one returns a single line rather than running to EOF.
+     */
+    shape: 'asymmetric' | 'symmetric' | 'selfClosing';
+}
+/** A heading shape — WORK-588's `extent="section"` derives its terminator here. */
+export interface HeadingShape {
+    /**
+     * Matches a heading line. Capture group 1 must be the part whose **length**
+     * gives the nesting level (`###` → 3), so `section` can build a terminator
+     * for the anchor's own level without the author doing the arithmetic.
+     */
+    pattern: string;
+}
+/** Everything the lexical layer knows about one language. */
+export interface LanguageDefinition {
+    /** Line-comment prefixes. Empty means the language has none. */
+    lineComments: string[];
+    /** Block-comment open/close pairs. */
+    blockComments: Array<[open: string, close: string]>;
+    /** Quote delimiters. */
+    strings: StringDelimiter[];
+    /** Template delimiters, which may contain interpolated code. */
+    templates: TemplateDelimiter[];
+    /** Escape character inside strings and templates. */
+    escape?: string;
+    /**
+     * Annotation prefixes that attach to a declaration (`@Component`,
+     * `#[derive]`, `@dataclass`). WORK-587 attaches these to the symbol always,
+     * independently of `doc`.
+     */
+    annotations: string[];
+    /** `symbol=` declaration keywords. */
+    keywords: string[];
+    /** Declaration modifiers permitted before a keyword. */
+    modifiers: string[];
+    /** Heading shapes — WORK-588 (`extent="section"`). */
+    headings: HeadingShape[];
+    /** Token pairs — WORK-588 (`extent="paired"`). */
+    tokenPairs: TokenPair[];
+    /**
+     * Block-fence markers (```` ``` ````, `~~~`).
+     *
+     * Declaring these switches the masker onto its **Markdown** pass, which is
+     * a separate budget line from the C-family state machine and not the same
+     * ~40 lines: on a docs site the fences frequently contain the very tokens
+     * being counted. `site/content/runes/tabs.md` has a `{% tab %}` in an
+     * inline code span, and the pages most worth quoting with `paired` are
+     * exactly the ones full of fenced examples of the tags.
+     *
+     * The fence *marker lines stay visible* and only the interior is blanked,
+     * so an author can still anchor on a fence and a symmetric `paired` scan
+     * can still find its close.
+     */
+    fences: string[];
+    /** Inline code-span delimiters. Blanked span and all. */
+    inlineCode: string[];
+    /** Columns a tab expands to — WORK-588 (`extent="dedent"`). */
+    tabWidth: number;
+    /**
+     * Whether the language belongs to D11's **balanced delimiters** family —
+     * the one `extent="auto"` is for, where a `;` or a matching `}` ends a
+     * construct.
+     *
+     * This is a lexical fact, not a strategy (D5): the engine still never
+     * guesses which extent to use. What it does is let `auto` refuse in a
+     * language where delimiter balance is meaningless, instead of returning a
+     * plausible wrong span. Python and YAML are indentation-structured, and
+     * Markdoc, Svelte and HTML are tag-paired — pointing `auto` at any of them
+     * is the silently-wrong case, so `auto` fails loudly there and the refusal
+     * names the strategy that does fit.
+     */
+    delimited: boolean;
+}
+/** A partial definition, as an override or a newly declared language. */
+export type LanguageDefinitionOverrides = Partial<LanguageDefinition>;
+/**
+ * The built-in table.
+ *
+ * Keys are the highlight-language identifiers `LANG_MAP` already produces, so
+ * extension → language identification is reused rather than duplicated.
+ */
+export declare const BASE_LANGUAGES: Readonly<Record<string, LanguageDefinition>>;
+/**
+ * Merge language overrides onto a base table, mirroring `mergeThemeConfig()`.
+ *
+ * A key with no base entry is a **newly declared language**, not an override,
+ * and is taken whole — so the seam supports both extension surfaces D15 names
+ * without either of them shipping a config key yet. A key that does exist is
+ * merged field by field, with a provided array replacing the base array rather
+ * than concatenating: a project narrowing a language's comment prefixes must
+ * be able to remove one, which a concatenating merge makes impossible.
+ */
+export declare function mergeLanguages(base: Readonly<Record<string, LanguageDefinition>>, overrides: Record<string, LanguageDefinitionOverrides>): Record<string, LanguageDefinition>;
+/**
+ * Look up the lexical definition for a file path or language identifier.
+ *
+ * Accepts what `inferLanguage` accepts (a path, an extension, or a bare
+ * extension) as well as a language id directly. Returns `undefined` for a
+ * language not in the table — the caller must treat that as "no lexical
+ * knowledge", never as a default.
+ */
+export declare function resolveLanguage(pathOrLang: string, table?: Readonly<Record<string, LanguageDefinition>>): LanguageDefinition | undefined;
+//# sourceMappingURL=languages.d.ts.map

package/dist/lib/languages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languages.d.ts","sourceRoot":"","sources":["../../src/lib/languages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,+DAA+D;AAC/D,MAAM,WAAW,eAAe;IAC/B,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,+EAA+E;IAC/E,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,wDAAwD;IACxD,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,KAAK,EAAE,YAAY,GAAG,WAAW,GAAG,aAAa,CAAC;CAClD;AAED,mFAAmF;AACnF,MAAM,WAAW,YAAY;IAC5B;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,6DAA6D;AAC7D,MAAM,WAAW,kBAAkB;IAClC,gEAAgE;IAChE,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,sCAAsC;IACtC,aAAa,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,wBAAwB;IACxB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,gEAAgE;IAChE,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,sCAAsC;IACtC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,wDAAwD;IACxD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,sDAAsD;IACtD,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,kDAAkD;IAClD,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;;;;;;;;OAaG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,yDAAyD;IACzD,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;;;;;;;OAYG;IACH,SAAS,EAAE,OAAO,CAAC;CACnB;AAED,yEAAyE;AACzE,MAAM,MAAM,2BAA2B,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAuBtE;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CA4QtE,CAAC;AAEH;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC7B,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,EAClD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,2BAA2B,CAAC,GACpD,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAgBpC;AAuBD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC9B,UAAU,EAAE,MAAM,EAClB,KAAK,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAkB,GAClE,kBAAkB,GAAG,SAAS,CAOhC"}

package/dist/lib/languages.js

@@ -0,0 +1,383 @@
+/**
+ * The per-language lexical table (SPEC-131 D15, WORK-597).
+ *
+ * This module is **data**. The state machine that reads it lives in
+ * `mask.ts`, and the split is deliberate — D15 draws the line between what is
+ * declarative (comment prefixes, string delimiters, `symbol=` keywords, token
+ * pairs, heading shapes, tab width) and what stays code (the masker, the depth
+ * counter, continuation lookahead, the balance self-check).
+ *
+ * **Why a table and not a union regex (D10).** The obvious shortcut is to walk
+ * `^\s*(//|#|\*|/\*)` across every language at once. In CSS that eats
+ * `#header { … }` as a comment, and a head that silently swallows a preceding
+ * rule is exactly the failure class SPEC-131 exists to remove. There are zero
+ * such lines in Lumina today, so this repository would never notice — but
+ * refrakt ships to projects whose files we have never seen.
+ *
+ * **A language absent from this table gets no guess.** No comment prefixes
+ * means no head absorption and nothing masked, rather than a plausible default
+ * that is wrong in a format nobody checked.
+ *
+ * **No config surface ships with this (D15).** `refrakt.config.json` gains no
+ * `languages` or `anchors` key in this milestone. What ships is the
+ * {@link mergeLanguages} seam, mirroring `mergeThemeConfig()`, so that
+ * declaring a language later is an additive change rather than a retrofit of a
+ * hard-coded table.
+ */
+import { inferLanguage } from '../lang-map.js';
+/**
+ * The C-family lexical core, for the languages that agree on it.
+ *
+ * A function rather than a shared object so each language gets its own arrays:
+ * four definitions pointing at one `blockComments` array is a footgun waiting
+ * for the first consumer that mutates what it was handed.
+ */
+function cFamily() {
+    return {
+        lineComments: ['//'],
+        blockComments: [['/*', '*/']],
+        strings: [{ delim: '"' }, { delim: "'" }],
+        escape: '\\',
+        tabWidth: 4,
+        delimited: true,
+    };
+}
+/**
+ * The built-in table.
+ *
+ * Keys are the highlight-language identifiers `LANG_MAP` already produces, so
+ * extension → language identification is reused rather than duplicated.
+ */
+export const BASE_LANGUAGES = Object.freeze({
+    typescript: {
+        ...cFamily(),
+        templates: [{ delim: '`', interpolationOpen: '${', interpolationClose: '}' }],
+        annotations: ['@'],
+        keywords: [
+            'interface',
+            'type',
+            'class',
+            'const',
+            'let',
+            'var',
+            'function',
+            'enum',
+            'namespace',
+        ],
+        modifiers: [
+            'export',
+            'default',
+            'declare',
+            'async',
+            'abstract',
+            'static',
+            'public',
+            'private',
+            'protected',
+            'readonly',
+        ],
+        headings: [],
+        tokenPairs: [],
+        fences: [],
+        inlineCode: [],
+    },
+    javascript: {
+        ...cFamily(),
+        templates: [{ delim: '`', interpolationOpen: '${', interpolationClose: '}' }],
+        annotations: ['@'],
+        keywords: ['class', 'const', 'let', 'var', 'function'],
+        modifiers: ['export', 'default', 'async', 'static'],
+        headings: [],
+        tokenPairs: [],
+        fences: [],
+        inlineCode: [],
+    },
+    json: {
+        // JSON has no comments. Giving it `//` would blank a URL inside a string
+        // value on any file that reached the masker before the string rule.
+        lineComments: [],
+        blockComments: [],
+        strings: [{ delim: '"' }],
+        templates: [],
+        escape: '\\',
+        annotations: [],
+        keywords: [],
+        modifiers: [],
+        headings: [],
+        tokenPairs: [],
+        fences: [],
+        inlineCode: [],
+        tabWidth: 2,
+        delimited: true,
+    },
+    jsonc: {
+        lineComments: ['//'],
+        blockComments: [['/*', '*/']],
+        strings: [{ delim: '"' }],
+        templates: [],
+        escape: '\\',
+        annotations: [],
+        keywords: [],
+        modifiers: [],
+        headings: [],
+        tokenPairs: [],
+        fences: [],
+        inlineCode: [],
+        tabWidth: 2,
+        delimited: true,
+    },
+    css: {
+        // D10's hazard lives here: CSS has **no** line comment. `#header { … }`
+        // is an id selector, and a `#` prefix would swallow the rule above any
+        // anchor that followed it.
+        lineComments: [],
+        blockComments: [['/*', '*/']],
+        strings: [{ delim: '"' }, { delim: "'" }],
+        templates: [],
+        escape: '\\',
+        // CSS at-rules are **not** annotations. `@media` and `@layer` open a
+        // block; absorbing one as a head would pull an enclosing wrapper into
+        // the slice, which is the opposite of what a head is for.
+        annotations: [],
+        keywords: [],
+        modifiers: [],
+        headings: [],
+        tokenPairs: [],
+        fences: [],
+        inlineCode: [],
+        tabWidth: 2,
+        delimited: true,
+    },
+    python: {
+        lineComments: ['#'],
+        blockComments: [],
+        strings: [
+            { delim: '"""', multiline: true },
+            { delim: "'''", multiline: true },
+            { delim: '"' },
+            { delim: "'" },
+        ],
+        templates: [],
+        escape: '\\',
+        annotations: ['@'],
+        keywords: ['def', 'class'],
+        modifiers: ['async'],
+        headings: [],
+        tokenPairs: [],
+        fences: [],
+        inlineCode: [],
+        tabWidth: 4,
+        delimited: false,
+    },
+    rust: {
+        ...cFamily(),
+        templates: [],
+        annotations: ['#['],
+        keywords: ['struct', 'impl', 'fn', 'trait', 'enum', 'type', 'const', 'mod'],
+        modifiers: ['pub', 'async', 'unsafe', 'default'],
+        headings: [],
+        tokenPairs: [],
+        fences: [],
+        inlineCode: [],
+    },
+    go: {
+        ...cFamily(),
+        strings: [{ delim: '"' }, { delim: "'" }],
+        templates: [{ delim: '`' }],
+        annotations: [],
+        keywords: ['func', 'type', 'var', 'const'],
+        modifiers: [],
+        headings: [],
+        tokenPairs: [],
+        fences: [],
+        inlineCode: [],
+        tabWidth: 8,
+    },
+    yaml: {
+        lineComments: ['#'],
+        blockComments: [],
+        strings: [{ delim: '"' }, { delim: "'" }],
+        templates: [],
+        escape: '\\',
+        annotations: [],
+        keywords: [],
+        modifiers: [],
+        headings: [],
+        tokenPairs: [],
+        fences: [],
+        inlineCode: [],
+        tabWidth: 2,
+        delimited: false,
+    },
+    toml: {
+        lineComments: ['#'],
+        blockComments: [],
+        strings: [{ delim: '"' }, { delim: "'" }],
+        templates: [],
+        escape: '\\',
+        annotations: [],
+        keywords: [],
+        modifiers: [],
+        // A TOML table header is sibling-terminated; every table is level 1, so
+        // the capture is the bracket itself.
+        headings: [{ pattern: '^(\\[)[^\\[\\]]+\\]\\s*$' }],
+        tokenPairs: [],
+        fences: [],
+        inlineCode: [],
+        tabWidth: 2,
+        delimited: false,
+    },
+    bash: {
+        lineComments: ['#'],
+        blockComments: [],
+        strings: [{ delim: '"' }, { delim: "'" }],
+        templates: [],
+        escape: '\\',
+        annotations: [],
+        keywords: ['function'],
+        modifiers: [],
+        headings: [],
+        tokenPairs: [],
+        fences: [],
+        inlineCode: [],
+        tabWidth: 4,
+        delimited: true,
+    },
+    html: {
+        lineComments: [],
+        blockComments: [['<!--', '-->']],
+        strings: [{ delim: '"' }, { delim: "'" }],
+        templates: [],
+        annotations: [],
+        keywords: [],
+        modifiers: [],
+        headings: [],
+        tokenPairs: [
+            { open: '<', close: '</', shape: 'asymmetric' },
+            { open: '<img', close: '', shape: 'selfClosing' },
+            { open: '<br', close: '', shape: 'selfClosing' },
+        ],
+        fences: [],
+        inlineCode: [],
+        tabWidth: 2,
+        delimited: false,
+    },
+    markdoc: {
+        // Markdown's masker is recursive — fenced blocks and inline code spans
+        // that frequently contain the very tokens being counted. SPEC-131 is
+        // explicit that this is "not the same ~40 lines" as the C family, so it
+        // is WORK-588's, alongside the strategies that need it. The shapes
+        // below are declared now; nothing masks them yet.
+        lineComments: [],
+        blockComments: [['<!--', '-->']],
+        strings: [],
+        templates: [],
+        annotations: [],
+        keywords: [],
+        modifiers: [],
+        headings: [{ pattern: '^(#{1,6})\\s+\\S' }],
+        tokenPairs: [
+            { open: '{%', close: '{% /', shape: 'asymmetric' },
+            { open: '```', close: '```', shape: 'symmetric' },
+            { open: '{%', close: '/%}', shape: 'selfClosing' },
+        ],
+        fences: ['```', '~~~'],
+        inlineCode: ['`'],
+        tabWidth: 2,
+        delimited: false,
+    },
+    svelte: {
+        lineComments: [],
+        blockComments: [['<!--', '-->']],
+        strings: [{ delim: '"' }, { delim: "'" }],
+        templates: [],
+        annotations: [],
+        keywords: [],
+        modifiers: [],
+        headings: [],
+        tokenPairs: [{ open: '<', close: '</', shape: 'asymmetric' }],
+        fences: [],
+        inlineCode: [],
+        tabWidth: 2,
+        delimited: false,
+    },
+    vue: {
+        lineComments: [],
+        blockComments: [['<!--', '-->']],
+        strings: [{ delim: '"' }, { delim: "'" }],
+        templates: [],
+        annotations: [],
+        keywords: [],
+        modifiers: [],
+        headings: [],
+        tokenPairs: [{ open: '<', close: '</', shape: 'asymmetric' }],
+        fences: [],
+        inlineCode: [],
+        tabWidth: 2,
+        delimited: false,
+    },
+});
+/**
+ * Merge language overrides onto a base table, mirroring `mergeThemeConfig()`.
+ *
+ * A key with no base entry is a **newly declared language**, not an override,
+ * and is taken whole — so the seam supports both extension surfaces D15 names
+ * without either of them shipping a config key yet. A key that does exist is
+ * merged field by field, with a provided array replacing the base array rather
+ * than concatenating: a project narrowing a language's comment prefixes must
+ * be able to remove one, which a concatenating merge makes impossible.
+ */
+export function mergeLanguages(base, overrides) {
+    const merged = { ...base };
+    for (const [name, override] of Object.entries(overrides)) {
+        const existing = merged[name];
+        if (!existing) {
+            merged[name] = normalizeDefinition(override);
+            continue;
+        }
+        merged[name] = {
+            ...existing,
+            ...override,
+        };
+    }
+    return merged;
+}
+/** Fill a partial definition out to a complete one — an undeclared field is
+ *  empty rather than inherited from an unrelated language. */
+function normalizeDefinition(partial) {
+    return {
+        lineComments: partial.lineComments ?? [],
+        blockComments: partial.blockComments ?? [],
+        strings: partial.strings ?? [],
+        templates: partial.templates ?? [],
+        escape: partial.escape,
+        annotations: partial.annotations ?? [],
+        keywords: partial.keywords ?? [],
+        modifiers: partial.modifiers ?? [],
+        headings: partial.headings ?? [],
+        tokenPairs: partial.tokenPairs ?? [],
+        fences: partial.fences ?? [],
+        inlineCode: partial.inlineCode ?? [],
+        tabWidth: partial.tabWidth ?? 4,
+        delimited: partial.delimited ?? false,
+    };
+}
+/**
+ * Look up the lexical definition for a file path or language identifier.
+ *
+ * Accepts what `inferLanguage` accepts (a path, an extension, or a bare
+ * extension) as well as a language id directly. Returns `undefined` for a
+ * language not in the table — the caller must treat that as "no lexical
+ * knowledge", never as a default.
+ */
+export function resolveLanguage(pathOrLang, table = BASE_LANGUAGES) {
+    if (typeof pathOrLang !== 'string' || pathOrLang.length === 0)
+        return undefined;
+    // A language id wins over extension inference, so `resolveLanguage('css')`
+    // works without dressing it up as a filename.
+    const direct = table[pathOrLang.toLowerCase()];
+    if (direct)
+        return direct;
+    return table[inferLanguage(pathOrLang)];
+}
+//# sourceMappingURL=languages.js.map

package/dist/lib/languages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"languages.js","sourceRoot":"","sources":["../../src/lib/languages.ts"],"names":[],"mappings":"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"}

package/dist/lib/line-diff.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Line-level LCS diff.
+ *
+ * Extracted from `tags/diff.ts` (WORK-592), where it was module-local, so that
+ * both the `diff` rune and the `snippet review` terminal renderer read one
+ * implementation. A pure move: the algorithm is unchanged.
+ */
+export interface DiffHunk {
+    type: 'equal' | 'add' | 'remove';
+    text: string;
+}
+/**
+ * Compute a line-level diff using LCS (Longest Common Subsequence).
+ *
+ * Returns hunks with type and raw text. Presentation — highlighting, gutters,
+ * terminal colour — is the caller's.
+ */
+export declare function computeLineDiff(before: string, after: string): DiffHunk[];
+/**
+ * A one-line summary of what changed between two slices.
+ *
+ * D7's example reads "+2 fields, 1 removed", which requires *interpreting* the
+ * diff rather than reporting it. The spec left the granularity open; this is
+ * the settled answer, and the reasoning is recorded because it was a real
+ * choice:
+ *
+ * Counting added and removed lines is cheap and honest. Naming *fields* would
+ * mean parsing the slice, which needs a language-aware layer this feature does
+ * not have and SPEC-131 D1 deliberately declined to build. A count that says
+ * "3 added, 1 removed" tells an author how much to expect; a count that claimed
+ * "2 fields" while actually counting lines would be worse than the cheap
+ * version, because it would sound authoritative.
+ */
+export declare function summarizeDiff(before: string, after: string): string;
+//# sourceMappingURL=line-diff.d.ts.map

package/dist/lib/line-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-diff.d.ts","sourceRoot":"","sources":["../../src/lib/line-diff.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,QAAQ;IACxB,IAAI,EAAE,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;CACb;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,QAAQ,EAAE,CAoCzE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAUnE"}