@x18n/builtins 0.0.13 → 0.0.15

package/dist/{regex-AYVhuSb6.mjs → scanners/regex.mjs}

@@ -1,4 +1,4 @@
-//#region src/scanners/regex.ts
+//#region src/scanners/regex/index.ts
 /** The key part of i18n-ally `usageMatchRegex` patterns. */
 const keyPattern = "[\\w\\d\\. \\-\\[\\]\\/:]+?";
 /** Turns a pattern with a `{key}` placeholder into a regex whose first group is the key. */
@@ -62,43 +62,5 @@ function regex(specs = [], id = "regex") {
 		scanners: [scanner]
 	};
 }
-/**
-* 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 { scanWithRegex as i, regex as n, regexScopes as r, compileUsagePattern as t };
+export { compileUsagePattern, regex as default, regex, scanWithRegex };

package/dist/scanners/svelte.d.mts

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

package/dist/{scanners-DhnnVp7s.mjs → scanners/svelte.mjs}

@@ -1,5 +1,5 @@
-import { i as isTextAttribute, o as loadParser, s as scanSource } from "./vue-CF4pe-Yr.mjs";
-//#region src/scanners/svelte.ts
+import { n as loadParser, r as scanSource, t as isTextAttribute } from "../js-CV-ECNJG.mjs";
+//#region src/scanners/svelte/index.ts
 let compiler;
 function isSvelteNode(value) {
 	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" && "start" in value && typeof value.start === "number" && "end" in value && typeof value.end === "number";
@@ -101,4 +101,4 @@ function svelte() {
 	};
 }
 //#endregion
-export { svelte as t };
+export { svelte as default, svelte };

package/dist/scanners/vue.d.mts

@@ -0,0 +1,6 @@
+import { Plugin } from "@x18n/core";
+//#region src/scanners/vue/index.d.ts
+/** Vue SFCs: `<script>` through the `js` scanner, template expressions, `v-t`, `<i18n-t keypath>`. */
+export declare function vue(): Plugin;
+//#endregion
+export { vue as default };

package/dist/scanners/vue.mjs

@@ -0,0 +1,172 @@
+import { t as loadVueCompiler } from "../vue-compiler-0sfLIiiL.mjs";
+import { n as loadParser, r as scanSource, t as isTextAttribute } from "../js-CV-ECNJG.mjs";
+//#region src/scanners/vue/index.ts
+const ELEMENT = 1;
+const TEXT = 2;
+const SIMPLE_EXPRESSION = 4;
+const INTERPOLATION = 5;
+const ATTRIBUTE = 6;
+/** `keypath` is the vue-i18n prop for a key, on `<i18n-t>` and on the app's own wrappers of it; `path` on the legacy components. */
+function isKeyAttribute(tag, name) {
+	return name === "keypath" || name === "path" && (tag === "i18n" || tag === "i18n-d");
+}
+function merge(into, result) {
+	into.usages.push(...result.usages);
+	into.keySlots.push(...result.keySlots ?? []);
+	into.hardStrings.push(...result.hardStrings ?? []);
+}
+var TemplateScan = class {
+	parse;
+	calls;
+	textAttributes;
+	out = {
+		usages: [],
+		keySlots: [],
+		hardStrings: []
+	};
+	constructor(parse, calls, textAttributes) {
+		this.parse = parse;
+		this.calls = calls;
+		this.textAttributes = textAttributes;
+	}
+	expression(content, offset) {
+		if (!content.trim()) return;
+		try {
+			merge(this.out, scanSource(this.parse, content, {
+				calls: this.calls,
+				offset,
+				filename: "template.ts",
+				expression: true,
+				hardStrings: false
+			}));
+		} catch {}
+	}
+	/** `:keypath="cond ? 'a' : 'b'"`: the expression is read as the key argument of a translate call. */
+	keyExpression(content, offset) {
+		const callee = "__x18nKey(";
+		try {
+			const result = scanSource(this.parse, `${callee}${content})`, {
+				calls: [{ callee: "__x18nKey" }],
+				offset: offset - 10,
+				filename: "template.ts",
+				hardStrings: false
+			});
+			merge(this.out, {
+				...result,
+				usages: result.usages.map(({ expression: _, ...usage }) => usage)
+			});
+		} catch {}
+	}
+	/** `v-t="'key'"` and `v-t="{ path: 'key' }"`. */
+	vt(dir) {
+		const exp = dir.exp;
+		if (!exp || !("content" in exp)) return;
+		const offset = exp.loc.start.offset;
+		const literal = /^\s*(['"`])(.*)\1\s*$/.exec(exp.content) ?? /path\s*:\s*(['"`])(.*?)\1/.exec(exp.content);
+		if (!literal) return;
+		const start = offset + exp.content.indexOf(literal[2], literal.index);
+		const range = {
+			start,
+			end: start + literal[2].length
+		};
+		this.out.usages.push({
+			raw: literal[2],
+			range,
+			kind: "call",
+			dynamic: false
+		});
+		this.out.keySlots.push(range);
+	}
+	attribute(element, prop) {
+		if (prop.type === ATTRIBUTE) {
+			const value = prop.value;
+			if (!value) return;
+			const range = {
+				start: value.loc.start.offset + 1,
+				end: value.loc.end.offset - 1
+			};
+			if (isKeyAttribute(element.tag, prop.name)) {
+				this.out.usages.push({
+					raw: value.content,
+					range,
+					kind: "call",
+					dynamic: false
+				});
+				this.out.keySlots.push(range);
+			} else if (isTextAttribute(prop.name, this.textAttributes) && /\p{L}/u.test(value.content)) this.out.hardStrings.push({
+				text: value.content,
+				range: {
+					start: prop.loc.start.offset,
+					end: prop.loc.end.offset
+				},
+				kind: "vue-attribute",
+				attribute: prop.name
+			});
+			return;
+		}
+		if (prop.name === "t") {
+			this.vt(prop);
+			return;
+		}
+		const exp = prop.exp;
+		if (exp && "content" in exp) {
+			if (prop.name === "bind" && prop.arg && "content" in prop.arg && isKeyAttribute(element.tag, prop.arg.content)) this.keyExpression(exp.content, exp.loc.start.offset);
+			else this.expression(exp.content, exp.loc.start.offset);
+		}
+	}
+	node(node) {
+		if (node.type === INTERPOLATION && "content" in node.content) this.expression(node.content.content, node.content.loc.start.offset);
+		if (node.type === TEXT) {
+			const text = node.content.trim();
+			if (text && /\p{L}/u.test(text)) {
+				const start = node.loc.start.offset + node.content.indexOf(text);
+				this.out.hardStrings.push({
+					text,
+					range: {
+						start,
+						end: start + text.length
+					},
+					kind: "vue-template-text"
+				});
+			}
+		}
+		if (node.type === ELEMENT) for (const prop of node.props) this.attribute(node, prop);
+		if ("children" in node) {
+			for (const child of node.children) if (typeof child === "object" && child.type !== SIMPLE_EXPRESSION) this.node(child);
+		}
+	}
+};
+/** Vue SFCs: `<script>` through the `js` scanner, template expressions, `v-t`, `<i18n-t keypath>`. */
+function vue() {
+	return {
+		name: "x18n:scanner-vue",
+		scanners: [{
+			id: "vue",
+			extensions: ["vue"],
+			async scan(file, ctx) {
+				const [{ parse }, parseJs] = await Promise.all([loadVueCompiler(), loadParser()]);
+				const { descriptor } = parse(file.text, {
+					filename: file.path,
+					sourceMap: false,
+					ignoreEmpty: false
+				});
+				const template = new TemplateScan(parseJs, ctx.calls, ctx.config.extract.attributes);
+				for (const script of [descriptor.script, descriptor.scriptSetup]) {
+					if (!script) continue;
+					const lang = script.lang ?? "js";
+					merge(template.out, scanSource(parseJs, script.content, {
+						calls: ctx.calls,
+						ignoreCallees: ctx.config.extract.ignoreCallees,
+						textAttributes: ctx.config.extract.attributes,
+						offset: script.loc.start.offset,
+						filename: `script.${lang === "tsx" || lang === "jsx" ? lang : lang === "ts" ? "ts" : "js"}`
+					}));
+				}
+				if (descriptor.template?.ast) template.node(descriptor.template.ast);
+				return template.out;
+			}
+		}]
+	};
+}
+//#endregion
+export { vue as default, vue };

package/dist/scanners.d.mts

@@ -1,52 +1,11 @@
-import { CallSpec, Plugin, RegexScannerSpec, ScanResult, UsageCandidate } from "@x18n/core";
-import { Node } from "oxc-parser";
-//#region src/scanners/js.d.ts
-/** `a.b.c` for identifier and member chains, `this.` dropped; undefined for anything else. */
-export declare function calleeName(node: Node): string | undefined;
-type ParseSync = typeof import("oxc-parser").parseSync;
-/** Loads oxc lazily: native in Node, WASM through the package's browser export. */
-export declare function loadParser(): Promise<ParseSync>;
-interface ScanSourceOptions {
-  readonly calls: readonly CallSpec[];
-  /** Offset of `text` in the file, for embedded code such as Vue `<script>`. */
-  readonly offset?: number;
-  readonly hardStrings?: boolean;
-  /** File name for the parser; picks JS, TS or JSX. */
-  readonly filename: string;
-  /** Parse `text` as one expression (template interpolations). */
-  readonly expression?: boolean;
-  /** Callees whose string arguments are never hard strings (`extract.ignoreCallees`). */
-  readonly ignoreCallees?: readonly string[] | undefined;
-  /** Attributes whose values are text, on top of the built-in ones (`extract.attributes`). */
-  readonly textAttributes?: readonly string[] | undefined;
-}
-export declare function scanSource(parse: ParseSync, text: string, options: ScanSourceOptions): ScanResult;
-/** The AST scanner for JS and TS, driven by call specs (`usage.calls`). */
-export declare function js(): Plugin;
-//#endregion
-//#region src/scanners/regex.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;
+import { ScannerEntry } from "@x18n/core";
+//#region src/scanners/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.
+ * Built-in scanners by id, in scan order. A scanner is a folder: `<name>/entry.ts` holds its extensions and a
+ * `load` for `<name>/index.ts`, imported when a file it scans is first scanned. `regex` is not here: its
+ * extensions come from `usage.regex`, so it is always loaded.
  */
-export declare function regexScopes(pattern: string, id?: string, options?: {
-  readonly as?: "namespace" | "keyPrefix";
-  readonly extensions?: readonly string[];
-  readonly wholeFile?: boolean;
-}): Plugin;
-//#endregion
-//#region src/scanners/svelte.d.ts
-/** Svelte components: `<script>` and template expressions through the `js` scanner. Node only at first. */
-export declare function svelte(): Plugin;
-//#endregion
-//#region src/scanners/vue.d.ts
-/** Vue SFCs: `<script>` through the `js` scanner, template expressions, `v-t`, `<i18n-t keypath>`. */
-export declare function vue(): Plugin;
-//#endregion
-export type { ScanSourceOptions };
+export declare const scanners: {
+  readonly [id: string]: ScannerEntry;
+};
+//#endregion

package/dist/scanners.mjs

@@ -1,4 +1,36 @@
-import { a as js, n as vue, o as loadParser, r as calleeName, s as scanSource } from "./vue-CF4pe-Yr.mjs";
-import { i as scanWithRegex, n as regex, r as regexScopes, t as compileUsagePattern } from "./regex-AYVhuSb6.mjs";
-import { t as svelte } from "./scanners-DhnnVp7s.mjs";
-export { calleeName, compileUsagePattern, js, loadParser, regex, regexScopes, scanSource, scanWithRegex, svelte, vue };
+//#endregion
+//#region src/scanners/index.ts
+/**
+* Built-in scanners by id, in scan order. A scanner is a folder: `<name>/entry.ts` holds its extensions and a
+* `load` for `<name>/index.ts`, imported when a file it scans is first scanned. `regex` is not here: its
+* extensions come from `usage.regex`, so it is always loaded.
+*/
+const scanners = {
+	js: {
+		extensions: [
+			"js",
+			"jsx",
+			"mjs",
+			"cjs",
+			"ts",
+			"tsx",
+			"mts",
+			"cts"
+		],
+		load: () => import("./scanners/js.mjs")
+	},
+	vue: {
+		extensions: ["vue"],
+		load: () => import("./scanners/vue.mjs")
+	},
+	svelte: {
+		extensions: ["svelte"],
+		load: () => import("./scanners/svelte.mjs")
+	},
+	astro: {
+		extensions: ["astro"],
+		load: () => import("./scanners/astro.mjs")
+	}
+};
+//#endregion
+export { scanners };

package/dist/sfc-blocks-DaGKDZsb.mjs

@@ -0,0 +1,213 @@
+import json from "./formats/json.mjs";
+import json5 from "./formats/json5.mjs";
+import yaml from "./formats/yaml.mjs";
+import { t as loadVueCompiler } from "./vue-compiler-0sfLIiiL.mjs";
+import { isMessageLeaf, pathId } from "@x18n/core";
+//#region src/finders/sfc-blocks.ts
+const formatOfLang = {
+	json: "json",
+	json5: "json5",
+	yaml: "yaml",
+	yml: "yaml"
+};
+/** A format for blocks that hold every locale (`{ "en": {...}, "de": {...} }`): each resource sees its locale's subtree. */
+function localeRoot(base) {
+	return {
+		id: `sfc-${base.id}`,
+		extensions: [],
+		parse(text, ctx) {
+			const parsed = base.parse(text, ctx);
+			const subtree = parsed.tree[ctx.locale];
+			const tree = subtree && !isMessageLeaf(subtree) ? subtree : {};
+			const ranges = /* @__PURE__ */ new Map();
+			const prefix = `${pathId([ctx.locale])}\u0000`;
+			for (const [id, range] of parsed.ranges ?? []) if (id.startsWith(prefix)) ranges.set(id.slice(prefix.length), range);
+			return {
+				tree,
+				ranges
+			};
+		},
+		edit: base.edit ? (text, ops, ctx) => base.edit(text, ops.map((op) => ({
+			...op,
+			path: [ctx.locale, ...op.path]
+		})), ctx) : void 0
+	};
+}
+/** Resolves `src` against the SFC's folder (builtins have no `node:path`); undefined above the project root. */
+function resolveSrc(from, src) {
+	const parts = src.startsWith("/") ? [] : from.split("/").slice(0, -1);
+	for (const part of src.split("/")) if (part === "..") {
+		if (parts.pop() === void 0) return void 0;
+	} else if (part && part !== ".") parts.push(part);
+	return parts.join("/");
+}
+/** The file and lang of a `src` block, if one of the block formats can read it; a `.js` or `.ts` file is not parsed as JSON. */
+function srcFile(from, src, lang) {
+	const path = resolveSrc(from, src);
+	if (path === void 0) return void 0;
+	const fileLang = lang ?? path.slice(path.lastIndexOf(".") + 1);
+	return Object.hasOwn(formatOfLang, fileLang) ? {
+		path,
+		lang: fileLang
+	} : void 0;
+}
+/** One resource per locale of a block: its `locale` attribute, or every top-level key. */
+function blockResources(bases, i18n, sourceLocale) {
+	const { path, locale, block } = i18n;
+	const base = bases.find((f) => f.id === (formatOfLang[block.lang ?? "json"] ?? "json"));
+	if (locale) return [{
+		path,
+		locale,
+		namespace: void 0,
+		format: base.id,
+		block: i18n.src ? void 0 : block
+	}];
+	try {
+		return Object.keys(base.parse(i18n.content, {
+			path,
+			locale: "",
+			namespace: void 0,
+			indent: void 0
+		}).tree).map((locale, i) => ({
+			path,
+			locale,
+			namespace: void 0,
+			format: `sfc-${base.id}`,
+			block: {
+				...block,
+				index: block.index * 1e3 + i
+			}
+		}));
+	} catch {
+		return [{
+			path,
+			locale: sourceLocale,
+			namespace: void 0,
+			format: `sfc-${base.id}`,
+			block
+		}];
+	}
+}
+/**
+* Vue `<i18n>` blocks: one resource per block and locale (`locale="en"`, or every top-level locale key).
+* A block with `src` is a resource in the referenced file, so edits go there.
+*/
+function sfcBlocks() {
+	const bases = [
+		json(),
+		json5(),
+		yaml()
+	].flatMap((plugin) => plugin.formats ?? []);
+	return {
+		name: "x18n:finder-sfc-blocks",
+		formats: bases.map(localeRoot),
+		localeFinders: [{
+			id: "sfc-blocks",
+			async find(ctx) {
+				const files = await ctx.host.glob(["**/*.vue"], {
+					ignore: ctx.config.usage.exclude,
+					gitignore: true
+				});
+				const { parse } = await loadVueCompiler();
+				const out = [];
+				const sources = /* @__PURE__ */ new Set();
+				for (const path of files) {
+					const text = await ctx.host.readFile(path);
+					if (!text?.includes("<i18n")) continue;
+					const { descriptor } = parse(text, {
+						filename: path,
+						sourceMap: false
+					});
+					for (const [index, { type, attrs, content, loc }] of descriptor.customBlocks.entries()) {
+						if (type !== "i18n") continue;
+						const lang = typeof attrs.lang === "string" ? attrs.lang : void 0;
+						const locale = typeof attrs.locale === "string" ? attrs.locale : void 0;
+						if (typeof attrs.src !== "string") {
+							out.push(...blockResources(bases, {
+								path,
+								content,
+								locale,
+								block: {
+									index,
+									range: {
+										start: loc.start.offset,
+										end: loc.end.offset
+									},
+									lang: lang ?? "json"
+								},
+								src: false
+							}, ctx.config.sourceLocale));
+							continue;
+						}
+						const src = srcFile(path, attrs.src, lang);
+						const srcText = !src || sources.has(src.path) ? void 0 : await ctx.host.readFile(src.path);
+						if (!src || srcText === void 0) continue;
+						sources.add(src.path);
+						const block = {
+							index,
+							range: {
+								start: 0,
+								end: srcText.length
+							},
+							lang: src.lang
+						};
+						out.push(...blockResources(bases, {
+							path: src.path,
+							content: srcText,
+							locale,
+							block,
+							src: true
+						}, ctx.config.sourceLocale));
+					}
+				}
+				return out;
+			}
+		}]
+	};
+}
+/** fluent-vue `<fluent locale="en">` blocks in Vue SFCs, read with the `ftl` format. */
+function sfcFluentBlocks() {
+	return {
+		name: "x18n:finder-sfc-fluent-blocks",
+		localeFinders: [{
+			id: "sfc-fluent-blocks",
+			async find(ctx) {
+				const files = await ctx.host.glob(["**/*.vue"], {
+					ignore: ctx.config.usage.exclude,
+					gitignore: true
+				});
+				const { parse } = await loadVueCompiler();
+				const out = [];
+				for (const path of files) {
+					const text = await ctx.host.readFile(path);
+					if (!text?.includes("<fluent")) continue;
+					parse(text, {
+						filename: path,
+						sourceMap: false
+					}).descriptor.customBlocks.forEach((block, index) => {
+						if (block.type === "fluent" && typeof block.attrs.locale === "string") {
+							const range = {
+								start: block.loc.start.offset,
+								end: block.loc.end.offset
+							};
+							out.push({
+								path,
+								locale: block.attrs.locale,
+								namespace: void 0,
+								format: "ftl",
+								block: {
+									index,
+									range,
+									lang: "ftl"
+								}
+							});
+						}
+					});
+				}
+				return out;
+			}
+		}]
+	};
+}
+//#endregion
+export { sfcFluentBlocks as n, sfcBlocks as t };

package/dist/shared-C7ceptwi.mjs

@@ -0,0 +1,55 @@
+//#region src/formats/shared/index.ts
+/** One indent level: the configured one, else the file's first indented line, else `fallback`. */
+function indentUnit(text, indent, fallback) {
+	if (indent !== void 0) return indent === "tab" ? "	" : " ".repeat(indent);
+	return /^([ \t]+)\S/m.exec(text)?.[1] ?? fallback;
+}
+function detectEol(text) {
+	return text.includes("\r\n") ? "\r\n" : "\n";
+}
+function toLeaf(value) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (value instanceof Date) return value.toISOString();
+}
+function leafText(value) {
+	return value === null ? "" : String(value);
+}
+function splice(text, range, insert) {
+	return text.slice(0, range.start) + insert + text.slice(range.end);
+}
+/** Appends `chunk` on a line of its own, in the file's line endings. */
+function appendLines(text, chunk) {
+	const eol = detectEol(text);
+	return (text === "" || text.endsWith("\n") ? text : text + eol) + chunk.replace(/\n/g, eol);
+}
+function splitLines(text) {
+	const out = [];
+	let start = 0;
+	while (start < text.length) {
+		const lf = text.indexOf("\n", start);
+		const next = lf === -1 ? text.length : lf + 1;
+		const end = lf === -1 ? text.length : lf > start && text[lf - 1] === "\r" ? lf - 1 : lf;
+		out.push({
+			start,
+			end,
+			next
+		});
+		start = next;
+	}
+	return out;
+}
+/** An entry's range widened to swallow the blank lines that separate it, so deleting it leaves one separator. */
+function withBlankLines(text, range) {
+	const after = /^(?:[ \t]*\r?\n)*(?:[ \t]*$)?/.exec(text.slice(range.end))[0].length;
+	if (range.end + after < text.length) return {
+		start: range.start,
+		end: range.end + after
+	};
+	const before = /(?<=\n)(?:[ \t]*\r?\n)+$/.exec(text.slice(0, range.start))?.[0].length ?? 0;
+	return {
+		start: range.start - before,
+		end: text.length
+	};
+}
+//#endregion
+export { splice as a, withBlankLines as c, leafText as i, detectEol as n, splitLines as o, indentUnit as r, toLeaf as s, appendLines as t };

package/dist/shared-D-tbsYmc.mjs

@@ -0,0 +1,30 @@
+//#region src/reporters/shared/index.ts
+const codes = {
+	red: 31,
+	yellow: 33,
+	cyan: 36,
+	gray: 90,
+	blue: 34,
+	bold: 1
+};
+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
+	});
+}
+//#endregion
+export { totals as i, paint as n, plural as r, codes as t };

package/dist/shared-D4NJBKEP.mjs

@@ -0,0 +1,17 @@
+//#region src/presets/shared/index.ts
+function dependsOn(names, prefixes = []) {
+	return (ctx) => ctx.hasAnyDependency(names) || [...ctx.dependencies].some((dep) => prefixes.some((prefix) => dep.startsWith(prefix)));
+}
+/** Extensions of JS and TS sources. */
+const scriptExtensions = [
+	"js",
+	"jsx",
+	"mjs",
+	"cjs",
+	"ts",
+	"tsx",
+	"mts",
+	"cts"
+];
+//#endregion
+export { scriptExtensions as n, dependsOn as t };

package/dist/shared-Tq06G0gp.mjs

@@ -0,0 +1,6 @@
+//#region src/presets/nuxt-i18n/shared.ts
+async function readNuxtConfig(host) {
+	return await host.readFile("nuxt.config.ts") ?? await host.readFile("nuxt.config.js");
+}
+//#endregion
+export { readNuxtConfig as t };