@redocly/recheck 0.15.0 → 2.58.0

package/dist/core/files.js

@@ -1,260 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import picomatch from 'picomatch';
-import { parseMarkdown } from '../parser/index.js';
-import { getImageDestinations } from '../rules/token/helpers.js';
-const SKIP_DIRS = ['node_modules', 'dist', 'build'];
-export async function discoverMarkdownFiles(inputPath) {
-    async function walkDir(dir) {
-        const files = [];
-        try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    if (entry.name.startsWith('.') || SKIP_DIRS.includes(entry.name)) {
-                        continue;
-                    }
-                    files.push(...(await walkDir(fullPath)));
-                }
-                else if (entry.isFile() &&
-                    picomatch.isMatch(entry.name, '*.{md,markdown}', { nocase: true })) {
-                    files.push(fullPath);
-                }
-            }
-        }
-        catch {
-            return [];
-        }
-        return files;
-    }
-    const stat = await fs.stat(inputPath);
-    if (stat.isFile()) {
-        return [inputPath];
-    }
-    else if (stat.isDirectory()) {
-        return walkDir(inputPath);
-    }
-    else {
-        return [];
-    }
-}
-/**
- * Load list of changed files from either a file path or stdin
- */
-export async function loadChangedFiles(changedListPath) {
-    // 1) Prefer explicit file path
-    if (changedListPath && changedListPath.length > 0) {
-        try {
-            const content = await fs.readFile(changedListPath, 'utf8');
-            return content
-                .split(/\r?\n/)
-                .map((s) => s.trim())
-                .filter(Boolean);
-        }
-        catch (_err) {
-            return [];
-        }
-    }
-    // 2) Otherwise try to read from stdin if piped
-    if (process.stdin.isTTY)
-        return [];
-    const chunks = [];
-    return await new Promise((resolve) => {
-        process.stdin.setEncoding('utf8');
-        process.stdin.on('data', (d) => chunks.push(String(d)));
-        process.stdin.on('end', () => {
-            const text = chunks.join('');
-            const lines = text
-                .split(/\r?\n/)
-                .map((s) => s.trim())
-                .filter(Boolean);
-            resolve(lines);
-        });
-        process.stdin.resume();
-    });
-}
-/**
- * Runs `fn` over `items` with at most `limit` calls in flight at once,
- * returning results in the same order as `items` regardless of completion
- * order. Used to bound concurrency for disk I/O (e.g. lintFiles' reads)
- * without pulling in a workspace dependency — recheck is published
- * independently, so it can't depend on @redocly/shared's promiseMapLimit.
- */
-export async function mapLimit(items, limit, fn) {
-    const results = new Array(items.length);
-    let next = 0;
-    async function worker() {
-        while (next < items.length) {
-            const index = next++;
-            results[index] = await fn(items[index], index);
-        }
-    }
-    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
-    return results;
-}
-/**
- * Whether any of the given rules use the max-image-size assertion, which
- * requires loading image metadata (file size, existence) from disk.
- */
-export function needsImageMetadata(rules) {
-    return rules.some((rule) => Object.keys(rule.assertions).includes('max-image-size'));
-}
-/**
- * Extracts every local (non-`http(s)://`) image destination referenced in
- * `content` — both inline (`![alt](path "title")`) and reference-style
- * (`![alt][ref]`, `![alt][]`, `![alt]`) syntax — via `getImageDestinations`
- * (rules/token/helpers.ts), the SAME AST-based extraction
- * `rules/scope/max-image-size.ts` uses to look images up in
- * `ScopeRuleContext.fileMetadata.images`. Sharing one extraction pass is
- * load-bearing, not just tidy: the strings returned here become the exact
- * Map keys `loadImageMetadata` below stores on-disk stats under, and
- * max-image-size looks metadata up by the identical destination string it
- * resolves from the same tree shape — a second, independently-written
- * extraction (even an AST-based one) could subtly disagree on edge cases
- * (e.g. angle-bracket literal destinations, reference normalization) and
- * silently break that lookup.
- *
- * Parses `content` itself rather than accepting a pre-built tree: neither
- * of this function's current callers (`lintFiles` in src/index.ts,
- * `runCommand` in src/commands/run.ts) has already parsed the file at the
- * point they call this — both read raw file content and call this
- * immediately after, before the runner's own `parseMarkdown` pass — so
- * there is no cheap existing tree to thread through. This parse only runs
- * at all when `needsImageMetadata` finds `max-image-size` configured (see
- * below), bounding the extra cost to that case.
- *
- * Deliberately parsed without `{ markdoc: true }`, even when the caller's
- * config has the flag on. `getImageDestinations` only reads `image` tokens
- * (from `![alt](dest)`/`![alt][ref]`) and link-reference definitions, and the
- * Markdoc syntax extension hooks only on `{`, so it cannot affect where
- * `!`/`[`/`]`/`(` constructs start, end, or resolve. The set of destinations is
- * the same either way, and threading the flag through would add a parameter
- * here and to two public signatures to preserve something already true by
- * construction.
- */
-function extractImageReferences(content) {
-    return getImageDestinations(parseMarkdown(content))
-        .map(({ destination }) => destination)
-        .filter((destination) => !destination.startsWith('http://') && !destination.startsWith('https://'));
-}
-/**
- * Cap on unique image refs processed per file by `loadImageMetadata`. Each
- * ref costs an `fs.stat`, so without a bound a pathological file (hundreds
- * of thousands of image refs) turns one lint into an unbounded stat storm.
- * 1,000 is far above any real document's image count. Refs beyond the cap
- * are OMITTED from the metadata map entirely — see the doc comment below
- * for why omission (not a fabricated `exists: false`) is the honest shape.
- */
-export const MAX_IMAGE_REFS_PER_FILE = 1000;
-/** Whether `resolved` (an absolute path) is `root` itself or inside it. */
-function isInsideRoot(root, resolved) {
-    const relative = path.relative(root, resolved);
-    return (relative === '' ||
-        (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)));
-}
-/**
- * Loads on-disk metadata (size, existence) for images referenced in a markdown
- * file's content, keyed by the image path as written in the source.
- *
- * Refs are confined to `root` (default: `process.cwd()`): a ref whose
- * resolved path escapes the root — `../` traversal above it, or an absolute
- * path like `/etc/passwd` — is recorded as `exists: false` WITHOUT being
- * stat'ed, so a hostile document can't use the linter to probe existence or
- * size of arbitrary files (both would otherwise leak into lint output).
- * Site-absolute doc refs like `/images/foo.png` land in the same bucket,
- * which matches the previous behavior for them observably: they used to be
- * stat'ed against the FILESYSTEM root, fail, and come back `exists: false`
- * anyway. Callers linting files outside their cwd should pass the lint root
- * explicitly (`lintFiles` threads its `root` option here).
- *
- * Confinement is physical, not just lexical: after the string-level check,
- * each surviving ref is `fs.realpath`'d and its REAL path must sit inside
- * the REAL root (the root's own realpath, resolved once per call). Without
- * this, a symlink planted INSIDE the root (`root/docs/evil.png ->
- * /etc/passwd`, or a symlinked directory escaping the root) passes the
- * lexical check and `fs.stat` follows it, leaking the target's existence
- * and size. Symlinks that RESOLVE inside the root keep working — legit repo
- * layouts symlink shared asset dirs around within the checkout. When
- * `realpath` throws (ENOENT for a missing file or dangling link — the
- * common case — or any other resolution failure), the ref falls through to
- * the same `fs.stat` try/catch as before: `stat` performs the identical
- * full path resolution, so it fails the same way and the ref reads
- * `exists: false` exactly as missing files always have. Cost: one extra
- * realpath per stat'ed image, only on the max-image-size code path.
- *
- * At most `MAX_IMAGE_REFS_PER_FILE` unique refs are processed; overflow refs
- * are omitted from the map rather than recorded. An absent key means "no
- * metadata loaded" to consumers — `max-image-size` skips refs it finds no
- * entry for, exactly as it skips `exists: false` entries — so omission never
- * fabricates a "this image is missing" fact for a ref that was simply never
- * checked. Duplicate refs share one entry (and one stat) and don't consume
- * extra cap slots.
- */
-export async function loadImageMetadata(file, content, root = process.cwd()) {
-    const images = new Map();
-    const baseDir = path.dirname(file);
-    const resolvedRoot = path.resolve(root);
-    const imageReferences = extractImageReferences(content);
-    // The root's physical identity, resolved once per call (not per ref).
-    // `undefined` when the root itself can't be resolved (e.g. doesn't
-    // exist) — nothing lexically inside a nonexistent root can stat
-    // successfully anyway, so the per-ref physical check is skipped and the
-    // stat below reports `exists: false` on its own.
-    let realRoot;
-    try {
-        realRoot = await fs.realpath(resolvedRoot);
-    }
-    catch {
-        realRoot = undefined;
-    }
-    for (const imagePath of imageReferences) {
-        if (images.has(imagePath)) {
-            continue;
-        }
-        if (images.size >= MAX_IMAGE_REFS_PER_FILE) {
-            break;
-        }
-        const fullPath = path.resolve(baseDir, imagePath);
-        if (!isInsideRoot(resolvedRoot, fullPath)) {
-            images.set(imagePath, { path: imagePath, size: 0, exists: false });
-            continue;
-        }
-        // Physical confinement: a symlink inside the root must also RESOLVE
-        // inside the (real) root, or stat would follow it out and leak the
-        // target's existence/size. A realpath failure (ENOENT for missing
-        // files and dangling links, or any other resolution error) falls
-        // through: `fs.stat` resolves the same path the same way, fails
-        // identically, and lands in the `exists: false` branch below —
-        // missing files keep their exact pre-existing behavior.
-        if (realRoot !== undefined) {
-            try {
-                const realPath = await fs.realpath(fullPath);
-                if (!isInsideRoot(realRoot, realPath)) {
-                    images.set(imagePath, { path: imagePath, size: 0, exists: false });
-                    continue;
-                }
-            }
-            catch {
-                // Fall through to the stat below.
-            }
-        }
-        try {
-            const stats = await fs.stat(fullPath);
-            images.set(imagePath, {
-                path: imagePath,
-                size: stats.size,
-                exists: true,
-            });
-        }
-        catch {
-            images.set(imagePath, {
-                path: imagePath,
-                size: 0,
-                exists: false,
-            });
-        }
-    }
-    return images.size > 0 ? { images } : undefined;
-}
-//# sourceMappingURL=files.js.map

package/dist/core/files.js.map

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

package/dist/core/inline-code.d.ts

@@ -1,87 +0,0 @@
-/**
- * Matches one CommonMark inline code span: a backtick RUN of N backticks,
- * then content up to the NEXT run of exactly N backticks -- not merely "a
- * backtick ... a backtick" (a single-backtick-only regex treats a
- * multi-backtick span like ` ``configFile`` ` as two adjacent EMPTY
- * single-backtick pairs -- the two backticks at each end each look like
- * their own complete single-backtick pair -- leaving the real content
- * completely unrecognized in between). `(`+)` + backreference `\1`
- * requires the closing run to match the opening run's exact length;
- * `(?!`)` after `\1` rejects a run that is actually LONGER than N (e.g. a
- * stray extra backtick right after would mean this is not the true,
- * maximal closing run) -- this also correctly handles a span whose content
- * itself contains a SHORTER, unpaired backtick run (` ``code ` x`` `).
- * Content is restricted to `[^\n]` so a span can never cross a line;
- * callers only ever run this against single-line text.
- *
- * Shared by capitalization.ts (mask + restore, so `$`-style casing never
- * touches a code span's content), spelling.ts (mask, so a misspelling
- * check never flags identifier text), and metric.ts (strip, so readability
- * scoring never counts a code span's words/syllables) -- all three need
- * the identical CommonMark-correct span recognition, just applied
- * differently (mask-and-restore vs outright removal).
- */
-export declare const BACKTICK_SPAN_RE: RegExp;
-/**
- * Placeholder character `maskInlineCode` masks spans with. \0 sits outside
- * every word tokenizer in the codebase (title-case.ts's WORD_RE,
- * capitalization.ts's sentence tokenizer, spelling.ts's word regex), so a
- * masked span is invisible to word-based scanning -- never matched, never
- * capitalized, never the first/last word.
- */
-export declare const INLINE_CODE_MASK_CHAR = "\0";
-/**
- * Masks every inline code span in `text` with a SAME-LENGTH run of
- * INLINE_CODE_MASK_CHAR. Length-preserving on purpose: every remaining
- * token's offset stays aligned with the original text, so match positions
- * computed against the masked string are valid source positions -- and
- * `restoreInlineCode` can splice the original spans back purely by
- * position.
- */
-export declare function maskInlineCode(text: string): string;
-/**
- * Restores the inline code spans of `original` into `transformed`, a string
- * derived from `maskInlineCode(original)` by length-preserving transforms
- * only (e.g. case changes). Splices by position, not content search: the
- * span offsets found in `original` are still the span offsets in
- * `transformed` because masking and the intervening transforms never change
- * string length.
- */
-export declare function restoreInlineCode(original: string, transformed: string): string;
-/**
- * The half-open character ranges `[start, end)` of every inline code span
- * in `text`, using the same `BACKTICK_SPAN_RE` span recognition as
- * `maskInlineCode`/`restoreInlineCode` -- span recognition stays in exactly
- * one place.
- *
- * For rules that must REJECT a match inside code rather than rewrite text
- * (swap.ts, pattern.ts): those rules run an arbitrary user-supplied regex
- * (a `pattern` token, a `swap` key under `keysAreRegex`), and masking can
- * change what that regex matches. `maskInlineCode` substitutes a
- * same-length run of `\0` for a span's real characters -- and `\0` is not
- * whitespace, not a comma, not anything in particular. A negated class
- * like `[^\s,]+` treats that run as ordinary "not comma, not whitespace"
- * text and can match straight through it, merging text before and after
- * the span -- including whatever character (e.g. a comma) the class
- * exists to react to -- into one bogus match. A range check has no such
- * failure mode: the regex still runs against the genuine, unmodified text,
- * and a match is discarded only AFTER the fact, if its span overlaps a
- * code span. Use `inlineCodeRanges` + `overlapsAnyRange` for that; keep
- * `maskInlineCode` for rules that transform text in place and need a
- * length-preserving stand-in (capitalization.ts, spelling.ts).
- */
-export declare function inlineCodeRanges(text: string): Array<{
-    start: number;
-    end: number;
-}>;
-/**
- * Whether the half-open range `[start, end)` overlaps ANY of `ranges`.
- * Half-open, exclusive-end comparison on both sides: a match that only
- * touches a range's boundary -- ends exactly where the range starts, or
- * starts exactly where the range ends -- does NOT overlap.
- */
-export declare function overlapsAnyRange(start: number, end: number, ranges: Array<{
-    start: number;
-    end: number;
-}>): boolean;
-//# sourceMappingURL=inline-code.d.ts.map

package/dist/core/inline-code.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inline-code.d.ts","sourceRoot":"","sources":["../../src/core/inline-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,gBAAgB,QAAwB,CAAC;AAEtD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAY/E;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAOpF;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GAC5C,OAAO,CAET"}

package/dist/core/inline-code.js

@@ -1,104 +0,0 @@
-/**
- * Matches one CommonMark inline code span: a backtick RUN of N backticks,
- * then content up to the NEXT run of exactly N backticks -- not merely "a
- * backtick ... a backtick" (a single-backtick-only regex treats a
- * multi-backtick span like ` ``configFile`` ` as two adjacent EMPTY
- * single-backtick pairs -- the two backticks at each end each look like
- * their own complete single-backtick pair -- leaving the real content
- * completely unrecognized in between). `(`+)` + backreference `\1`
- * requires the closing run to match the opening run's exact length;
- * `(?!`)` after `\1` rejects a run that is actually LONGER than N (e.g. a
- * stray extra backtick right after would mean this is not the true,
- * maximal closing run) -- this also correctly handles a span whose content
- * itself contains a SHORTER, unpaired backtick run (` ``code ` x`` `).
- * Content is restricted to `[^\n]` so a span can never cross a line;
- * callers only ever run this against single-line text.
- *
- * Shared by capitalization.ts (mask + restore, so `$`-style casing never
- * touches a code span's content), spelling.ts (mask, so a misspelling
- * check never flags identifier text), and metric.ts (strip, so readability
- * scoring never counts a code span's words/syllables) -- all three need
- * the identical CommonMark-correct span recognition, just applied
- * differently (mask-and-restore vs outright removal).
- */
-export const BACKTICK_SPAN_RE = /(`+)[^\n]*?\1(?!`)/g;
-/**
- * Placeholder character `maskInlineCode` masks spans with. \0 sits outside
- * every word tokenizer in the codebase (title-case.ts's WORD_RE,
- * capitalization.ts's sentence tokenizer, spelling.ts's word regex), so a
- * masked span is invisible to word-based scanning -- never matched, never
- * capitalized, never the first/last word.
- */
-export const INLINE_CODE_MASK_CHAR = '\0';
-/**
- * Masks every inline code span in `text` with a SAME-LENGTH run of
- * INLINE_CODE_MASK_CHAR. Length-preserving on purpose: every remaining
- * token's offset stays aligned with the original text, so match positions
- * computed against the masked string are valid source positions -- and
- * `restoreInlineCode` can splice the original spans back purely by
- * position.
- */
-export function maskInlineCode(text) {
-    return text.replace(BACKTICK_SPAN_RE, (span) => INLINE_CODE_MASK_CHAR.repeat(span.length));
-}
-/**
- * Restores the inline code spans of `original` into `transformed`, a string
- * derived from `maskInlineCode(original)` by length-preserving transforms
- * only (e.g. case changes). Splices by position, not content search: the
- * span offsets found in `original` are still the span offsets in
- * `transformed` because masking and the intervening transforms never change
- * string length.
- */
-export function restoreInlineCode(original, transformed) {
-    let result = '';
-    let cursor = 0;
-    for (const match of original.matchAll(BACKTICK_SPAN_RE)) {
-        const start = match.index ?? 0;
-        const end = start + match[0].length;
-        result += transformed.slice(cursor, start);
-        result += original.slice(start, end); // restore the masked span verbatim
-        cursor = end;
-    }
-    result += transformed.slice(cursor);
-    return result;
-}
-/**
- * The half-open character ranges `[start, end)` of every inline code span
- * in `text`, using the same `BACKTICK_SPAN_RE` span recognition as
- * `maskInlineCode`/`restoreInlineCode` -- span recognition stays in exactly
- * one place.
- *
- * For rules that must REJECT a match inside code rather than rewrite text
- * (swap.ts, pattern.ts): those rules run an arbitrary user-supplied regex
- * (a `pattern` token, a `swap` key under `keysAreRegex`), and masking can
- * change what that regex matches. `maskInlineCode` substitutes a
- * same-length run of `\0` for a span's real characters -- and `\0` is not
- * whitespace, not a comma, not anything in particular. A negated class
- * like `[^\s,]+` treats that run as ordinary "not comma, not whitespace"
- * text and can match straight through it, merging text before and after
- * the span -- including whatever character (e.g. a comma) the class
- * exists to react to -- into one bogus match. A range check has no such
- * failure mode: the regex still runs against the genuine, unmodified text,
- * and a match is discarded only AFTER the fact, if its span overlaps a
- * code span. Use `inlineCodeRanges` + `overlapsAnyRange` for that; keep
- * `maskInlineCode` for rules that transform text in place and need a
- * length-preserving stand-in (capitalization.ts, spelling.ts).
- */
-export function inlineCodeRanges(text) {
-    const ranges = [];
-    for (const match of text.matchAll(BACKTICK_SPAN_RE)) {
-        const start = match.index ?? 0;
-        ranges.push({ start, end: start + match[0].length });
-    }
-    return ranges;
-}
-/**
- * Whether the half-open range `[start, end)` overlaps ANY of `ranges`.
- * Half-open, exclusive-end comparison on both sides: a match that only
- * touches a range's boundary -- ends exactly where the range starts, or
- * starts exactly where the range ends -- does NOT overlap.
- */
-export function overlapsAnyRange(start, end, ranges) {
-    return ranges.some((range) => start < range.end && range.start < end);
-}
-//# sourceMappingURL=inline-code.js.map

package/dist/core/inline-code.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"inline-code.js","sourceRoot":"","sources":["../../src/core/inline-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,qBAAqB,CAAC;AAEtD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAE1C;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,OAAO,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,qBAAqB,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;AAC7F,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAgB,EAAE,WAAmB;IACrE,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACxD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;QAC/B,MAAM,GAAG,GAAG,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QACpC,MAAM,IAAI,WAAW,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC3C,MAAM,IAAI,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,mCAAmC;QACzE,MAAM,GAAG,GAAG,CAAC;IACf,CAAC;IACD,MAAM,IAAI,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACpC,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,MAAM,MAAM,GAA0C,EAAE,CAAC;IACzD,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACpD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;QAC/B,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;IACvD,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAa,EACb,GAAW,EACX,MAA6C;IAE7C,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;AACxE,CAAC"}

package/dist/core/line-endings.d.ts

@@ -1,32 +0,0 @@
-/**
- * Matches one line ending: CRLF (`\r\n`), lone CR (`\r`), or LF (`\n`).
- * Safe to share: `String.prototype.split` ignores the `g` flag/lastIndex,
- * and `String.prototype.match` with `g` always scans from index 0.
- */
-export declare const newLineRe: RegExp;
-/**
- * Gets the file's most common line ending, falling back to the platform
- * default for content with no line endings at all — the exact semantics of
- * upstream's `getPreferredLineEnding(input, os)`. `applyFixesToContent`
- * joins fixed lines with this, so an all-CRLF file round-trips through
- * --fix still CRLF (and a mixed-endings file is normalized to its
- * majority ending, as markdownlint's `applyFixes` does).
- */
-/**
- * Maps a 0-based character offset within `text` to a 1-based
- * (line, column) pair, treating CRLF, lone CR, and lone LF each as ONE
- * line ending — the single offset→position mapping every scope-rule
- * internals must use instead of hand-rolled `split('\n')` /
- * `lastIndexOf('\n')` arithmetic (which, on a CR-only file, keeps every
- * offset on line 1 with a column counted from the start of the text).
- *
- * An offset pointing INTO a CRLF pair (at its '\n') is reported as
- * column 1 of the following line; real callers pass match/sentence
- * offsets, which never start inside a line ending.
- */
-export declare function offsetToLineColumn(text: string, offset: number): {
-    line: number;
-    column: number;
-};
-export declare function getPreferredLineEnding(input: string): string;
-//# sourceMappingURL=line-endings.d.ts.map

package/dist/core/line-endings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"line-endings.d.ts","sourceRoot":"","sources":["../../src/core/line-endings.ts"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,eAAO,MAAM,SAAS,QAAc,CAAC;AAErC;;;;;;;GAOG;AACH;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAQjG;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAa5D"}

package/dist/core/line-endings.js

@@ -1,65 +0,0 @@
-// Ported from markdownlint's line-ending helpers (helpers/shared.cjs
-// `newlineRe` and helpers/helpers.cjs `getPreferredLineEnding`;
-// https://github.com/DavidAnson/markdownlint, MIT © David Anson).
-//
-// Everything that turns file content into per-line arrays (the runner's
-// ctx.lines, applyFixesToContent's working lines) must split with
-// `newLineRe`, never a bare '\n' — a CRLF file split on '\n' leaves a
-// trailing '\r' on every line, which token rules then misread as trailing
-// whitespace (and --fix would then mangle).
-import * as os from 'node:os';
-/**
- * Matches one line ending: CRLF (`\r\n`), lone CR (`\r`), or LF (`\n`).
- * Safe to share: `String.prototype.split` ignores the `g` flag/lastIndex,
- * and `String.prototype.match` with `g` always scans from index 0.
- */
-export const newLineRe = /\r\n?|\n/g;
-/**
- * Gets the file's most common line ending, falling back to the platform
- * default for content with no line endings at all — the exact semantics of
- * upstream's `getPreferredLineEnding(input, os)`. `applyFixesToContent`
- * joins fixed lines with this, so an all-CRLF file round-trips through
- * --fix still CRLF (and a mixed-endings file is normalized to its
- * majority ending, as markdownlint's `applyFixes` does).
- */
-/**
- * Maps a 0-based character offset within `text` to a 1-based
- * (line, column) pair, treating CRLF, lone CR, and lone LF each as ONE
- * line ending — the single offset→position mapping every scope-rule
- * internals must use instead of hand-rolled `split('\n')` /
- * `lastIndexOf('\n')` arithmetic (which, on a CR-only file, keeps every
- * offset on line 1 with a column counted from the start of the text).
- *
- * An offset pointing INTO a CRLF pair (at its '\n') is reported as
- * column 1 of the following line; real callers pass match/sentence
- * offsets, which never start inside a line ending.
- */
-export function offsetToLineColumn(text, offset) {
-    let line = 1;
-    let lineStart = 0;
-    for (const match of text.slice(0, offset).matchAll(newLineRe)) {
-        line++;
-        lineStart = match.index + match[0].length;
-    }
-    return { line, column: offset - lineStart + 1 };
-}
-export function getPreferredLineEnding(input) {
-    let cr = 0;
-    let lf = 0;
-    let crlf = 0;
-    const endings = input.match(newLineRe) ?? [];
-    for (const ending of endings) {
-        if (ending === '\r')
-            cr++;
-        else if (ending === '\n')
-            lf++;
-        else
-            crlf++;
-    }
-    if (!cr && !lf && !crlf)
-        return os.EOL;
-    if (lf >= crlf && lf >= cr)
-        return '\n';
-    return crlf >= cr ? '\r\n' : '\r';
-}
-//# sourceMappingURL=line-endings.js.map

package/dist/core/line-endings.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"line-endings.js","sourceRoot":"","sources":["../../src/core/line-endings.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,gEAAgE;AAChE,kEAAkE;AAClE,EAAE;AACF,wEAAwE;AACxE,kEAAkE;AAClE,sEAAsE;AACtE,0EAA0E;AAC1E,4CAA4C;AAC5C,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAE9B;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,WAAW,CAAC;AAErC;;;;;;;GAOG;AACH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY,EAAE,MAAc;IAC7D,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QAC9D,IAAI,EAAE,CAAC;QACP,SAAS,GAAG,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAC5C,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,CAAC,EAAE,CAAC;AAClD,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,KAAa;IAClD,IAAI,EAAE,GAAG,CAAC,CAAC;IACX,IAAI,EAAE,GAAG,CAAC,CAAC;IACX,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IAC7C,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,IAAI,MAAM,KAAK,IAAI;YAAE,EAAE,EAAE,CAAC;aACrB,IAAI,MAAM,KAAK,IAAI;YAAE,EAAE,EAAE,CAAC;;YAC1B,IAAI,EAAE,CAAC;IACd,CAAC;IACD,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,CAAC,GAAG,CAAC;IACvC,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,EAAE;QAAE,OAAO,IAAI,CAAC;IACxC,OAAO,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;AACpC,CAAC"}

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

@@ -1,79 +0,0 @@
-import type { Fix } from '../types/index.js';
-import type { TokenTree } from '../parser/types.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 declare const MARKDOC_TAG_MASK_CHAR = " ";
-/**
- * One markdoc tag's verbatim source bytes on ONE line. A block tag whose
- * attributes are broken across lines (`{% table\n  x=1 %}`) contributes one
- * entry per line it covers, so every entry is a plain single-line span that a
- * `Fix` — itself always confined to one line — can be compared against directly.
- */
-export interface MarkdocTagSpan {
-    /** 1-based source line. */
-    line: number;
-    /** 1-based, inclusive. */
-    startColumn: number;
-    /** 1-based, exclusive. */
-    endColumn: number;
-    /** The source bytes between those columns — what must survive a fix. */
-    text: string;
-}
-/**
- * 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 declare function markdocTagSpans(tree: TokenTree, content: string): MarkdocTagSpan[];
-export interface ProtectedFixes {
-    /** Fixes safe to apply — tag-overlapping ones with their tags restored. */
-    fixes: Fix[];
-    /** Fixes that could not be made tag-safe, for the caller's skipped list. */
-    dropped: Fix[];
-}
-/**
- * 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 declare function protectMarkdocTags(fixes: Fix[], spans: MarkdocTagSpan[], content: string): ProtectedFixes;
-//# sourceMappingURL=markdoc-tags.d.ts.map