@intentius/chant 0.124.12 → 0.124.14

package/dist/lint/config.js

@@ -0,0 +1,483 @@
+import { readFileSync, existsSync } from "fs";
+import { join, dirname, resolve } from "path";
+import { z } from "zod";
+import { evaluateProjectConfigSync } from "../config-sandbox.js";
+import { moduleDir, getRuntime } from "../runtime-adapter.js";
+import { canonicalRuleId } from "../audit/catalog.js";
+import strictPreset from "./presets/strict.json" with { type: "json" };
+// chant #1117 — the upward config-discovery walk moved to a shared module
+// (`../project-root`) so `chant build`/`lint.policies` use the identical walk
+// `chant lint`/`chant graph` already did. Re-exported here since this is
+// still where every existing call site (`./config.test.ts`, `../cli/commands/lint.ts`)
+// imports it from.
+export { findProjectRoot } from "../project-root.js";
+/** Mapping of built-in preset names to their file paths */
+const BUILTIN_PRESETS = {
+    "@intentius/chant/lint/presets/strict": resolve(moduleDir(import.meta.url), "presets/strict.json"),
+    "@intentius/chant/lint/presets/relaxed": resolve(moduleDir(import.meta.url), "presets/relaxed.json"),
+};
+// ── Zod schemas for lint config validation ─────────────────────────
+const SeveritySchema = z.enum(["off", "error", "warning", "info"]);
+const RuleConfigSchema = z.union([
+    SeveritySchema,
+    z.tuple([SeveritySchema, z.record(z.string(), z.unknown())]),
+]);
+export const LintConfigSchema = z.object({
+    rules: z.record(z.string(), RuleConfigSchema).optional(),
+    extends: z.array(z.string()).optional(),
+    overrides: z.array(z.object({
+        files: z.array(z.string()),
+        rules: z.record(z.string(), RuleConfigSchema),
+    })).optional(),
+    plugins: z.array(z.string()).optional(),
+    policies: z.array(z.string()).optional(),
+    presets: z.record(z.string(), z.string()).optional(),
+});
+/**
+ * Check if a Zod union error is specifically about an invalid severity string
+ * (as opposed to a completely wrong type like a number).
+ */
+function isBadSeverityError(issue, config, path) {
+    if (issue.code !== "invalid_union")
+        return null;
+    // Navigate to the value in the config to see what was actually provided
+    let value = config;
+    for (const key of path) {
+        if (value == null || typeof value !== "object")
+            return null;
+        value = value[key];
+    }
+    // If the value is a string, the user meant it as a severity — show the specific severity error
+    if (typeof value === "string") {
+        return value;
+    }
+    return null;
+}
+/**
+ * Format a Zod error into a human-readable message matching existing error patterns.
+ */
+function formatLintConfigError(configPath, error, rawConfig) {
+    const issue = error.issues[0];
+    const path = issue.path;
+    // Cast path to (string | number)[] — Zod's path is PropertyKey[] but only uses string | number
+    const p = path;
+    // rules.{ruleId} — invalid severity or structure
+    if (p[0] === "rules" && p.length >= 2) {
+        const ruleId = p[1];
+        const badValue = isBadSeverityError(issue, rawConfig, p);
+        if (badValue !== null) {
+            return `Invalid config file ${configPath}: rule "${ruleId}" has invalid severity "${badValue}". Must be "off", "error", "warning", or "info"`;
+        }
+        return `Invalid config file ${configPath}: rule "${ruleId}" must be a severity string or [severity, options] tuple`;
+    }
+    // rules — wrong type
+    if (p[0] === "rules" && p.length === 1) {
+        return `Invalid config file ${configPath}: rules must be an object`;
+    }
+    // extends — wrong type or element type
+    if (p[0] === "extends") {
+        if (p.length === 1) {
+            return `Invalid config file ${configPath}: extends must be an array`;
+        }
+        return `Invalid config file ${configPath}: extends must be an array of strings`;
+    }
+    // overrides[i].* errors
+    if (p[0] === "overrides") {
+        if (p.length === 1) {
+            return `Invalid config file ${configPath}: overrides must be an array`;
+        }
+        const i = p[1];
+        if (p.length === 2) {
+            return `Invalid config file ${configPath}: overrides[${i}] must be an object`;
+        }
+        if (p[2] === "files") {
+            if (p.length === 3) {
+                return `Invalid config file ${configPath}: overrides[${i}].files must be an array`;
+            }
+            return `Invalid config file ${configPath}: overrides[${i}].files must be an array of strings`;
+        }
+        if (p[2] === "rules") {
+            if (p.length === 3) {
+                return `Invalid config file ${configPath}: overrides[${i}].rules must be an object`;
+            }
+            if (p.length >= 4) {
+                const ruleId = p[3];
+                const badValue = isBadSeverityError(issue, rawConfig, p);
+                if (badValue !== null) {
+                    return `Invalid config file ${configPath}: overrides[${i}] rule "${ruleId}" has invalid severity "${badValue}". Must be "off", "error", "warning", or "info"`;
+                }
+                return `Invalid config file ${configPath}: overrides[${i}] rule "${ruleId}" must be a severity string or [severity, options] tuple`;
+            }
+        }
+    }
+    // plugins — wrong type or element type
+    if (p[0] === "plugins") {
+        if (p.length === 1) {
+            return `Invalid config file ${configPath}: plugins must be an array`;
+        }
+        return `Invalid config file ${configPath}: plugins must be an array of strings`;
+    }
+    // Fallback
+    return `Invalid config file ${configPath}: ${issue.message}`;
+}
+/**
+ * Parse a rule config value into severity and options
+ */
+export function parseRuleConfig(value) {
+    if (typeof value === "string") {
+        return { severity: value };
+    }
+    if (!Array.isArray(value) || value.length !== 2) {
+        throw new Error(`Invalid rule config: expected a severity string or [severity, options] tuple`);
+    }
+    const [severity, options] = value;
+    if (typeof severity !== "string" || !isValidSeverity(severity)) {
+        throw new Error(`Invalid rule config: severity "${severity}" must be "off", "error", "warning", or "info"`);
+    }
+    if (typeof options !== "object" || options === null || Array.isArray(options)) {
+        throw new Error(`Invalid rule config: options must be a plain object`);
+    }
+    return { severity, options };
+}
+/**
+ * Resolve one check/rule id's effective severity (and options) against an
+ * already-resolved `lint.rules` map — the ONE place `"off"`/severity-override
+ * resolution happens, so a rule id behaves identically regardless of which
+ * phase produced it.
+ *
+ * chant #1138 — before this, the same `lint.rules: { ID: "off" }` config was
+ * resolved by two independent call sites that had grown their own copy of
+ * this logic (`../cli/commands/lint.ts`'s `getDefaultRules` for AST COR/EVL
+ * rules, and its `runComponentCheckDiagnostics` for whole-component COMP*
+ * checks) — identical in effect, but a rule id's suppression having two
+ * places to (potentially, eventually) diverge is itself the bug class #1138
+ * is about. Both were converted to call this instead, and post-synth checks/
+ * policies (`./post-synth.ts`'s `applyConfiguredSeverity`) now go through it
+ * too, closing the gap the issue reports: a post-synth check id honors
+ * `lint.rules` exactly like an AST rule id does.
+ *
+ * `rules` takes the already-resolved map (`config.rules`, or
+ * `resolveRulesForFile`'s per-file merge) rather than a whole `LintConfig` —
+ * callers that need per-file `overrides` resolve that first; post-synth
+ * checks have no per-file scope to begin with (see {@link
+ * ./post-synth.ts!PostSynthDiagnostic}'s doc for why), so they always pass
+ * `config.rules` directly.
+ *
+ * `catalog` (chant #2113) is optional and off by default: pass a resolved
+ * audit catalog to also honor a `rules` key that names one of `id`'s
+ * `RuleMeta.aliases` rather than `id` itself. A project's
+ * `lint.rules: { OLD_ID: "off" }` then keeps suppressing the rule after it
+ * is renamed/renumbered, instead of silently starting to match nothing. Every
+ * existing call site omits `catalog` and is unaffected; a caller that has one
+ * handy (an audit-shaped consumer, not `chant build`'s post-synth loop, which
+ * has no catalog readily resolved at that point) opts in by passing it.
+ */
+export function resolveConfiguredSeverity(rules, id, defaultSeverity, catalog) {
+    const configValue = rules?.[id];
+    if (configValue !== undefined)
+        return parseRuleConfig(configValue);
+    if (catalog && rules) {
+        for (const [key, value] of Object.entries(rules)) {
+            if (canonicalRuleId(key, catalog) === id)
+                return parseRuleConfig(value);
+        }
+    }
+    return { severity: defaultSeverity };
+}
+/**
+ * Default configuration with all rules enabled at strict preset severities
+ */
+export const DEFAULT_CONFIG = {
+    rules: { ...strictPreset.rules },
+    extends: [],
+};
+/**
+ * Validate that a severity string is valid
+ */
+function isValidSeverity(value) {
+    return value === "off" || value === "error" || value === "warning" || value === "info";
+}
+/**
+ * Load and merge a single config file
+ */
+function loadConfigFile(configPath, visited = new Set()) {
+    // Check for circular extends
+    if (visited.has(configPath)) {
+        throw new Error(`Circular extends detected: ${configPath}`);
+    }
+    visited.add(configPath);
+    // Read and parse config file
+    if (!existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    let content;
+    try {
+        content = readFileSync(configPath, "utf-8");
+    }
+    catch (err) {
+        throw new Error(`Failed to read config file ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let raw;
+    try {
+        raw = JSON.parse(content);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse config file ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Validate config structure
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error(`Invalid config file ${configPath}: must be an object`);
+    }
+    // Accept both shapes: lint fields at top level (legacy) OR nested under a
+    // "lint" key (matches chant.config.ts ChantConfig shape). When the JSON has
+    // both a top-level "rules"/"extends"/etc AND a "lint": {...}, prefer the
+    // nested one — that matches the explicit ChantConfig contract.
+    const rawObj = raw;
+    let config;
+    if (rawObj.lint &&
+        typeof rawObj.lint === "object" &&
+        !Array.isArray(rawObj.lint)) {
+        config = rawObj.lint;
+    }
+    else {
+        config = rawObj;
+    }
+    // Validate with Zod schema
+    const parseResult = LintConfigSchema.safeParse(config);
+    if (!parseResult.success) {
+        throw new Error(formatLintConfigError(configPath, parseResult.error, config));
+    }
+    // Process extends
+    let mergedConfig = { rules: {}, extends: [] };
+    if (config.extends && config.extends.length > 0) {
+        const baseDir = dirname(configPath);
+        for (const extendPath of config.extends) {
+            // Resolve paths: relative, built-in preset, or absolute
+            let resolvedPath;
+            if (extendPath.startsWith(".")) {
+                resolvedPath = join(baseDir, extendPath);
+            }
+            else if (extendPath.startsWith("@intentius/chant")) {
+                const builtinPath = BUILTIN_PRESETS[extendPath];
+                if (builtinPath) {
+                    resolvedPath = builtinPath;
+                }
+                else {
+                    throw new Error(`Unknown preset: ${extendPath} (extended from ${configPath})`);
+                }
+            }
+            else {
+                resolvedPath = extendPath;
+            }
+            // Check if extended config exists
+            if (!existsSync(resolvedPath)) {
+                throw new Error(`Extended config file not found: ${resolvedPath} (extended from ${configPath})`);
+            }
+            // Load extended config recursively
+            const extendedConfig = loadConfigFile(resolvedPath, visited);
+            // Merge rules (later configs override earlier ones)
+            mergedConfig.rules = {
+                ...mergedConfig.rules,
+                ...extendedConfig.rules,
+            };
+        }
+    }
+    // Merge current config rules on top
+    mergedConfig.rules = {
+        ...mergedConfig.rules,
+        ...config.rules,
+    };
+    // Preserve overrides from the current config
+    if (config.overrides) {
+        mergedConfig.overrides = config.overrides;
+    }
+    // Preserve plugins from the current config only (not inherited from extends)
+    if (config.plugins) {
+        mergedConfig.plugins = config.plugins;
+    }
+    return mergedConfig;
+}
+/**
+ * Load lint configuration from a directory.
+ *
+ * Tries `chant.config.ts` first (extracts `lint` property from ChantConfig),
+ * then falls back to `chant.config.json` (legacy LintConfig format).
+ * Returns default configuration if neither exists.
+ *
+ * chant #1113 — the `chant.config.ts` branch executes project-authored code,
+ * so it goes through `../config-sandbox.ts` like every other config load
+ * rather than `require`-ing the file itself. Unarmed (which is every `chant
+ * lint` invocation today — `lint` has no `--sandbox` flag) that is the
+ * identical `createRequire` path this used before, moved one module over.
+ *
+ * @param dir - Directory path to search for config file
+ * @returns Loaded and merged configuration, or default config if not found
+ */
+export function loadConfig(dir) {
+    // Try chant.config.ts first — Bun has native require() for .ts, Node uses tsx's loader
+    const tsConfigPath = join(dir, "chant.config.ts");
+    if (existsSync(tsConfigPath)) {
+        try {
+            const config = evaluateProjectConfigSync(tsConfigPath, dir);
+            if (typeof config === "object" && config !== null) {
+                // ChantConfig format: extract lint property
+                if ("lint" in config && typeof config.lint === "object") {
+                    return config.lint;
+                }
+                // Bare rules at top level
+                if ("rules" in config) {
+                    return config;
+                }
+                // Config exists but has no lint section — use defaults
+                return DEFAULT_CONFIG;
+            }
+        }
+        catch {
+            // Fall through to JSON
+        }
+    }
+    // Fall back to chant.config.json
+    const jsonConfigPath = join(dir, "chant.config.json");
+    if (!existsSync(jsonConfigPath)) {
+        return DEFAULT_CONFIG;
+    }
+    try {
+        return loadConfigFile(jsonConfigPath);
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Resolve the effective rules for a specific file path by applying overrides.
+ *
+ * Starts with the base config rules, then iterates through overrides in order.
+ * For each override whose file globs match the given path, merges override rules on top.
+ *
+ * @param config - The loaded lint configuration
+ * @param filePath - The file path to resolve rules for (relative to project root)
+ * @returns Merged rule configuration with overrides applied
+ */
+export function resolveRulesForFile(config, filePath) {
+    const rules = { ...config.rules };
+    if (!config.overrides) {
+        return rules;
+    }
+    for (const override of config.overrides) {
+        const matches = override.files.some((pattern) => {
+            return getRuntime().globMatch(pattern, filePath);
+        });
+        if (matches) {
+            Object.assign(rules, override.rules);
+        }
+    }
+    return rules;
+}
+/**
+ * Apply `lint.rules` severity overrides to already-produced post-synth
+ * diagnostics — one lexicon-shipped check's findings, or one project's
+ * `lint.policies` findings, it doesn't matter which: both are plain
+ * `PostSynthDiagnostic[]` by the time they reach this function, so both go
+ * through the identical resolution an AST rule id or a COMP* check id gets
+ * (`resolveConfiguredSeverity`, above), keyed by `diag.checkId` instead of
+ * `LintRule.id`/`ComponentCheck.id`. `"off"` suppresses (moved to
+ * `suppressed`); any other configured severity replaces `diag.severity`,
+ * exactly as a config override changes an AST diagnostic's reported level.
+ *
+ * Lives here rather than in `./post-synth.ts` (where `PostSynthDiagnostic` is
+ * declared) on purpose: `post-synth.ts` is a leaf every lexicon's checks
+ * import as a real runtime module, and this file resolves built-in preset
+ * paths via the runtime adapter at module scope — pulling that into every
+ * lexicon's check barrel merely to share one filter function would be the
+ * wrong trade. Only this file's TYPE (`PostSynthDiagnostic`) crosses back,
+ * which costs nothing at runtime.
+ *
+ * chant #1138 — deliberately does NOT also honor `chant-disable` source
+ * comments. `PostSynthDiagnostic` has no source anchor to disable AT — see
+ * its doc comment (`./post-synth.ts`) for why `entity` doesn't supply one —
+ * so there is no coherent site to check for a directive. Even in the one case
+ * a real anchor sometimes exists (a live, in-process `ctx.entities` value
+ * stamped with build provenance, `../provenance.ts`'s `getProvenance`), it
+ * would not generalize: not every check sets `entity`, `entity` isn't
+ * guaranteed to be an entities-map key (it's a name in the synthesized
+ * OUTPUT — a CFN logical id, a k8s `metadata.name` — which a serializer is
+ * free to have derived, prefixed, or renamed from the source-level entity
+ * name), and that provenance never crosses the `--sandbox` policy child's
+ * JSON wire (`../discovery/entity-wire-codec.ts` doesn't carry it, and
+ * re-deriving it on the far side would mean sending source file paths into a
+ * channel that's supposed to carry only the resolved build). Building
+ * directive suppression on a sometimes-present, sometimes-not anchor would
+ * make `chant build` and `chant build --sandbox` disagree about the
+ * identical finding depending on which path happened to still have the
+ * entity object around — precisely the kind of inconsistency #1138 exists to
+ * remove. Config severity (`"off"`) is the one suppression surface this can
+ * offer uniformly; a check that wants a per-instance escape hatch can read
+ * `ctx.env`/its own options to decide not to emit a diagnostic at all.
+ *
+ * chant #2111 adds a second, narrower surface next to this one:
+ * `./suppressions.ts`'s `applyInlineSuppressions` matches `diag.entity`
+ * against `ctx.entities` (a source-level map key every `PostSynthContext`
+ * carries) instead of a name in the synthesized output, so it sidesteps the
+ * exact mismatch this comment describes. It is opt-in per lexicon (an entity
+ * has to carry a `suppressions` field) and runs as its own pass, right after
+ * this one, in both `chant build` and `chant audit`. See that module's doc
+ * for the full reasoning.
+ *
+ * `catalog` (chant #2113, optional) passes straight through to
+ * `resolveConfiguredSeverity` above for alias resolution; see its doc for
+ * what that buys and why it's opt-in.
+ */
+export function applyConfiguredSeverity(diagnostics, rules, catalog) {
+    const kept = [];
+    const suppressed = [];
+    for (const diag of diagnostics) {
+        const resolved = resolveConfiguredSeverity(rules, diag.checkId, diag.severity, catalog);
+        if (resolved.severity === "off") {
+            suppressed.push(diag);
+            continue;
+        }
+        kept.push(resolved.severity === diag.severity ? diag : { ...diag, severity: resolved.severity });
+    }
+    return { diagnostics: kept, suppressed };
+}
+/**
+ * Resolve `lint.presets`' name for one lexicon into the set of check ids that
+ * preset enables (chant #2113). `presets` is what a lexicon plugin's
+ * `lintPresets()` returns (`../lexicon.ts`). A lexicon that ships none
+ * passes `undefined` here, in which case this returns `undefined` and
+ * `applyConfiguredPreset` below becomes a no-op (every rule reports, exactly
+ * today's behavior for a lexicon this feature doesn't touch).
+ *
+ * An unrecognized preset name (a typo, or a name the lexicon doesn't define)
+ * also returns `undefined` rather than an empty set. Falling back to
+ * unfiltered is the safe failure direction; silently reporting nothing would
+ * not be.
+ */
+export function resolvePresetIds(presets, presetName) {
+    const ids = presets?.[presetName];
+    return ids ? new Set(ids) : undefined;
+}
+/**
+ * Filter post-synth diagnostics down to an active preset's ids (chant
+ * #2113). `presetIds` is `resolvePresetIds`'s output. `undefined` disables
+ * filtering entirely (a lexicon with no presets, or an unresolved preset
+ * name), matching tflint's own precedence chain (`--only` / rule config,
+ * then preset, then `disabled_by_default`, `tflint-ruleset-terraform`'s
+ * config docs): an explicit `lint.rules` entry for a check id always keeps
+ * that id's findings, whether or not the active preset includes it, so a
+ * project can opt a single report-only rule back in under `recommended`
+ * without switching its whole lexicon to `all`.
+ */
+export function applyConfiguredPreset(diagnostics, presetIds, rules) {
+    if (!presetIds)
+        return { diagnostics: [...diagnostics], suppressed: [] };
+    const kept = [];
+    const suppressed = [];
+    for (const diag of diagnostics) {
+        if (presetIds.has(diag.checkId) || rules?.[diag.checkId] !== undefined)
+            kept.push(diag);
+        else
+            suppressed.push(diag);
+    }
+    return { diagnostics: kept, suppressed };
+}

package/dist/lint/declarative.js

@@ -0,0 +1,122 @@
+import { resolveSelector } from "./selectors.js";
+import { getNamedCheck } from "./named-checks.js";
+/**
+ * Build a standard LintRule from a declarative RuleSpec.
+ */
+export function rule(spec) {
+    const selectorFn = resolveSelector(spec.selector);
+    return {
+        id: spec.id,
+        severity: spec.severity,
+        category: spec.category,
+        description: spec.description,
+        helpUri: spec.helpUri,
+        check(context) {
+            const diagnostics = [];
+            const sf = context.sourceFile;
+            let nodes = selectorFn(sf);
+            // Apply match conditions
+            if (spec.match) {
+                nodes = nodes.filter((node) => matchNode(node, spec.match, sf, context));
+            }
+            // Apply custom validation
+            if (spec.validate) {
+                nodes = nodes.filter((node) => spec.validate(node, context));
+            }
+            for (const node of nodes) {
+                const { line, character } = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+                const nodeText = node.getText(sf);
+                const message = spec.message.replace(/\{node\}/g, nodeText);
+                const diagnostic = {
+                    file: context.filePath,
+                    line: line + 1,
+                    column: character + 1,
+                    ruleId: spec.id,
+                    severity: spec.severity,
+                    message,
+                };
+                if (spec.fix) {
+                    diagnostic.fix = buildFix(node, spec.fix, sf);
+                }
+                diagnostics.push(diagnostic);
+            }
+            return diagnostics;
+        },
+    };
+}
+/**
+ * Check if a node matches the given condition.
+ */
+function matchNode(node, condition, sf, context) {
+    // Pattern match
+    if (condition.pattern) {
+        const text = node.getText(sf);
+        if (!condition.pattern.test(text))
+            return false;
+    }
+    // Within match — node must be inside a parent matching the selector
+    if (condition.within) {
+        const parentSelector = resolveSelector(condition.within);
+        const parents = parentSelector(sf);
+        const isWithin = parents.some((parent) => isAncestorOf(parent, node));
+        if (!isWithin)
+            return false;
+    }
+    // Require match — node must contain children matching the selector(s)
+    if (condition.require) {
+        const reqs = Array.isArray(condition.require) ? condition.require : [condition.require];
+        for (const req of reqs) {
+            const childSelector = resolveSelector(req);
+            const children = childSelector(sf);
+            const hasChild = children.some((child) => isAncestorOf(node, child));
+            if (!hasChild)
+                return false;
+        }
+    }
+    // Named check
+    if (condition.check) {
+        const checkFn = getNamedCheck(condition.check);
+        if (!checkFn) {
+            throw new Error(`Unknown named check: "${condition.check}"`);
+        }
+        if (!checkFn(node, context))
+            return false;
+    }
+    return true;
+}
+/**
+ * Check if `ancestor` is an ancestor of `node`.
+ */
+function isAncestorOf(ancestor, node) {
+    let current = node.parent;
+    while (current) {
+        if (current === ancestor)
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+/**
+ * Build a LintFix from a declarative fix spec.
+ */
+function buildFix(node, fix, sf) {
+    const start = node.getStart(sf);
+    const end = node.getEnd();
+    switch (fix.kind) {
+        case "replace": {
+            const text = fix.resolve ? fix.resolve(node, sf) : (fix.text ?? "");
+            return { range: [start, end], replacement: text, kind: "replace" };
+        }
+        case "insert-before": {
+            const text = fix.resolve ? fix.resolve(node, sf) : (fix.text ?? "");
+            return { range: [start, start], replacement: text, kind: "insert-before" };
+        }
+        case "insert-after": {
+            const text = fix.resolve ? fix.resolve(node, sf) : (fix.text ?? "");
+            return { range: [end, end], replacement: text, kind: "insert-after" };
+        }
+        case "delete": {
+            return { range: [start, end], replacement: "", kind: "delete" };
+        }
+    }
+}

package/dist/lint/discover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../src/lint/discover.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAYnD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,QAAQ,EAAE,CAkBhF;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,cAAc,EAAE,CAkB5F;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAYnD"}
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../src/lint/discover.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA8BnD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,QAAQ,EAAE,CAmBhF;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,cAAc,EAAE,CAmB5F;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAYnD"}