@mintlify/cli 4.0.1812 → 4.1.1

package/bin/update.js

@@ -1,65 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { jsx as _jsx } from "react/jsx-runtime";
-import { SpinnerLog, SuccessLog, ErrorLog, addLog, addErrorLog, clearLogs, getLatestClientVersion, downloadTargetMint, getClientVersion, } from '@mintlify/previewing';
-import { assertValidPackageName, execFileAsync, getLatestCliVersion, getVersions, detectPackageManager, windowsCompatibleSpawnOptions, } from './helpers.js';
-export const update = (_a) => __awaiter(void 0, [_a], void 0, function* ({ packageName }) {
-    assertValidPackageName(packageName);
-    addLog(_jsx(SpinnerLog, { message: "updating..." }));
-    const { cli: existingCliVersion } = getVersions(packageName);
-    const latestCliVersion = getLatestCliVersion(packageName);
-    const isUpToDate = existingCliVersion && latestCliVersion && latestCliVersion.trim() === existingCliVersion.trim();
-    if (!isUpToDate && existingCliVersion && latestCliVersion.trim() !== existingCliVersion.trim()) {
-        const packageManager = yield detectPackageManager({ packageName });
-        try {
-            clearLogs();
-            addLog(_jsx(SpinnerLog, { message: `updating ${packageName} package...` }));
-            if (packageManager === 'pnpm') {
-                yield execFileAsync('pnpm', ['install', '-g', `${packageName}@latest`, '--silent'], windowsCompatibleSpawnOptions);
-            }
-            else {
-                yield execFileAsync('npm', ['install', '-g', `${packageName}@latest`, '--silent'], windowsCompatibleSpawnOptions);
-            }
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            addErrorLog(_jsx(ErrorLog, { message: `Failed to update ${packageName}@${latestCliVersion} using ${packageManager}: ${errorMessage}` }));
-            return;
-        }
-    }
-    clearLogs();
-    addLog(_jsx(SpinnerLog, { message: "updating client..." }));
-    let clientUpdated = false;
-    const latestClientVersion = yield getLatestClientVersion();
-    if (latestClientVersion) {
-        const existingClientVersion = getClientVersion().trim();
-        if (existingClientVersion !== latestClientVersion.trim()) {
-            try {
-                yield downloadTargetMint({
-                    targetVersion: latestClientVersion,
-                    existingVersion: existingClientVersion === 'none' ? null : existingClientVersion,
-                });
-                clientUpdated = true;
-            }
-            catch (err) {
-                const errorMessage = err instanceof Error ? err.message : String(err);
-                addErrorLog(_jsx(ErrorLog, { message: `Failed to update client: ${errorMessage}` }));
-                return;
-            }
-        }
-    }
-    clearLogs();
-    if (isUpToDate && !clientUpdated) {
-        addLog(_jsx(SuccessLog, { message: "already up to date" }));
-    }
-    else {
-        addLog(_jsx(SuccessLog, { message: `updated ${packageName} to the latest version: ${latestCliVersion}` }));
-    }
-});

package/bin/validate/command.js

@@ -1,127 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { jsx as _jsx } from "react/jsx-runtime";
-import { addLog, checkBuild, clearLogs, ErrorLog, SpinnerLog } from '@mintlify/previewing';
-import path from 'node:path';
-import { format } from 'node:util';
-import { CMD_EXEC_PATH, errorMessage, getVersions, terminate } from '../helpers.js';
-import { resolveExplicitFiles } from '../resolveFiles.js';
-import { sendPublishPrompt } from '../signup.js';
-import { checkSite, runBuildChecks, selectRules } from './engine.js';
-import { logReport } from './output.js';
-import { toReport } from './report.js';
-export const EXIT = { passed: 0, failed: 1, crashed: 2 };
-export const splitList = (values) => values.flatMap((value) => value
-    .split(',')
-    .map((item) => item.trim())
-    .filter(Boolean));
-const write = (text) => new Promise((resolve) => {
-    process.stdout.write(text, () => resolve());
-});
-/**
- * Writes console output straight to stderr, so --format json leaves stdout to the report. Ink
- * patches console and redraws on stdout, so redirecting to console.error isn't enough.
- */
-const consoleToStderr = () => {
-    const original = {
-        log: console.log,
-        info: console.info,
-        warn: console.warn,
-        error: console.error,
-    };
-    const toStderr = (...args) => {
-        process.stderr.write(`${format(...args)}\n`);
-    };
-    console.log = console.info = console.warn = console.error = toStderr;
-    return () => Object.assign(console, original);
-};
-const resolveSelection = (baseDir, values) => __awaiter(void 0, void 0, void 0, function* () {
-    const args = (values !== null && values !== void 0 ? values : []).map(String).filter(Boolean);
-    if (args.length === 0)
-        return undefined;
-    const files = yield resolveExplicitFiles(CMD_EXEC_PATH, args);
-    return new Set(files.map((file) => path.relative(baseDir, path.resolve(CMD_EXEC_PATH, file)).split(path.sep).join('/')));
-});
-/** mint validate: one pass over every selected rule, then the strict build when nothing failed. */
-export const validateHandler = (argv_1, packageName_1, ...args_1) => __awaiter(void 0, [argv_1, packageName_1, ...args_1], void 0, function* (argv, packageName, baseDir = CMD_EXEC_PATH) {
-    var _a;
-    const json = argv.format === 'json';
-    const restoreConsole = json ? consoleToStderr() : undefined;
-    try {
-        const rules = selectRules({
-            enable: argv.enable,
-            disable: (_a = argv.disable) !== null && _a !== void 0 ? _a : [],
-        });
-        const selected = yield resolveSelection(baseDir, argv.files);
-        if (!json)
-            addLog(_jsx(SpinnerLog, { message: "validating..." }));
-        const _b = yield checkSite(baseDir, rules, {
-            selected,
-            localSchema: argv['local-schema'],
-            fix: argv.fix,
-        }), { site, fixed } = _b, checked = __rest(_b, ["site", "fixed"]);
-        let { diagnostics } = checked;
-        const buildRules = rules.some(({ needsBuild }) => needsBuild);
-        let build;
-        if (!argv.build) {
-            build = { ran: false, reason: 'disabled' };
-        }
-        else if (!buildRules) {
-            build = { ran: false, reason: 'no build rules' };
-        }
-        else if (diagnostics.some(({ severity }) => severity === 'error')) {
-            build = { ran: false, reason: 'errors found' };
-        }
-        else {
-            if (!json)
-                addLog(_jsx(SpinnerLog, { message: "building..." }));
-            const { cli: cliVersion } = getVersions(packageName);
-            site.build = yield checkBuild(Object.assign(Object.assign({}, argv), { _: [], $0: packageName, packageName,
-                cliVersion, disableOpenapi: !rules.some(({ group }) => group === 'openapi') }));
-            diagnostics = yield runBuildChecks(site, rules, diagnostics);
-            build = { ran: true, passed: site.build.passed };
-        }
-        const report = toReport(diagnostics, build, argv.fix ? fixed : undefined);
-        if (json) {
-            restoreConsole === null || restoreConsole === void 0 ? void 0 : restoreConsole();
-            yield write(`${JSON.stringify(report)}\n`);
-        }
-        else {
-            clearLogs();
-            logReport(report);
-            if (report.passed && build.ran && build.passed)
-                yield sendPublishPrompt();
-        }
-        yield terminate(report.passed ? EXIT.passed : EXIT.failed);
-    }
-    catch (error) {
-        // Bad arguments and crashes alike mean validate could not run
-        if (json) {
-            restoreConsole === null || restoreConsole === void 0 ? void 0 : restoreConsole();
-            process.stderr.write(`Error: ${errorMessage(error)}\n`);
-        }
-        else {
-            clearLogs();
-            addLog(_jsx(ErrorLog, { message: errorMessage(error) }));
-        }
-        yield terminate(EXIT.crashed);
-    }
-});

package/bin/validate/engine.js

@@ -1,154 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { replaceVariables } from '@mintlify/common';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { checkFiles, parseFile } from './files.js';
-import { applyEdits, selectEdits, toPosition } from './mdx.js';
-import { buildFindings } from './rules/build.js';
-import { RULES } from './rules/index.js';
-import { PARSE_ERROR } from './rules/parseError.js';
-import { loadSite } from './site.js';
-import { GROUPS, } from './types.js';
-export class UsageError extends Error {
-}
-const ruleList = () => RULES.map(({ id }) => id).join(', ');
-const matchToken = (token) => {
-    if (token === 'all')
-        return RULES;
-    const rule = RULES.find(({ id }) => id === token);
-    if (rule)
-        return [rule];
-    if (GROUPS.includes(token)) {
-        return RULES.filter(({ group }) => group === token);
-    }
-    throw new UsageError(`unknown rule or group "${token}". Groups: all, ${GROUPS.join(', ')}. Rules: ${ruleList()}`);
-};
-/** Every rule, minus --disable, plus --enable. parse-error is the engine's own, not selectable. */
-export const selectRules = ({ enable = [], disable = [], }) => {
-    if ([...disable, ...enable].includes(PARSE_ERROR.id)) {
-        throw new UsageError(`${PARSE_ERROR.id} always runs and can't be disabled`);
-    }
-    const selected = new Set(RULES);
-    for (const token of disable)
-        for (const rule of matchToken(token))
-            selected.delete(rule);
-    for (const token of enable)
-        for (const rule of matchToken(token))
-            selected.add(rule);
-    return RULES.filter((rule) => selected.has(rule));
-};
-const toDiagnostic = (source, finding) => {
-    var _a;
-    return (Object.assign(Object.assign({}, finding), { rule: source.id, group: source.group, severity: (_a = finding.severity) !== null && _a !== void 0 ? _a : source.severity }));
-};
-const RULE_ORDER = new Map(RULES.map(({ id }, index) => [id, index]));
-const sortDiagnostics = (diagnostics) => diagnostics.sort((a, b) => {
-    var _a, _b, _c, _d, _e, _f;
-    return (a.file < b.file ? -1 : a.file > b.file ? 1 : 0) ||
-        ((_a = a.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.line) !== null && _b !== void 0 ? _b : 0) ||
-        ((_c = a.column) !== null && _c !== void 0 ? _c : 0) - ((_d = b.column) !== null && _d !== void 0 ? _d : 0) ||
-        ((_e = RULE_ORDER.get(a.rule)) !== null && _e !== void 0 ? _e : 0) - ((_f = RULE_ORDER.get(b.rule)) !== null && _f !== void 0 ? _f : 0);
-});
-/** Adds findings for a rule unless a diagnostic of that rule already has the same key. */
-const merge = (diagnostics, source, extra, key) => {
-    const reported = new Set(diagnostics.filter((item) => item.rule === source.id).map(key));
-    for (const finding of extra) {
-        if (reported.has(key(finding)))
-            continue;
-        reported.add(key(finding));
-        diagnostics.push(toDiagnostic(source, finding));
-    }
-};
-const addParseErrors = (site, diagnostics, extra) => merge(diagnostics, PARSE_ERROR, extra.filter(({ file }) => !site.selected || site.selected.has(file)), ({ file }) => file);
-const fileRulesOf = (rules) => rules.filter((rule) => rule.scope === 'file');
-const runSiteRules = (site, rules, needsBuild, diagnostics) => __awaiter(void 0, void 0, void 0, function* () {
-    for (const rule of rules) {
-        if (rule.scope !== 'site' || Boolean(rule.needsBuild) !== needsBuild)
-            continue;
-        for (const finding of yield rule.check(site))
-            diagnostics.push(toDiagnostic(rule, finding));
-    }
-});
-/** Runs every selected rule that doesn't need the build. */
-export const runChecks = (site, rules) => __awaiter(void 0, void 0, void 0, function* () {
-    const diagnostics = yield checkFiles(site, fileRulesOf(rules));
-    yield runSiteRules(site, rules, false, diagnostics);
-    return sortDiagnostics(diagnostics);
-});
-/** Adds the build's findings to a site whose build has run. */
-export const runBuildChecks = (site, rules, diagnostics) => __awaiter(void 0, void 0, void 0, function* () {
-    yield runSiteRules(site, rules, true, diagnostics);
-    // The file pass already reported files it couldn't parse; the build adds the rest
-    addParseErrors(site, diagnostics, buildFindings(site, 'parse-error'));
-    return sortDiagnostics(diagnostics);
-});
-const parseLevel = (file, content, baseDir) => {
-    const parsed = parseFile(file, content, baseDir);
-    return 'error' in parsed ? 0 : parsed.approximate ? 1 : 2;
-};
-/** Applies every fix that doesn't overlap an earlier fix in the same file, writing each Markdown file only when its fixed content parses at least as well as before. */
-export const applyFixes = (site, diagnostics) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const read = (file) => { var _a; return (_a = site.read(file)) !== null && _a !== void 0 ? _a : ''; };
-    const chosen = new Map();
-    const overlaps = ({ file, start, end }) => { var _a; return ((_a = chosen.get(file)) !== null && _a !== void 0 ? _a : []).some(({ fix }) => start < fix.end && fix.start < end); };
-    for (const { rule, fix } of diagnostics) {
-        if (!fix || overlaps(fix))
-            continue;
-        const content = read(fix.file);
-        const change = Object.assign(Object.assign({ rule, file: fix.file }, toPosition(content, fix.start)), { before: content.slice(fix.start, fix.end), after: fix.text });
-        chosen.set(fix.file, [...((_a = chosen.get(fix.file)) !== null && _a !== void 0 ? _a : []), { fix, change }]);
-    }
-    const snippets = new Set(site.files.filter(({ kind }) => kind === 'snippet').map(({ file }) => file));
-    const level = (file, content) => parseLevel(file, snippets.has(file) ? replaceVariables(content, site.variables) : content, site.baseDir);
-    const applied = [];
-    for (const [file, picks] of chosen) {
-        const content = read(file);
-        const updated = applyEdits(content, selectEdits(picks.map(({ fix }) => fix)));
-        if (/\.mdx?$/.test(file) && level(file, updated) < level(file, content)) {
-            continue;
-        }
-        yield fs.writeFile(path.join(site.baseDir, file), updated);
-        applied.push(...picks.map(({ change }) => change));
-    }
-    return applied;
-});
-// Fixes can unlock others (a self-closed <br> lets a page parse), so --fix runs a few passes
-const MAX_FIX_PASSES = 5;
-/**
- * Loads the site and runs the selected rules. With fix, applies the fixes, rechecks only the
- * files that changed for further fixes, then runs every rule once more for the final report.
- */
-export const checkSite = (baseDir, rules, options) => __awaiter(void 0, void 0, void 0, function* () {
-    const fixed = [];
-    let site = yield loadSite(baseDir, options);
-    const { selected } = options;
-    if (selected && !site.files.some(({ file }) => selected.has(file))) {
-        throw new UsageError(`none of the given files are pages or snippets of this site: ${[...selected].join(', ')}`);
-    }
-    const diagnostics = yield runChecks(site, rules);
-    if (!options.fix)
-        return { site, diagnostics, fixed };
-    // Only file rules offer fixes, so passes after the first recheck just the files that changed
-    let pending = diagnostics;
-    for (let pass = 0; pass < MAX_FIX_PASSES; pass++) {
-        const changes = yield applyFixes(site, pending);
-        if (changes.length === 0)
-            break;
-        fixed.push(...changes);
-        site = yield loadSite(baseDir, options);
-        const changed = new Set(changes.map(({ file }) => file));
-        pending = sortDiagnostics(yield checkFiles(Object.assign(Object.assign({}, site), { selected: changed }), fileRulesOf(rules)));
-    }
-    if (fixed.length === 0)
-        return { site, diagnostics, fixed };
-    return { site, diagnostics: yield runChecks(site, rules), fixed };
-});

package/bin/validate/files.js

@@ -1,163 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { getAST, getFileCategory, parseFrontmatter, replaceVariables } from '@mintlify/common';
-import { categorizeMdxFiles, getErrorPosition, getMintIgnore, listContentFiles, } from '@mintlify/prebuild';
-import { applyEdits, collectAnchorLinks, parseContent, relocate, selectEdits, toOffset, unmapEdit, } from './mdx.js';
-import { PARSE_ERROR } from './rules/parseError.js';
-const CHECKED_CATEGORIES = new Set(['page', 'snippet', 'snippet-v2']);
-export const readSiteFiles = (baseDir) => __awaiter(void 0, void 0, void 0, function* () {
-    const { mdxCandidates: candidates } = yield listContentFiles(baseDir, yield getMintIgnore(baseDir));
-    const { snippets, snippetsV2 } = yield categorizeMdxFiles(baseDir, candidates);
-    const snippetFiles = new Set([...snippets, ...snippetsV2]);
-    return candidates
-        .filter((name) => /\.mdx?$/.test(name) && CHECKED_CATEGORIES.has(getFileCategory(name)))
-        .map((name) => ({
-        file: name.replace(/^\//, ''),
-        kind: (snippetFiles.has(name) ? 'snippet' : 'page'),
-    }));
-});
-const readFrontmatter = (content) => {
-    try {
-        const { attributes } = parseFrontmatter(content);
-        return attributes && typeof attributes === 'object' ? Object.assign({}, attributes) : {};
-    }
-    catch (_a) {
-        return {};
-    }
-};
-const REASON_POSITION = /\s*\(\d+:\d+(?:-\d+:\d+)?\)$/;
-const TAG_NAME_RULES = new Set(['unexpected-character', 'unexpected-eof']);
-const ESCAPE_HINT = "; if this < isn't a tag, escape it as \\<";
-const isStrayLessThan = (error, content, position) => {
-    const { source, ruleId } = (error !== null && error !== void 0 ? error : {});
-    return (source === 'micromark-extension-mdx-jsx' &&
-        typeof ruleId === 'string' &&
-        TAG_NAME_RULES.has(ruleId) &&
-        (position === null || position === void 0 ? void 0 : position.line) != null &&
-        position.column != null &&
-        content[toOffset(content, position.line, position.column) - 1] === '<');
-};
-export const toParseError = (error, content = '') => {
-    const reason = error === null || error === void 0 ? void 0 : error.reason;
-    const fallback = error instanceof Error ? error.message : 'could not parse this file';
-    const text = typeof reason === 'string' ? reason : fallback;
-    const position = error && typeof error === 'object' ? getErrorPosition(error) : null;
-    const hint = isStrayLessThan(error, content, position) ? ESCAPE_HINT : '';
-    return Object.assign(Object.assign(Object.assign({}, ((position === null || position === void 0 ? void 0 : position.line) != null && { line: position.line })), ((position === null || position === void 0 ? void 0 : position.column) != null && { column: position.column })), { message: text.replace(REASON_POSITION, '') + hint });
-};
-const parseErrorDiagnostic = (file, error) => (Object.assign(Object.assign({}, error), { rule: PARSE_ERROR.id, group: PARSE_ERROR.group, severity: PARSE_ERROR.severity, file, message: `${error.message} (other checks were skipped for this file)` }));
-const tryParseContent = (content) => {
-    try {
-        return parseContent(content);
-    }
-    catch (_a) {
-        return undefined;
-    }
-};
-export const parseFile = (file, content, baseDir, extras = {}) => {
-    const context = Object.assign({ file, content, baseDir, frontmatter: readFrontmatter(content) }, extras);
-    const tree = tryParseContent(content);
-    if (tree)
-        return { context: Object.assign(Object.assign({}, context), { tree }), approximate: false };
-    try {
-        return { context: Object.assign(Object.assign({}, context), { tree: getAST(content, file) }), approximate: true };
-    }
-    catch (error) {
-        return { error: toParseError(error, content) };
-    }
-};
-const EMPTY_TREE = { type: 'root', children: [] };
-const SOURCE_STAGE = 1;
-const AFTER_RAW_STAGE = 2;
-const VARIABLE = /\{\{\s*([\w.\-]+)\s*\}\}/g;
-const variableEdits = (content, variables = {}) => [...content.matchAll(VARIABLE)]
-    .filter((match) => match[1] !== undefined && variables[match[1]] !== undefined)
-    .map((match) => ({
-    start: match.index,
-    end: match.index + match[0].length,
-    text: replaceVariables(match[0], variables),
-}));
-const toDiagnostic = (rule, file, _a, stages, stage) => {
-    var { edit } = _a, finding = __rest(_a, ["edit"]);
-    const original = edit && unmapEdit(stages, stage, edit);
-    return Object.assign(Object.assign(Object.assign(Object.assign({}, finding), relocate(stages, stage, finding)), { rule: rule.id, group: rule.group, severity: rule.severity, file }), (original && { fix: Object.assign({ file }, original) }));
-};
-const checkFile = (allRules, { file, kind }, content, baseDir, extras, variables) => {
-    const rules = kind === 'snippet' ? allRules.filter((rule) => !rule.pagesOnly) : allRules;
-    const raw = rules.filter((rule) => rule.raw);
-    const treeRules = rules.filter((rule) => !rule.raw);
-    const varEdits = kind === 'snippet' ? variableEdits(content, variables) : [];
-    const source = applyEdits(content, varEdits);
-    const rawContext = {
-        file,
-        content: source,
-        baseDir,
-        frontmatter: {},
-        tree: EMPTY_TREE,
-        variables,
-    };
-    const rawFound = raw.flatMap((rule) => rule.check(rawContext).map((finding) => ({ rule, finding })));
-    const rawEdits = selectEdits(rawFound.flatMap(({ finding }) => (finding.edit ? [finding.edit] : [])));
-    const afterRaw = applyEdits(source, rawEdits);
-    const stages = [
-        { content, edits: varEdits },
-        { content: source, edits: rawEdits },
-        { content: afterRaw, edits: [] },
-    ];
-    const diagnostics = rawFound.map(({ rule, finding }) => toDiagnostic(rule, file, finding, stages, SOURCE_STAGE));
-    const parsed = parseFile(file, afterRaw, baseDir, Object.assign(Object.assign({}, extras), { variables }));
-    if ('error' in parsed) {
-        diagnostics.unshift(parseErrorDiagnostic(file, Object.assign(Object.assign({}, parsed.error), relocate(stages, AFTER_RAW_STAGE, parsed.error))));
-        return diagnostics;
-    }
-    for (const rule of treeRules) {
-        for (const finding of rule.check(parsed.context)) {
-            const found = parsed.approximate ? Object.assign(Object.assign({}, finding), { edit: undefined }) : finding;
-            diagnostics.push(toDiagnostic(rule, file, found, stages, AFTER_RAW_STAGE));
-        }
-    }
-    return diagnostics;
-};
-const collectSiteAnchorLinks = (site) => __awaiter(void 0, void 0, void 0, function* () {
-    const pages = yield Promise.all(site.files.map(({ file }) => { var _a; return collectAnchorLinks(file, (_a = site.read(file)) !== null && _a !== void 0 ? _a : ''); }));
-    return new Set(pages.flat());
-});
-export const checkFiles = (site, rules) => __awaiter(void 0, void 0, void 0, function* () {
-    const anchorRules = new Set(rules.filter((rule) => rule.needsAnchorLinks).map(({ id }) => id));
-    const targets = site.files.filter(({ file }) => !site.selected || site.selected.has(file));
-    const checkTarget = (entry, extras) => {
-        const content = site.read(entry.file);
-        if (content === undefined) {
-            return [parseErrorDiagnostic(entry.file, { message: 'could not read this file' })];
-        }
-        return checkFile(rules, entry, content, site.baseDir, extras, site.variables);
-    };
-    const needsLinks = (diagnostics) => diagnostics.some(({ rule }) => anchorRules.has(rule));
-    const checked = targets.map((entry) => checkTarget(entry, { readFile: site.read }));
-    if (!checked.some(needsLinks))
-        return checked.flat();
-    const extras = { readFile: site.read, anchorLinks: yield collectSiteAnchorLinks(site) };
-    return targets.flatMap((entry, index) => {
-        var _a;
-        const diagnostics = (_a = checked[index]) !== null && _a !== void 0 ? _a : [];
-        return needsLinks(diagnostics) ? checkTarget(entry, extras) : diagnostics;
-    });
-});