@x18n/builtins 0.0.13 → 0.0.15

package/dist/reporters.mjs

@@ -1,221 +1,11 @@
-import { createLineIndex, envelope, toWireDiagnostic } from "@x18n/core";
 //#region src/reporters/index.ts
-const codes = {
-	red: 31,
-	yellow: 33,
-	cyan: 36,
-	gray: 90,
-	blue: 34,
-	bold: 1
+/** Reporters by id. Each is also its own module, `@x18n/builtins/reporters/<id>`. */
+const reporters = {
+	pretty: () => import("./reporters/pretty.mjs"),
+	json: () => import("./reporters/json.mjs"),
+	markdown: () => import("./reporters/markdown.mjs"),
+	github: () => import("./reporters/github.mjs"),
+	sarif: () => import("./reporters/sarif.mjs")
 };
-function paint(ctx, color, text) {
-	return ctx.color ? `\u001B[${codes[color]}m${text}\u001B[0m` : text;
-}
-function plural(count, word) {
-	return `${count} ${word}${count === 1 ? "" : "s"}`;
-}
-function totals(inputs) {
-	return inputs.reduce((sum, input) => ({
-		errors: sum.errors + input.summary.errors,
-		warnings: sum.warnings + input.summary.warnings,
-		infos: sum.infos + input.summary.infos,
-		files: sum.files + input.summary.files
-	}), {
-		errors: 0,
-		warnings: 0,
-		infos: 0,
-		files: 0
-	});
-}
-const severityColor = {
-	error: "red",
-	warning: "yellow",
-	info: "blue",
-	hint: "gray"
-};
-/** The severity as a highlighted label, like ` ERROR `. */
-function badge(ctx, severity) {
-	const label = ` ${severity.toUpperCase()} `;
-	return ctx.color ? `\u001B[1;7;${codes[severityColor[severity]]}m${label}\u001B[0m` : label;
-}
-/** The marked line with one line of context on each side, and `~` under the range. */
-function codeFrame(text, start, end, severity, ctx) {
-	const index = createLineIndex(text);
-	const from = index.position(start);
-	const to = index.position(end);
-	const first = Math.max(0, from.line - 1);
-	const last = Math.min(index.lineCount - 1, from.line + 1);
-	const pad = String(last + 1).length;
-	const gutter = (n) => `${paint(ctx, "gray", n.padStart(pad))} ${paint(ctx, "gray", "│")} `;
-	const width = Math.max(1, (to.line === from.line ? to.character : index.line(from.line).length) - from.character);
-	const lines = [];
-	for (let n = first; n <= last; n++) {
-		const line = index.line(n);
-		lines.push(`${gutter(String(n + 1))}${n === from.line ? line : paint(ctx, "gray", line)}`);
-		if (n === from.line) lines.push(`${gutter("")}${" ".repeat(from.character)}${paint(ctx, severityColor[severity], "~".repeat(width))}`);
-	}
-	return lines.join("\n");
-}
-/** `path:line:col`, then the severity, message and check, a code frame, and a summary. */
-const prettyReporter = {
-	id: "pretty",
-	report(inputs, ctx) {
-		const blocks = [];
-		for (const input of inputs) for (const d of input.diagnostics) {
-			const head = `${badge(ctx, d.severity)} ${d.message}  ${paint(ctx, "gray", d.code)}`;
-			if (!d.location) {
-				blocks.push(head);
-				continue;
-			}
-			const text = input.text(d.location.path);
-			const position = createLineIndex(text ?? "").position(d.location.range.start);
-			const where = `${paint(ctx, "cyan", ctx.displayPath(d.location.path, input.project))}${paint(ctx, "gray", `:${position.line + 1}:${position.character + 1}`)}`;
-			const frame = text !== void 0 && d.location.range.end > d.location.range.start ? `\n${codeFrame(text, d.location.range.start, d.location.range.end, d.severity, ctx)}` : "";
-			blocks.push(`${where}\n${head}${frame}`);
-		}
-		const sum = totals(inputs);
-		if (sum.errors + sum.warnings === 0) blocks.push(paint(ctx, "gray", "Found no errors."));
-		else {
-			const parts = [
-				sum.errors ? paint(ctx, "red", `✖ ${plural(sum.errors, "error")}`) : "",
-				sum.warnings ? paint(ctx, "yellow", `⚠ ${plural(sum.warnings, "warning")}`) : "",
-				paint(ctx, "gray", plural(sum.files, "file"))
-			].filter(Boolean);
-			blocks.push(parts.join("  "));
-		}
-		return `${blocks.join("\n\n")}\n`;
-	}
-};
-/** The versioned JSON contract of `x18n check --json`. */
-const jsonReporter = {
-	id: "json",
-	report(inputs) {
-		const diagnostics = inputs.flatMap((input) => input.diagnostics.map((d) => toWireDiagnostic(input.project, d, input.text)));
-		const data = { projects: inputs.map((input) => ({
-			name: input.project,
-			summary: input.summary,
-			coverage: input.coverage.map((c) => ({
-				locale: c.locale,
-				total: c.total,
-				translated: c.translated,
-				missing: c.missing.length,
-				empty: c.empty.length,
-				outdated: c.outdated.length
-			}))
-		})) };
-		return `${JSON.stringify(envelope("check", data, diagnostics), null, 2)}\n`;
-	}
-};
-function escapeCell(text) {
-	return text.replace(/\|/g, "\\|").replace(/\n/g, " ");
-}
-/** Summary and tables for PR comments and agent context. */
-const markdownReporter = {
-	id: "markdown",
-	report(inputs, ctx) {
-		const sum = totals(inputs);
-		const out = [
-			"## x18n check",
-			"",
-			`**${plural(sum.errors, "error")}**, ${plural(sum.warnings, "warning")} in ${plural(sum.files, "file")}.`,
-			""
-		];
-		for (const input of inputs) {
-			if (inputs.length > 1) out.push(`### ${input.project}`, "");
-			out.push("| Locale | Translated | Missing | Empty |", "| --- | --- | --- | --- |");
-			for (const c of input.coverage) out.push(`| ${c.locale} | ${c.translated}/${c.total} | ${c.missing.length} | ${c.empty.length} |`);
-			out.push("");
-			if (input.diagnostics.length === 0) continue;
-			out.push("| Severity | Check | Location | Message |", "| --- | --- | --- | --- |");
-			for (const d of input.diagnostics.slice(0, 200)) {
-				const line = d.location ? createLineIndex(input.text(d.location.path) ?? "").position(d.location.range.start).line + 1 : void 0;
-				const where = d.location ? `\`${ctx.displayPath(d.location.path, input.project)}:${line}\`` : "";
-				out.push(`| ${d.severity} | \`${d.code}\` | ${where} | ${escapeCell(d.message)} |`);
-			}
-			if (input.diagnostics.length > 200) out.push("", `_${input.diagnostics.length - 200} more not shown._`);
-			out.push("");
-		}
-		return `${out.join("\n")}\n`;
-	}
-};
-function escapeProperty(text) {
-	return text.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C");
-}
-function escapeData(text) {
-	return text.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
-}
-/** GitHub Actions workflow commands, which become annotations on the PR. */
-const githubReporter = {
-	id: "github",
-	report(inputs, ctx) {
-		const out = [];
-		for (const input of inputs) for (const d of input.diagnostics) {
-			const level = d.severity === "error" ? "error" : d.severity === "warning" ? "warning" : "notice";
-			const props = [`title=${escapeProperty(`x18n ${d.code}`)}`];
-			if (d.location) {
-				const wire = toWireDiagnostic(input.project, d, input.text).range;
-				props.unshift(`file=${escapeProperty(ctx.displayPath(d.location.path, input.project))}`, `line=${wire.line}`, `col=${wire.column}`, `endLine=${wire.endLine}`, `endColumn=${wire.endColumn}`);
-			}
-			out.push(`::${level} ${props.join(",")}::${escapeData(d.message)}`);
-		}
-		return out.length ? `${out.join("\n")}\n` : "";
-	}
-};
-/** SARIF 2.1.0 for code scanning. */
-const sarifReporter = {
-	id: "sarif",
-	report(inputs, ctx) {
-		const all = inputs.flatMap((input) => input.diagnostics.map((d) => ({
-			input,
-			d
-		})));
-		const rules = [...new Set(all.map(({ d }) => d.code))].sort();
-		const results = all.map(({ input, d }) => {
-			const wire = toWireDiagnostic(input.project, d, input.text);
-			return {
-				ruleId: d.code,
-				level: d.severity === "error" ? "error" : d.severity === "warning" ? "warning" : "note",
-				message: { text: d.message },
-				locations: d.location && wire.range ? [{ physicalLocation: {
-					artifactLocation: { uri: ctx.displayPath(d.location.path, input.project) },
-					region: {
-						startLine: wire.range.line,
-						startColumn: wire.range.column,
-						endLine: wire.range.endLine,
-						endColumn: wire.range.endColumn
-					}
-				} }] : []
-			};
-		});
-		const log = {
-			$schema: "https://json.schemastore.org/sarif-2.1.0.json",
-			version: "2.1.0",
-			runs: [{
-				tool: { driver: {
-					name: "x18n",
-					informationUri: "https://x18n.antfu.dev",
-					rules: rules.map((id) => ({
-						id,
-						helpUri: `https://x18n.antfu.dev/checks/${id}`
-					}))
-				} },
-				results
-			}]
-		};
-		return `${JSON.stringify(log, null, 2)}\n`;
-	}
-};
-function reporters() {
-	return {
-		name: "x18n:reporters",
-		reporters: [
-			prettyReporter,
-			jsonReporter,
-			markdownReporter,
-			githubReporter,
-			sarifReporter
-		]
-	};
-}
 //#endregion
-export { githubReporter, jsonReporter, markdownReporter, prettyReporter, reporters, sarifReporter };
+export { reporters };

package/dist/reviews.d.mts

@@ -0,0 +1,6 @@
+import { Plugin, ReviewStore } from "@x18n/core";
+//#region src/reviews/index.d.ts
+/** Reviews in a YAML file (`.x18n/reviews.yml`), tracked in git so they show up in pull requests. */
+export declare const yamlReviewStore: ReviewStore;
+export declare function reviews(): Plugin;
+//#endregion

package/dist/reviews.mjs

@@ -0,0 +1,35 @@
+import { ReviewFileSchema, validate } from "@x18n/core";
+import { parse, stringify } from "yaml";
+//#region src/reviews/index.ts
+const header = "# yaml-language-server: $schema=https://x18n.antfu.dev/schema/reviews.json\n";
+/** Reviews in a YAML file (`.x18n/reviews.yml`), tracked in git so they show up in pull requests. */
+const yamlReviewStore = {
+	id: "yaml",
+	parse(text) {
+		const result = validate(ReviewFileSchema, parse(text) ?? { x18n: 1 });
+		if (!result.success) throw new Error(result.issues.map((issue) => `${issue.path || "(root)"}: ${issue.message}`).join("; "));
+		return {
+			threads: result.output.threads ?? {},
+			sources: result.output.sources ?? {}
+		};
+	},
+	serialize(data) {
+		const file = {
+			x18n: 1,
+			...Object.keys(data.threads).length > 0 && { threads: data.threads },
+			...Object.keys(data.sources).length > 0 && { sources: data.sources }
+		};
+		return header + stringify(file, {
+			lineWidth: 0,
+			aliasDuplicateObjects: false
+		});
+	}
+};
+function reviews() {
+	return {
+		name: "x18n:reviews",
+		reviewStores: [yamlReviewStore]
+	};
+}
+//#endregion
+export { reviews, yamlReviewStore };

package/dist/scanners/astro.d.mts

@@ -0,0 +1,6 @@
+import { Plugin } from "@x18n/core";
+//#region src/scanners/astro/index.d.ts
+/** Astro components: the `---` frontmatter, `<script>` and template expressions through the `js` scanner. */
+export declare function astro(): Plugin;
+//#endregion
+export { astro as default };

package/dist/scanners/astro.mjs

@@ -0,0 +1,256 @@
+import { n as loadParser, r as scanSource, t as isTextAttribute } from "../js-CV-ECNJG.mjs";
+//#region src/scanners/astro/index.ts
+const voidElements = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"source",
+	"track",
+	"wbr"
+]);
+/**
+* Splits an Astro template into the parts the `js` scanner reads: top-level `{...}` expressions and
+* `<script>` contents, plus text and text attributes as hard strings. Markup inside an expression
+* (`{items.map(i => <li>{t(i)}</li>)}`) stays in the expression, which oxc parses as JSX.
+*/
+var AstroTemplate = class {
+	text;
+	textAttributes;
+	expressions = [];
+	scripts = [];
+	hardStrings = [];
+	constructor(text, textAttributes) {
+		this.text = text;
+		this.textAttributes = textAttributes;
+	}
+	/** Index after the first `token` from `i`, or the end of the text. */
+	after(i, token) {
+		const at = this.text.indexOf(token, i);
+		return at < 0 ? this.text.length : at + token.length;
+	}
+	/** Index after the run of characters matching `pattern` (sticky) at `i`. */
+	skip(pattern, i) {
+		pattern.lastIndex = i;
+		return pattern.test(this.text) ? pattern.lastIndex : i;
+	}
+	/** Markup from `i`. At the top level it records what it finds; nested in an expression it returns after its closing tag. */
+	markup(i, nested) {
+		const { text } = this;
+		let textStart = i;
+		while (i < text.length) {
+			const c = text[i];
+			const next = text[i + 1] ?? "";
+			if (c !== "{" && c !== "<") {
+				i++;
+				continue;
+			}
+			let end;
+			if (c === "{") end = this.expression(i, nested);
+			else if (text.startsWith("<!--", i)) end = this.after(i, "-->");
+			else if (next === "/" || next === "!" || next === "?") end = this.after(i, ">");
+			else if (/[a-z>]/i.test(next)) end = this.element(i, nested);
+			else {
+				i++;
+				continue;
+			}
+			if (!nested) this.textNode(textStart, i);
+			if (nested && c === "<" && next === "/") return end;
+			i = textStart = end;
+		}
+		if (!nested) this.textNode(textStart, i);
+		return i;
+	}
+	element(i, nested) {
+		const { text } = this;
+		const nameEnd = this.skip(/[^\s/>{]*/y, i + 1);
+		const name = text.slice(i + 1, nameEnd).toLowerCase();
+		let j = nameEnd;
+		while (j < text.length) {
+			j = this.skip(/\s*/y, j);
+			if (text[j] === ">" || text.startsWith("/>", j)) break;
+			if (text[j] === "{") {
+				j = this.expression(j, nested);
+				continue;
+			}
+			const attributeStart = j;
+			j = Math.max(this.skip(/[^\s=>/{]+/y, j), j + 1);
+			if (text[j] !== "=") continue;
+			const attribute = text.slice(attributeStart, j);
+			const quote = text[++j];
+			if (quote === "{") j = this.expression(j, nested);
+			else if (quote === "`") {
+				const end = this.template(j) + 1;
+				if (!nested) this.expressions.push({
+					start: j,
+					end
+				});
+				j = end;
+			} else if (quote === "\"" || quote === "'") {
+				const end = this.after(j + 1, quote);
+				const value = text.slice(j + 1, end - 1);
+				if (!nested && isTextAttribute(attribute, this.textAttributes) && /\p{L}/u.test(value)) this.hardStrings.push({
+					text: value,
+					range: {
+						start: attributeStart,
+						end
+					},
+					kind: "astro-attribute",
+					attribute
+				});
+				j = end;
+			} else j = this.skip(/[^\s>]*/y, j);
+		}
+		const selfClosing = text.startsWith("/>", j);
+		const end = Math.min(j + (selfClosing ? 2 : 1), text.length);
+		if (name === "script" || name === "style") {
+			const close = new RegExp(`</${name}`, "gi");
+			close.lastIndex = end;
+			const closeStart = close.exec(text)?.index ?? text.length;
+			if (name === "script" && !nested) this.scripts.push({
+				start: end,
+				end: closeStart
+			});
+			return this.after(closeStart, ">");
+		}
+		if (!nested || selfClosing || voidElements.has(name)) return end;
+		return this.markup(end, true);
+	}
+	/** `{...}` at `i`; returns the index after its `}`. */
+	expression(i, nested) {
+		const close = this.js(i + 1);
+		if (!nested) this.expressions.push({
+			start: i + 1,
+			end: close
+		});
+		return close + 1;
+	}
+	/** Index of the `}` that closes JS code starting at `i`, past strings, comments and JSX. */
+	js(i) {
+		const { text } = this;
+		let depth = 0;
+		let previous = "(";
+		for (; i < text.length; i++) {
+			const c = text[i];
+			if (c === "\"" || c === "'") i = this.literal(i, c);
+			else if (c === "`") i = this.template(i);
+			else if (text.startsWith("//", i)) i = this.after(i, "\n") - 1;
+			else if (text.startsWith("/*", i)) i = this.after(i, "*/") - 1;
+			else if (c === "/" && this.startsOperand(i, previous)) i = this.literal(i, "/");
+			else if (c === "{") depth++;
+			else if (c === "}") {
+				if (depth-- === 0) return i;
+			} else if (c === "<" && /[a-z>]/i.test(text[i + 1] ?? "") && this.startsOperand(i, previous)) {
+				i = this.element(i, true) - 1;
+				previous = ">";
+				continue;
+			}
+			if (!/\s/.test(c)) previous = c;
+		}
+		return text.length;
+	}
+	/** Whether `i` starts a value rather than continuing one: `<` opens JSX and `/` a regex there, after a value they are operators. */
+	startsOperand(i, previous) {
+		return !/[\w$)\]]/.test(previous) || /\breturn\s*$/.test(this.text.slice(Math.max(0, i - 10), i));
+	}
+	/** Index of the `quote` that closes the string or regex literal at `i`, past escapes and regex classes. */
+	literal(i, quote) {
+		const { text } = this;
+		let inClass = false;
+		for (i++; i < text.length; i++) {
+			const c = text[i];
+			if (c === "\\") i++;
+			else if (quote === "/" && (c === "[" || c === "]")) inClass = c === "[";
+			else if (c === quote && !inClass) return i;
+		}
+		return text.length;
+	}
+	/** Index of the backtick that closes the template literal at `i`. */
+	template(i) {
+		const { text } = this;
+		for (i++; i < text.length; i++) if (text[i] === "\\") i++;
+		else if (text[i] === "`") return i;
+		else if (text.startsWith("${", i)) i = this.js(i + 2);
+		return text.length;
+	}
+	textNode(start, end) {
+		const data = this.text.slice(start, end);
+		const text = data.trim();
+		if (!/\p{L}/u.test(text)) return;
+		const at = start + data.indexOf(text);
+		this.hardStrings.push({
+			text,
+			range: {
+				start: at,
+				end: at + text.length
+			},
+			kind: "astro-text"
+		});
+	}
+};
+/** Astro components: the `---` frontmatter, `<script>` and template expressions through the `js` scanner. */
+function astro() {
+	return {
+		name: "x18n:scanner-astro",
+		scanners: [{
+			id: "astro",
+			extensions: ["astro"],
+			async scan(file, ctx) {
+				const parse = await loadParser();
+				const { text } = file;
+				const usages = [];
+				const keySlots = [];
+				const hardStrings = [];
+				const add = (range, filename, expression, reportHardStrings) => {
+					let result;
+					try {
+						result = scanSource(parse, text.slice(range.start, range.end), {
+							calls: ctx.calls,
+							ignoreCallees: ctx.config.extract.ignoreCallees,
+							textAttributes: ctx.config.extract.attributes,
+							offset: range.start,
+							filename,
+							expression,
+							hardStrings: reportHardStrings
+						});
+					} catch {
+						return;
+					}
+					usages.push(...result.usages);
+					keySlots.push(...result.keySlots ?? []);
+					hardStrings.push(...result.hardStrings ?? []);
+				};
+				let templateStart = 0;
+				const open = /^\s*---/.exec(text);
+				if (open) {
+					const close = /^---/gm;
+					close.lastIndex = open[0].length;
+					const end = close.exec(text)?.index ?? text.length;
+					add({
+						start: open[0].length,
+						end
+					}, "frontmatter.ts", false, true);
+					templateStart = end + 3;
+				}
+				const template = new AstroTemplate(text, ctx.config.extract.attributes);
+				template.markup(templateStart, false);
+				for (const range of template.scripts) add(range, "script.ts", false, false);
+				for (const range of template.expressions) add(range, "template.tsx", true, false);
+				hardStrings.push(...template.hardStrings);
+				return {
+					usages,
+					keySlots,
+					hardStrings
+				};
+			}
+		}]
+	};
+}
+//#endregion
+export { astro, astro as default };

package/dist/scanners/js.d.mts

@@ -0,0 +1,6 @@
+import { Plugin } from "@x18n/core";
+//#region src/scanners/js/index.d.ts
+/** The AST scanner for JS and TS, driven by call specs (`usage.calls`). */
+export declare function js(): Plugin;
+//#endregion
+export { js as default };

package/dist/scanners/js.mjs

@@ -0,0 +1,33 @@
+import { n as loadParser, r as scanSource } from "../js-CV-ECNJG.mjs";
+//#region src/scanners/js/index.ts
+/** The AST scanner for JS and TS, driven by call specs (`usage.calls`). */
+function js() {
+	return {
+		name: "x18n:scanner-js",
+		scanners: [{
+			id: "js",
+			extensions: [
+				"js",
+				"jsx",
+				"mjs",
+				"cjs",
+				"ts",
+				"tsx",
+				"mts",
+				"cts"
+			],
+			async scan(file, ctx) {
+				const parse = await loadParser();
+				return scanSource(parse, file.text, {
+					calls: ctx.calls,
+					filename: file.path,
+					hardStrings: true,
+					ignoreCallees: ctx.config.extract.ignoreCallees,
+					textAttributes: ctx.config.extract.attributes
+				});
+			}
+		}]
+	};
+}
+//#endregion
+export { js as default, js };

package/dist/scanners/regex-scopes.d.mts

@@ -0,0 +1,14 @@
+import { Plugin } from "@x18n/core";
+//#region src/scanners/regex-scopes/index.d.ts
+/**
+ * Regions after each match of `pattern` (group 1 = namespace, or key prefix with `as: 'keyPrefix'`; or the
+ * named groups `namespace` and `keyPrefix`), up to the next match: i18n-ally `scopeRangeRegex`.
+ * With `wholeFile`, the first match scopes the whole file. Matches that capture nothing are skipped.
+ */
+export declare function regexScopes(pattern: string, id?: string, options?: {
+  readonly as?: "namespace" | "keyPrefix";
+  readonly extensions?: readonly string[];
+  readonly wholeFile?: boolean;
+}): Plugin;
+//#endregion
+export { regexScopes as default };

package/dist/scanners/regex-scopes.mjs

@@ -0,0 +1,41 @@
+//#region src/scanners/regex-scopes/index.ts
+/**
+* Regions after each match of `pattern` (group 1 = namespace, or key prefix with `as: 'keyPrefix'`; or the
+* named groups `namespace` and `keyPrefix`), up to the next match: i18n-ally `scopeRangeRegex`.
+* With `wholeFile`, the first match scopes the whole file. Matches that capture nothing are skipped.
+*/
+function regexScopes(pattern, id = "scopes", options = {}) {
+	const re = new RegExp(pattern, "g");
+	return {
+		name: `x18n:scanner-${id}`,
+		scanners: [{
+			id,
+			extensions: options.extensions ?? ["*"],
+			scan(file) {
+				const found = [...file.text.matchAll(re)].map((match) => ({
+					match,
+					values: match.groups ? {
+						namespace: match.groups.namespace,
+						keyPrefix: match.groups.keyPrefix
+					} : options.as === "keyPrefix" ? { keyPrefix: match[1] } : { namespace: match[1] }
+				})).filter(({ values }) => values.namespace !== void 0 || values.keyPrefix !== void 0);
+				if (options.wholeFile) found.splice(1);
+				return {
+					usages: [],
+					scopes: found.map(({ match, values }, i) => ({
+						range: options.wholeFile ? {
+							start: 0,
+							end: file.text.length
+						} : {
+							start: match.index + match[0].length,
+							end: found[i + 1]?.match.index ?? file.text.length
+						},
+						...values
+					}))
+				};
+			}
+		}]
+	};
+}
+//#endregion
+export { regexScopes as default, regexScopes };

package/dist/scanners/regex.d.mts

@@ -0,0 +1,9 @@
+import { Plugin, RegexScannerSpec, UsageCandidate } from "@x18n/core";
+//#region src/scanners/regex/index.d.ts
+/** Turns a pattern with a `{key}` placeholder into a regex whose first group is the key. */
+export declare function compileUsagePattern(pattern: string): RegExp;
+export declare function scanWithRegex(text: string, regexes: readonly RegExp[]): UsageCandidate[];
+/** The `regex` scanner over `usage.regex` specs, plus extra specs given here (YAML plugins). */
+export declare function regex(specs?: readonly RegexScannerSpec[], id?: string): Plugin;
+//#endregion
+export { regex as default };