@redocly/recheck 0.15.0 → 2.58.1

package/dist/core/markdoc-tags.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdoc-tags.d.ts","sourceRoot":"","sources":["../../src/core/markdoc-tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAIpD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,0BAA0B;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,0BAA0B;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,cAAc,EAAE,CAoBlF;AAED,MAAM,WAAW,cAAc;IAC7B,2EAA2E;IAC3E,KAAK,EAAE,GAAG,EAAE,CAAC;IACb,4EAA4E;IAC5E,OAAO,EAAE,GAAG,EAAE,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,GAAG,EAAE,EACZ,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE,MAAM,GACd,cAAc,CAsDhB"}

package/dist/core/markdoc-tags.js

@@ -1,131 +0,0 @@
-import { filterByTypes } from '../parser/index.js';
-import { newLineRe } from './line-endings.js';
-/**
- * The character `scopes/extractor.ts` blanks a markdoc tag's span with when
- * building prose content. A SPACE, deliberately, and not
- * `core/inline-code.ts`'s `\0` sentinel:
- *
- * - Recheck's prose model must read a tag's span as a GAP, and the word
- *   tokenizers, `String.prototype.trim`, and the sentence splitter all agree on
- *   whitespace, so a space makes every one of them treat the tag as absent.
- * - A user-supplied regex must NOT read it as a gap, and no sentinel can give
- *   that: `\0` stops `\s+` from crossing a tag, but a negated class (`[^,]+`)
- *   walks straight through it either way. Regex rules therefore have to reject
- *   a match by RANGE, after the fact, against the unmodified text — see
- *   `ScopedSegment.maskedRanges` and `nonProseRanges` in `rules/utils.ts`.
- */
-export const MARKDOC_TAG_MASK_CHAR = ' ';
-/**
- * Every markdoc tag's source span in `content`, split per line (see
- * `MarkdocTagSpan`). Empty for a flag-off parse, since no `markdocTag` tokens
- * exist in the tree at all, so `--fix` behaves byte-identically.
- *
- * Uses `filterByTypes` rather than a raw `tree.flat.filter` so htmlFlow-reparsed
- * tokens are excluded on the same terms as for every other consumer: they
- * duplicate positions already covered by their `htmlFlow` parent, and treating a
- * duplicate as a protected span would block fixes on a line with no real tag.
- */
-export function markdocTagSpans(tree, content) {
-    const tags = filterByTypes(tree, ['markdocTag']);
-    if (tags.length === 0)
-        return [];
-    const sourceLines = content.split(newLineRe);
-    const spans = [];
-    for (const tag of tags) {
-        for (let line = tag.startLine; line <= tag.endLine; line++) {
-            const sourceLine = sourceLines[line - 1] ?? '';
-            const startColumn = line === tag.startLine ? tag.startColumn : 1;
-            const endColumn = line === tag.endLine ? tag.endColumn : sourceLine.length + 1;
-            if (endColumn <= startColumn)
-                continue;
-            spans.push({
-                line,
-                startColumn,
-                endColumn,
-                text: sourceLine.slice(startColumn - 1, endColumn - 1),
-            });
-        }
-    }
-    return spans;
-}
-/**
- * The choke point that keeps `--fix` from rewriting a markdoc tag's bytes.
- *
- * Prose scope content is masked (see `MARKDOC_TAG_MASK_CHAR`), which breaks the
- * precondition every whole-span rewriter relied on: `ScopedSegment.content` used
- * to be a verbatim source slice, so a rule replacing its whole span writes the
- * mask back over the real source and DELETES the tag. Rather than teach each such
- * rule to splice its own tags back, every fix from every rule passes through here
- * once, on its way to `applyFixesToContent`:
- *
- * - No tag on the fix's line, or no overlap with one: passes through untouched.
- *   This is the only path a flag-off run can take, so flag-off byte-identity is
- *   structural, not a special case.
- * - Overlap where the fix replaces its span with the SAME number of characters:
- *   each overlapped tag's original bytes are spliced back at their own offsets.
- *   Length preservation is what makes those offsets meaningful, and it is the
- *   same contract `restoreInlineCode` (core/inline-code.ts) already relies on.
- * - Anything else — a length-changing replacement, a fix that cuts a tag in half,
- *   a whole-line rewrite (`deleteCount: -1`) on a line with a tag — is DROPPED
- *   and reported as skipped, since there is no position to splice into without
- *   inventing one.
- *
- * A fix that turns out to change nothing once its tags are restored is dropped
- * too: it only matched mask characters, and letting it through would report a
- * byte-identical file as fixed and make `runRulesUntilStable` re-propose it on
- * every pass.
- */
-export function protectMarkdocTags(fixes, spans, content) {
-    if (spans.length === 0 || fixes.length === 0)
-        return { fixes, dropped: [] };
-    const byLine = new Map();
-    for (const span of spans) {
-        const existing = byLine.get(span.line);
-        if (existing)
-            existing.push(span);
-        else
-            byLine.set(span.line, [span]);
-    }
-    const sourceLines = content.split(newLineRe);
-    const safe = [];
-    const dropped = [];
-    for (const fix of fixes) {
-        const lineSpans = byLine.get(fix.lineNumber);
-        if (lineSpans === undefined) {
-            safe.push(fix);
-            continue;
-        }
-        const deleteCount = fix.deleteCount ?? 0;
-        if (deleteCount === -1) {
-            dropped.push(fix);
-            continue;
-        }
-        const editColumn = fix.editColumn ?? 1;
-        const editEnd = editColumn + deleteCount;
-        const overlapped = lineSpans.filter((span) => editColumn < span.endColumn && span.startColumn < editEnd);
-        if (overlapped.length === 0) {
-            safe.push(fix);
-            continue;
-        }
-        const insertText = fix.insertText ?? '';
-        const splittable = insertText.length === deleteCount &&
-            overlapped.every((span) => span.startColumn >= editColumn && span.endColumn <= editEnd);
-        if (!splittable) {
-            dropped.push(fix);
-            continue;
-        }
-        let restored = insertText;
-        for (const span of overlapped) {
-            const at = span.startColumn - editColumn;
-            restored = restored.slice(0, at) + span.text + restored.slice(at + span.text.length);
-        }
-        const replaced = (sourceLines[fix.lineNumber - 1] ?? '').slice(editColumn - 1, editEnd - 1);
-        if (restored === replaced) {
-            dropped.push(fix);
-            continue;
-        }
-        safe.push({ ...fix, insertText: restored });
-    }
-    return { fixes: safe, dropped };
-}
-//# sourceMappingURL=markdoc-tags.js.map

package/dist/core/markdoc-tags.js.map

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

package/dist/core/prose-extract.d.ts

@@ -1,6 +0,0 @@
-import type { ScopedSegment } from '../scopes/types.js';
-/** Strips markup that is never readable prose. Exported for direct unit testing. */
-export declare function stripNonProse(text: string): string;
-/** Builds the prose blocks a readability score reads, from `summary` segments. */
-export declare function extractProse(segments: ScopedSegment[]): string[];
-//# sourceMappingURL=prose-extract.d.ts.map

package/dist/core/prose-extract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prose-extract.d.ts","sourceRoot":"","sources":["../../src/core/prose-extract.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AASxD,oFAAoF;AACpF,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AA+DD,kFAAkF;AAClF,wBAAgB,YAAY,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,MAAM,EAAE,CAgBhE"}

package/dist/core/prose-extract.js

@@ -1,79 +0,0 @@
-import { BACKTICK_SPAN_RE } from './inline-code.js';
-// Markdoc tag-marker spans. Non-greedy, so back-to-back tags strip as
-// separate spans instead of one tag's opener swallowing the prose before
-// the next tag's closer. Only used when markdoc parsing is off; with it on,
-// tag spans arrive pre-masked in `segment.maskedRanges`.
-const MARKDOC_TAG_RE = /\{%-?[\s\S]*?-?%\}/g;
-/** Strips markup that is never readable prose. Exported for direct unit testing. */
-export function stripNonProse(text) {
-    return text.replace(MARKDOC_TAG_RE, '').replace(BACKTICK_SPAN_RE, '');
-}
-// Splices masked tag spans OUT of the content instead of reading through the
-// mask's spaces: a tag flush against text (`<code>{% x %}</code>`) must
-// count as one word, not two.
-function spliceOutMaskedSpans(segment) {
-    const ranges = segment.maskedRanges;
-    if (ranges === undefined)
-        return segment.content;
-    let result = '';
-    let cursor = 0;
-    for (const range of ranges) {
-        result += segment.content.slice(cursor, Math.max(range.start, cursor));
-        cursor = Math.max(range.end, cursor);
-    }
-    return result + segment.content.slice(cursor);
-}
-function comparePosition(aLine, aColumn, bLine, bColumn) {
-    return aLine - bLine || aColumn - bColumn;
-}
-function spanContains(outer, inner) {
-    return (comparePosition(outer.startLine, outer.startColumn, inner.startLine, inner.startColumn) <= 0 &&
-        comparePosition(outer.endLine, outer.endColumn, inner.endLine, inner.endColumn) >= 0);
-}
-// Drops segments whose source span is fully nested inside another kept
-// segment's span (a list inside a blockquote emits both), so nested words
-// are never scored twice. Sorted by start ascending with ties broken by
-// span DESCENDING, a container is always visited before anything inside it.
-// Block spans never partially overlap, so after popping ended containers,
-// the stack top is the only span a candidate can nest inside.
-function dedupeBySpanContainment(segments) {
-    const ordered = [...segments].sort((a, b) => {
-        const byStart = comparePosition(a.startLine, a.startColumn, b.startLine, b.startColumn);
-        if (byStart !== 0)
-            return byStart;
-        return comparePosition(b.endLine, b.endColumn, a.endLine, a.endColumn);
-    });
-    const stack = [];
-    const kept = [];
-    for (const segment of ordered) {
-        while (stack.length > 0) {
-            const top = stack[stack.length - 1];
-            if (comparePosition(top.endLine, top.endColumn, segment.startLine, segment.startColumn) < 0) {
-                stack.pop();
-            }
-            else {
-                break;
-            }
-        }
-        const container = stack[stack.length - 1];
-        if (container && spanContains(container, segment))
-            continue;
-        kept.push(segment);
-        stack.push(segment);
-    }
-    return kept;
-}
-/** Builds the prose blocks a readability score reads, from `summary` segments. */
-export function extractProse(segments) {
-    // Headings read as sentence fragments, so standard tools strip them.
-    const proseSegments = segments.filter((segment) => !segment.sourceScope?.startsWith('heading.'));
-    const deduped = dedupeBySpanContainment(proseSegments);
-    // Restore source order; the dedup sort breaks ties by span, not position.
-    deduped.sort((a, b) => a.startLine - b.startLine || a.startColumn - b.startColumn);
-    return deduped
-        .map((segment) => segment.maskedRanges !== undefined
-        ? spliceOutMaskedSpans(segment).replace(BACKTICK_SPAN_RE, '')
-        : stripNonProse(segment.content))
-        .filter((text) => text.trim() !== '');
-}
-//# sourceMappingURL=prose-extract.js.map

package/dist/core/prose-extract.js.map

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

package/dist/core/readability.d.ts

@@ -1,17 +0,0 @@
-export interface DocumentReadability {
-    words: number;
-    sentences: number;
-    /** Flesch reading ease; higher is easier. Null when there is no prose. */
-    fleschReadingEase: number | null;
-    /** Flesch-Kincaid grade level. Null when there is no prose. */
-    fleschKincaidGrade: number | null;
-    /**
-     * Automated Readability Index, a grade level from exact character counts --
-     * no syllable heuristic. Null when there is no prose.
-     */
-    automatedReadabilityIndex: number | null;
-}
-export declare function computeDocumentReadability(content: string, options?: {
-    markdoc?: boolean;
-}): DocumentReadability;
-//# sourceMappingURL=readability.d.ts.map

package/dist/core/readability.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"readability.d.ts","sourceRoot":"","sources":["../../src/core/readability.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,+DAA+D;IAC/D,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC;;;OAGG;IACH,yBAAyB,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1C;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,GAClC,mBAAmB,CAiCrB"}

package/dist/core/readability.js

@@ -1,37 +0,0 @@
-// Document-level readability. The `readability` command reports these
-// numbers and the `metric` assertion gates on them; both read the same
-// prose (core/prose-extract.ts) and formulas (metrics/).
-import { parseMarkdown } from '../parser/index.js';
-import { extractScopes } from '../scopes/extractor.js';
-import { extractProse } from './prose-extract.js';
-import { computeTextStatistics, computeReadability } from '../metrics/index.js';
-export function computeDocumentReadability(content, options = {}) {
-    const tree = parseMarkdown(content, { markdoc: options.markdoc ?? false });
-    const segments = extractScopes(tree, content).filter((segment) => segment.scope === 'summary');
-    const blocks = extractProse(segments);
-    // Per block and summed, so a block's end is an unconditional sentence end.
-    const stats = blocks.map(computeTextStatistics).reduce((sum, one) => ({
-        words: sum.words + one.words,
-        sentences: sum.sentences + one.sentences,
-        syllables: sum.syllables + one.syllables,
-        characters: sum.characters + one.characters,
-        complexWords: sum.complexWords + one.complexWords,
-    }), { words: 0, sentences: 0, syllables: 0, characters: 0, complexWords: 0 });
-    if (stats.words === 0 || stats.sentences === 0) {
-        return {
-            words: stats.words,
-            sentences: stats.sentences,
-            fleschReadingEase: null,
-            fleschKincaidGrade: null,
-            automatedReadabilityIndex: null,
-        };
-    }
-    return {
-        words: stats.words,
-        sentences: stats.sentences,
-        fleschReadingEase: computeReadability('flesch-reading-ease', stats),
-        fleschKincaidGrade: computeReadability('flesch-kincaid-grade', stats),
-        automatedReadabilityIndex: computeReadability('automated-readability', stats),
-    };
-}
-//# sourceMappingURL=readability.js.map

package/dist/core/readability.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"readability.js","sourceRoot":"","sources":["../../src/core/readability.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,uEAAuE;AACvE,yDAAyD;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAgBhF,MAAM,UAAU,0BAA0B,CACxC,OAAe,EACf,OAAO,GAA0B,EAAE;IAEnC,MAAM,IAAI,GAAG,aAAa,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,KAAK,EAAE,CAAC,CAAC;IAC3E,MAAM,QAAQ,GAAG,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC;IAC/F,MAAM,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;IAEtC,2EAA2E;IAC3E,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC,MAAM,CACpD,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;QACb,KAAK,EAAE,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK;QAC5B,SAAS,EAAE,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC,SAAS;QACxC,SAAS,EAAE,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC,SAAS;QACxC,UAAU,EAAE,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,UAAU;QAC3C,YAAY,EAAE,GAAG,CAAC,YAAY,GAAG,GAAG,CAAC,YAAY;KAClD,CAAC,EACF,EAAE,KAAK,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,CACzE,CAAC;IAEF,IAAI,KAAK,CAAC,KAAK,KAAK,CAAC,IAAI,KAAK,CAAC,SAAS,KAAK,CAAC,EAAE,CAAC;QAC/C,OAAO;YACL,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,iBAAiB,EAAE,IAAI;YACvB,kBAAkB,EAAE,IAAI;YACxB,yBAAyB,EAAE,IAAI;SAChC,CAAC;IACJ,CAAC;IACD,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,iBAAiB,EAAE,kBAAkB,CAAC,qBAAqB,EAAE,KAAK,CAAC;QACnE,kBAAkB,EAAE,kBAAkB,CAAC,sBAAsB,EAAE,KAAK,CAAC;QACrE,yBAAyB,EAAE,kBAAkB,CAAC,uBAAuB,EAAE,KAAK,CAAC;KAC9E,CAAC;AACJ,CAAC"}

package/dist/core/rule-filters.d.ts

@@ -1,45 +0,0 @@
-import type { NormalizedRule } from '../types/index.js';
-export interface FilterOptions {
-    severity?: 'off' | 'info' | 'warn' | 'warning' | 'error';
-    tags?: (string | number)[];
-    /** Run only these rules (see `matchesRuleName` for accepted spellings). */
-    rules?: string[];
-    /** Run everything except these rules. */
-    excludeRules?: string[];
-}
-export declare class UnknownRuleNameError extends Error {
-    readonly unknown: string[];
-    readonly available: string[];
-    constructor(unknown: string[], available: string[]);
-}
-/**
- * Restricts the run to the named rules. Unknown names throw rather than
- * silently narrowing to nothing: a typo'd `--rule` that reported "no issues"
- * would read exactly like a clean run.
- */
-export declare function filterByRuleNames(rules: NormalizedRule[], names: string[]): NormalizedRule[];
-/** Inverse of `filterByRuleNames`, with the same name matching and typo check. */
-export declare function excludeByRuleNames(rules: NormalizedRule[], names: string[]): NormalizedRule[];
-/**
- * Filter out disabled rules (severity: 'off')
- */
-export declare function filterEnabledRules(rules: NormalizedRule[]): {
-    enabled: NormalizedRule[];
-    disabledCount: number;
-};
-/**
- * Filter rules by minimum severity level
- */
-export declare function filterBySeverity(rules: NormalizedRule[], minSeverity: string): NormalizedRule[];
-/**
- * Filter rules by tags
- */
-export declare function filterByTags(rules: NormalizedRule[], tags: (string | number)[]): NormalizedRule[];
-/**
- * Apply all filters to rules
- */
-export declare function applyFilters(rules: NormalizedRule[], options: FilterOptions): {
-    filtered: NormalizedRule[];
-    disabledCount: number;
-};
-//# sourceMappingURL=rule-filters.d.ts.map

package/dist/core/rule-filters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rule-filters.d.ts","sourceRoot":"","sources":["../../src/core/rule-filters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IACzD,IAAI,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAC3B,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,yCAAyC;IACzC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAE3C,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE;IAF9B,YACW,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,MAAM,EAAE,EAI7B;CACF;AAkBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,CAU5F;AAED,kFAAkF;AAClF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,CAU7F;AAUD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG;IAC3D,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;CACvB,CAIA;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,cAAc,EAAE,CAS/F;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,cAAc,EAAE,CAIjG;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE,aAAa,GACrB;IACD,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;CACvB,CAyBA"}

package/dist/core/rule-filters.js

@@ -1,118 +0,0 @@
-export class UnknownRuleNameError extends Error {
-    constructor(unknown, available) {
-        super(`no rule in this configuration matches ${unknown.map((n) => `"${n}"`).join(', ')}`);
-        Object.defineProperty(this, "unknown", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: unknown
-        });
-        Object.defineProperty(this, "available", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: available
-        });
-        this.name = 'UnknownRuleNameError';
-    }
-}
-/**
- * A rule matches a `--rule`/`--exclude-rule` value when the value equals its
- * full config key (`recheck/us-spelling`) or its `shortName` -- the exact
- * string the report prints, so you can filter by what you just read.
- *
- * `shortName` removes only the `recheck/` prefix (see config/validate.ts), so
- * a rule from another namespace keeps that namespace: `google/passive-voice`
- * stays `google/passive-voice`. Do not match on the last path segment
- * instead. Preset rule keys share 20 bare names -- `no-trailing-punctuation`
- * exists in `recheck/`, `google/`, and `microsoft/` -- so one bare name would
- * select three different rules at once.
- */
-function matchesRuleName(rule, name) {
-    return rule.name === name || rule.shortName === name;
-}
-/**
- * Restricts the run to the named rules. Unknown names throw rather than
- * silently narrowing to nothing: a typo'd `--rule` that reported "no issues"
- * would read exactly like a clean run.
- */
-export function filterByRuleNames(rules, names) {
-    if (!names.length)
-        return rules;
-    const unknown = names.filter((name) => !rules.some((rule) => matchesRuleName(rule, name)));
-    if (unknown.length > 0) {
-        throw new UnknownRuleNameError(unknown, rules.map((rule) => rule.name));
-    }
-    return rules.filter((rule) => names.some((name) => matchesRuleName(rule, name)));
-}
-/** Inverse of `filterByRuleNames`, with the same name matching and typo check. */
-export function excludeByRuleNames(rules, names) {
-    if (!names.length)
-        return rules;
-    const unknown = names.filter((name) => !rules.some((rule) => matchesRuleName(rule, name)));
-    if (unknown.length > 0) {
-        throw new UnknownRuleNameError(unknown, rules.map((rule) => rule.name));
-    }
-    return rules.filter((rule) => !names.some((name) => matchesRuleName(rule, name)));
-}
-const SEVERITY_LEVELS = {
-    off: -1,
-    info: 0,
-    warn: 1,
-    warning: 1,
-    error: 2,
-};
-/**
- * Filter out disabled rules (severity: 'off')
- */
-export function filterEnabledRules(rules) {
-    const enabled = rules.filter((rule) => rule.severity !== 'off');
-    const disabledCount = rules.length - enabled.length;
-    return { enabled, disabledCount };
-}
-/**
- * Filter rules by minimum severity level
- */
-export function filterBySeverity(rules, minSeverity) {
-    const minLevel = SEVERITY_LEVELS[minSeverity];
-    if (minLevel === undefined)
-        return rules;
-    return rules.filter((rule) => {
-        const ruleSeverity = rule.severity === 'warning' ? 'warn' : rule.severity;
-        const ruleLevel = SEVERITY_LEVELS[ruleSeverity];
-        return ruleLevel >= minLevel;
-    });
-}
-/**
- * Filter rules by tags
- */
-export function filterByTags(rules, tags) {
-    if (!tags.length)
-        return rules;
-    return rules.filter((rule) => rule.tags?.some((tag) => tags.includes(tag)));
-}
-/**
- * Apply all filters to rules
- */
-export function applyFilters(rules, options) {
-    // Filter out disabled rules first
-    const { enabled, disabledCount } = filterEnabledRules(rules);
-    let filtered = enabled;
-    // Filter by severity if specified
-    if (options.severity) {
-        filtered = filterBySeverity(filtered, options.severity);
-    }
-    // Filter by tags if specified
-    if (options.tags?.length) {
-        filtered = filterByTags(filtered, options.tags);
-    }
-    // Name filters run last so they can narrow whatever the broader filters left.
-    if (options.rules?.length) {
-        filtered = filterByRuleNames(filtered, options.rules);
-    }
-    if (options.excludeRules?.length) {
-        filtered = excludeByRuleNames(filtered, options.excludeRules);
-    }
-    return { filtered, disabledCount };
-}
-//# sourceMappingURL=rule-filters.js.map

package/dist/core/rule-filters.js.map

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

package/dist/core/runner.d.ts

@@ -1,98 +0,0 @@
-import type { NormalizedRule, Problem, Fix } from '../types/index.js';
-import type { ScopeRuleContext } from '../rules/types.js';
-import { type MarkdocSchema } from '../parser/markdoc/schema.js';
-export interface RunnerOptions {
-    fix?: boolean;
-    /**
-     * Lint each input as embedded markdown rather than a whole document:
-     * a leading `---` parses as content instead of front matter, and
-     * EMBEDDED_UNSUPPORTED_RULES drop from the run, even when configured.
-     */
-    embedded?: boolean;
-    /**
-     * Cap on the total problems a run may collect, enforced BETWEEN files:
-     * once a file's lint pushes the total to (or past) the cap, that file's
-     * overflow is truncated and NO further file is linted at all — so a
-     * pathological input set can't ballon memory past cap + one file's worth
-     * of problems. Runs that hit the cap report `truncated: true` on their
-     * RunResult. Omit for unbounded collection (the default).
-     */
-    maxProblems?: number;
-    /**
-     * FULL set of configured rule names, used only to decide which inline
-     * directive names get an "unknown rule" warning (see core/directives.ts).
-     * Callers filter `severity: off` rules out of `rules` before runRules, so
-     * without this a directive suppressing an off-rule — a deliberate no-op,
-     * not a typo — would warn as unknown. Defaults to the names of `rules`
-     * (correct for callers that never pre-filter).
-     */
-    knownRuleNames?: Set<string>;
-    /**
-     * Opt-in Markdoc tokenization, passed through to every `parseMarkdown` call
-     * this run makes. Defaults to disabled, matching `parseMarkdown`'s own
-     * default, which leaves the parse byte-identical.
-     */
-    markdoc?: boolean;
-    /**
-     * The resolved schema used to derive `ctx.markdoc.pairing`'s self-closing
-     * set; only meaningful alongside `markdoc: true`. `null` or omitted means no
-     * schema: parsing and pairing still run, every rule reading
-     * `ctx.markdoc.schema` sees `null`, and no tag name counts as self-closing,
-     * so an unclosed one lands in `pairing.unclosed` rather than
-     * `voidMissingSlash`.
-     */
-    markdocSchema?: MarkdocSchema | null;
-}
-export interface FileInput {
-    path: string;
-    content: string;
-    metadata?: ScopeRuleContext['fileMetadata'];
-}
-export interface RunResult {
-    problems: Problem[];
-    fixedFiles: Map<string, string>;
-    /**
-     * Flat list of the fixes that GENUINELY landed in `fixedFiles`, for
-     * reporting. Proposed fixes dropped by the applier's overlap resolution
-     * are NOT here — they're in `skippedFixes` (see applyFixesToContent's
-     * applied/skipped classification).
-     */
-    fixes: Fix[];
-    /**
-     * Proposed fixes that could not be applied (overlapping edits,
-     * out-of-range lines). For runRulesUntilStable this holds only the fixes
-     * still pending after the final pass — a fix skipped in one pass but
-     * re-proposed and applied in a later pass is (correctly) reported in
-     * `fixes` instead.
-     */
-    skippedFixes: Fix[];
-    /**
-     * True when `RunnerOptions.maxProblems` cut the run short: problems were
-     * dropped past the cap and/or later files were never linted. Always false
-     * for uncapped runs, and for capped runs whose problem count never
-     * exceeded the cap with files left over.
-     */
-    truncated: boolean;
-}
-export declare function runRules(files: FileInput[], rules: NormalizedRule[], options?: RunnerOptions): Promise<RunResult>;
-/**
- * Runs rules with fix:true repeatedly (lint → apply fixes → re-lint the
- * fixed content) until a pass produces zero fixes, capped at
- * MAX_FIX_PASSES. runRules() itself is single-pass by design (library
- * callers that need convergence should loop, as this helper does). This is
- * what public API's lintFiles() and the CLI's run
- * command use so a single --fix invocation fully converges instead of
- * requiring the user to re-run --fix multiple times.
- *
- * The returned `problems` are from the FIRST pass (matching prior
- * single-pass behavior: --fix reports the issues it found/fixed, not the
- * post-fix state) while `fixedFiles` reflects the final, fully-converged
- * content. `fixes` is the flat list of every fix genuinely applied across
- * all passes; `skippedFixes` holds only the fixes still pending after the
- * final pass. A fix skipped mid-run (overlap) is normally re-proposed
- * against the fixed content and applied by a later pass — it then counts
- * in `fixes`, not `skippedFixes` — so a non-empty `skippedFixes` here
- * means the run hit MAX_FIX_PASSES with conflicting edits unresolved.
- */
-export declare function runRulesUntilStable(files: FileInput[], rules: NormalizedRule[], options?: Omit<RunnerOptions, 'fix'>): Promise<RunResult>;
-//# sourceMappingURL=runner.d.ts.map

package/dist/core/runner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/core/runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAEtE,OAAO,KAAK,EAAE,gBAAgB,EAAoB,MAAM,mBAAmB,CAAC;AAc5E,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAatF,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;CACtC;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,gBAAgB,CAAC,cAAc,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC;;;;;OAKG;IACH,KAAK,EAAE,GAAG,EAAE,CAAC;IACb;;;;;;OAMG;IACH,YAAY,EAAE,GAAG,EAAE,CAAC;IACpB;;;;;OAKG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AA0ED,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,SAAS,EAAE,EAClB,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,SAAS,CAAC,CAuQpB;AAOD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,SAAS,EAAE,EAClB,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,KAAK,CAAM,GACvC,OAAO,CAAC,SAAS,CAAC,CAuCpB"}