@generaltranslation/vue-extractor 0.0.0

package/dist/internal/types.d.ts

@@ -0,0 +1,69 @@
+import type { VueExtractionResult } from '../types.js';
+import type { ImplicitSlotWhitespace } from './vueCompiler.js';
+export type GTComponentName = 'T' | 'Var' | 'Num' | 'DateTime' | 'Currency' | 'Plural' | 'Branch';
+/** Vue builtins whose runtime identity changes rich-content traversal. */
+export type VueBuiltinName = 'Fragment' | 'Suspense';
+export type StringFunctionKind = 'gt' | 'messages' | 'msg';
+export type TemplateContainerKind = 'array' | 'object';
+export type TemplateBindings = {
+    /** Lengths of statically known, non-mutated array paths. */
+    arrayLengths: Map<string, number>;
+    /** Callable bindings that may return a GT or Vue component identity. */
+    componentFactories: Set<string>;
+    components: Map<string, GTComponentName>;
+    /** Statically known container paths available to template expressions. */
+    containerKinds: Map<string, TemplateContainerKind>;
+    /** Container paths whose immediate runtime value may be a GT component. */
+    possibleGTContainers: Set<string>;
+    /** Callable paths whose returned container may directly contain `<T>`. */
+    gtContainerFactories: Set<string>;
+    /** Program bindings whose identity takes precedence over registrations. */
+    directBindings: Set<string>;
+    /** GT identities registered through an Options API `components` object. */
+    registeredComponents: Map<string, GTComponentName>;
+    /** Vue builtin identities registered through an Options API object. */
+    registeredVueBuiltins: Map<string, VueBuiltinName>;
+    staticValues: Map<string, string | number | bigint | boolean | null>;
+    /** Vue identity helpers such as `markRaw`. */
+    identityFunctions: Set<string>;
+    /** Statically visible string alternatives for non-singleton expressions. */
+    possibleStaticStrings: Map<string, Set<string>>;
+    stringFunctions: Map<string, StringFunctionKind>;
+    /** Callable aliases that may resolve to a gt-vue string function. */
+    uncertainStringFunctions: Set<string>;
+    /** Component aliases whose runtime identity escaped static analysis. */
+    uncertainComponents: Set<string>;
+    /** Direct aliases that can specifically resolve to a GT component. */
+    uncertainGTComponents: Set<string>;
+    /** Callable bindings that may specifically return a GT component. */
+    gtComponentFactories: Set<string>;
+    /** Uncertain identities originating in an Options API registration. */
+    uncertainRegisteredComponents: Set<string>;
+    /** Uncertain GT identities originating in an Options API registration. */
+    uncertainRegisteredGTComponents: Set<string>;
+    /** Statically proven local aliases of Vue builtins. */
+    vueBuiltins: Map<string, VueBuiltinName>;
+};
+export type ExtractionPosition = {
+    line: number;
+    column: number;
+    offset: number;
+};
+export type ExtractionLocation = {
+    start: ExtractionPosition;
+    end: ExtractionPosition;
+};
+export type VueExtractionContext = {
+    errors: string[];
+    file: string;
+    /** Whitespace predicate used by the resolved consumer Vue compiler. */
+    implicitSlotWhitespace: ImplicitSlotWhitespace;
+    includeSourceCodeContext: boolean;
+    relativeFile: string;
+    results: VueExtractionResult[];
+    source: string;
+    surroundingLineCount: number;
+    /** Variable component nodes whose public shape was already validated. */
+    validatedVariableComponents: WeakSet<object>;
+    warnings: Set<string>;
+};

package/dist/internal/types.js

@@ -0,0 +1 @@
+export {};

package/dist/internal/utils.d.ts

@@ -0,0 +1,19 @@
+import type * as t from '@babel/types';
+import type { VueExtractionResult } from '../types.js';
+import type { ExtractionLocation, VueExtractionContext } from './types.js';
+export declare function createVueExtractionContext(file: string, source: string, projectRoot: string, includeSourceCodeContext: boolean, surroundingLineCount: number, results: VueExtractionResult[], errors: string[], warnings: Set<string>): VueExtractionContext;
+export declare function addVueError(context: VueExtractionContext, location: ExtractionLocation | undefined, whatHappened: string, fix?: string): void;
+export declare function babelLocation(location: t.SourceLocation | null | undefined): ExtractionLocation | undefined;
+export declare function createInlineMetadata(context: VueExtractionContext, location: ExtractionLocation | undefined, translationContext?: string): VueExtractionResult['metadata'];
+export type StaticPrimitive = string | number | bigint | boolean | null;
+export type StaticPrimitiveResult = {
+    ok: true;
+    value: StaticPrimitive;
+} | {
+    ok: false;
+};
+export type StaticIdentifierResolver = (identifier: t.Identifier) => StaticPrimitiveResult;
+/** Removes syntax-only TypeScript, Flow, and parenthesis wrappers. */
+export declare function unwrapExpression(input: t.Node | null | undefined): t.Node | undefined;
+/** Evaluates the side-effect-free primitive subset supported by extraction. */
+export declare function readStaticPrimitive(input: t.Node | null | undefined, resolveIdentifier?: StaticIdentifierResolver): StaticPrimitiveResult;

package/dist/internal/utils.js

@@ -0,0 +1,149 @@
+import path from "node:path";
+import { createDiagnosticMessage } from "generaltranslation/internal";
+//#region src/internal/utils.ts
+function createVueExtractionContext(file, source, projectRoot, includeSourceCodeContext, surroundingLineCount, results, errors, warnings) {
+	return {
+		errors,
+		file,
+		implicitSlotWhitespace: "ecmascript",
+		includeSourceCodeContext,
+		relativeFile: path.relative(projectRoot, file),
+		results,
+		source,
+		surroundingLineCount,
+		validatedVariableComponents: /* @__PURE__ */ new WeakSet(),
+		warnings
+	};
+}
+function addVueError(context, location, whatHappened, fix) {
+	const position = location ? ` (${location.start.line}:${location.start.column})` : "";
+	context.errors.push(`${context.file}${position}: ${createDiagnosticMessage({
+		whatHappened,
+		fix
+	})}`);
+}
+function babelLocation(location) {
+	if (!location) return void 0;
+	return {
+		start: {
+			line: location.start.line,
+			column: location.start.column + 1,
+			offset: location.start.index ?? 0
+		},
+		end: {
+			line: location.end.line,
+			column: location.end.column + 1,
+			offset: location.end.index ?? 0
+		}
+	};
+}
+function createInlineMetadata(context, location, translationContext) {
+	const metadata = {
+		...translationContext !== void 0 && { context: translationContext },
+		...context.relativeFile && { filePaths: [context.relativeFile] }
+	};
+	if (context.includeSourceCodeContext && context.relativeFile && location?.start.line && location.end.line) {
+		const sourceCode = extractSourceCode(context.source, location.start.line, location.end.line, context.surroundingLineCount);
+		if (sourceCode) metadata.sourceCode = { [context.relativeFile]: [sourceCode] };
+	}
+	return metadata;
+}
+/** Extracts source lines around a 1-based line range. */
+function extractSourceCode(source, startLine, endLine, surroundingLineCount) {
+	const lines = source.split("\n");
+	if (lines.length === 0) return void 0;
+	const targetStart = Math.max(0, startLine - 1);
+	const targetEnd = Math.min(lines.length - 1, endLine - 1);
+	if (targetStart > targetEnd) return void 0;
+	return {
+		before: lines.slice(Math.max(0, targetStart - surroundingLineCount), targetStart).join("\n"),
+		target: lines.slice(targetStart, targetEnd + 1).join("\n"),
+		after: lines.slice(targetEnd + 1, targetEnd + 1 + surroundingLineCount).join("\n")
+	};
+}
+/** Removes syntax-only TypeScript, Flow, and parenthesis wrappers. */
+function unwrapExpression(input) {
+	let current = input ?? void 0;
+	while (current && (current.type === "TSAsExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSInstantiationExpression" || current.type === "TypeCastExpression" || current.type === "ParenthesizedExpression")) current = current.expression;
+	return current;
+}
+/** Evaluates the side-effect-free primitive subset supported by extraction. */
+function readStaticPrimitive(input, resolveIdentifier) {
+	const expression = unwrapExpression(input);
+	if (!expression) return { ok: false };
+	if (expression.type === "Identifier" && resolveIdentifier) return resolveIdentifier(expression);
+	if (expression.type === "StringLiteral") return {
+		ok: true,
+		value: expression.value
+	};
+	if (expression.type === "NumericLiteral") return {
+		ok: true,
+		value: expression.value
+	};
+	if (expression.type === "BigIntLiteral") try {
+		return {
+			ok: true,
+			value: BigInt(expression.value)
+		};
+	} catch {
+		return { ok: false };
+	}
+	if (expression.type === "BooleanLiteral") return {
+		ok: true,
+		value: expression.value
+	};
+	if (expression.type === "NullLiteral") return {
+		ok: true,
+		value: null
+	};
+	if (expression.type === "TemplateLiteral") {
+		const firstQuasi = expression.quasis[0]?.value.cooked;
+		if (firstQuasi == null) return { ok: false };
+		let value = firstQuasi;
+		for (let index = 0; index < expression.expressions.length; index += 1) {
+			const interpolation = readStaticPrimitive(expression.expressions[index], resolveIdentifier);
+			if (!interpolation.ok) return { ok: false };
+			value += String(interpolation.value);
+			const quasi = expression.quasis[index + 1]?.value.cooked;
+			if (quasi == null) return { ok: false };
+			value += quasi;
+		}
+		return {
+			ok: true,
+			value
+		};
+	}
+	if (expression.type === "BinaryExpression" && expression.operator === "+") {
+		const left = readStaticPrimitive(expression.left, resolveIdentifier);
+		const right = readStaticPrimitive(expression.right, resolveIdentifier);
+		if (!left.ok || !right.ok) return { ok: false };
+		if (typeof left.value === "string" || typeof right.value === "string") return {
+			ok: true,
+			value: String(left.value) + String(right.value)
+		};
+		if (typeof left.value === "bigint" || typeof right.value === "bigint") return typeof left.value === "bigint" && typeof right.value === "bigint" ? {
+			ok: true,
+			value: left.value + right.value
+		} : { ok: false };
+		return {
+			ok: true,
+			value: Number(left.value) + Number(right.value)
+		};
+	}
+	if (expression.type === "UnaryExpression" && (expression.operator === "+" || expression.operator === "-")) {
+		const argument = readStaticPrimitive(expression.argument, resolveIdentifier);
+		if (argument.ok && typeof argument.value === "number") return {
+			ok: true,
+			value: expression.operator === "-" ? -argument.value : argument.value
+		};
+		if (argument.ok && typeof argument.value === "bigint") return expression.operator === "-" ? {
+			ok: true,
+			value: -argument.value
+		} : { ok: false };
+	}
+	return { ok: false };
+}
+//#endregion
+export { addVueError, babelLocation, createInlineMetadata, createVueExtractionContext, readStaticPrimitive, unwrapExpression };
+
+//# sourceMappingURL=utils.js.map

package/dist/internal/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/internal/utils.ts"],"sourcesContent":["import path from 'node:path';\nimport type * as t from '@babel/types';\nimport { createDiagnosticMessage } from 'generaltranslation/internal';\nimport type { VueExtractionResult, VueSourceCode } from '../types.js';\nimport type { ExtractionLocation, VueExtractionContext } from './types.js';\n\nexport function createVueExtractionContext(\n  file: string,\n  source: string,\n  projectRoot: string,\n  includeSourceCodeContext: boolean,\n  surroundingLineCount: number,\n  results: VueExtractionResult[],\n  errors: string[],\n  warnings: Set<string>\n): VueExtractionContext {\n  return {\n    errors,\n    file,\n    // Script-only extraction never reads this field. Vue SFC extraction\n    // replaces it with the resolved consumer compiler's behavior before\n    // traversing the template.\n    implicitSlotWhitespace: 'ecmascript',\n    includeSourceCodeContext,\n    relativeFile: path.relative(projectRoot, file),\n    results,\n    source,\n    surroundingLineCount,\n    validatedVariableComponents: new WeakSet(),\n    warnings,\n  };\n}\n\nexport function addVueError(\n  context: VueExtractionContext,\n  location: ExtractionLocation | undefined,\n  whatHappened: string,\n  fix?: string\n): void {\n  const position = location\n    ? ` (${location.start.line}:${location.start.column})`\n    : '';\n  context.errors.push(\n    `${context.file}${position}: ${createDiagnosticMessage({ whatHappened, fix })}`\n  );\n}\n\nexport function babelLocation(\n  location: t.SourceLocation | null | undefined\n): ExtractionLocation | undefined {\n  if (!location) return undefined;\n  return {\n    start: {\n      line: location.start.line,\n      column: location.start.column + 1,\n      offset: location.start.index ?? 0,\n    },\n    end: {\n      line: location.end.line,\n      column: location.end.column + 1,\n      offset: location.end.index ?? 0,\n    },\n  };\n}\n\nexport function createInlineMetadata(\n  context: VueExtractionContext,\n  location: ExtractionLocation | undefined,\n  translationContext?: string\n): VueExtractionResult['metadata'] {\n  const metadata: VueExtractionResult['metadata'] = {\n    ...(translationContext !== undefined && { context: translationContext }),\n    ...(context.relativeFile && { filePaths: [context.relativeFile] }),\n  };\n\n  if (\n    context.includeSourceCodeContext &&\n    context.relativeFile &&\n    location?.start.line &&\n    location.end.line\n  ) {\n    const sourceCode = extractSourceCode(\n      context.source,\n      location.start.line,\n      location.end.line,\n      context.surroundingLineCount\n    );\n    if (sourceCode) {\n      metadata.sourceCode = { [context.relativeFile]: [sourceCode] };\n    }\n  }\n\n  return metadata;\n}\n\n/** Extracts source lines around a 1-based line range. */\nfunction extractSourceCode(\n  source: string,\n  startLine: number,\n  endLine: number,\n  surroundingLineCount: number\n): VueSourceCode | undefined {\n  const lines = source.split('\\n');\n  if (lines.length === 0) return undefined;\n\n  const targetStart = Math.max(0, startLine - 1);\n  const targetEnd = Math.min(lines.length - 1, endLine - 1);\n  if (targetStart > targetEnd) return undefined;\n\n  return {\n    before: lines\n      .slice(Math.max(0, targetStart - surroundingLineCount), targetStart)\n      .join('\\n'),\n    target: lines.slice(targetStart, targetEnd + 1).join('\\n'),\n    after: lines\n      .slice(targetEnd + 1, targetEnd + 1 + surroundingLineCount)\n      .join('\\n'),\n  };\n}\n\nexport type StaticPrimitive = string | number | bigint | boolean | null;\nexport type StaticPrimitiveResult =\n  | { ok: true; value: StaticPrimitive }\n  | { ok: false };\nexport type StaticIdentifierResolver = (\n  identifier: t.Identifier\n) => StaticPrimitiveResult;\n\n/** Removes syntax-only TypeScript, Flow, and parenthesis wrappers. */\nexport function unwrapExpression(\n  input: t.Node | null | undefined\n): t.Node | undefined {\n  let current = input ?? undefined;\n  while (\n    current &&\n    (current.type === 'TSAsExpression' ||\n      current.type === 'TSTypeAssertion' ||\n      current.type === 'TSNonNullExpression' ||\n      current.type === 'TSSatisfiesExpression' ||\n      current.type === 'TSInstantiationExpression' ||\n      current.type === 'TypeCastExpression' ||\n      current.type === 'ParenthesizedExpression')\n  ) {\n    current = current.expression;\n  }\n  return current;\n}\n\n/** Evaluates the side-effect-free primitive subset supported by extraction. */\nexport function readStaticPrimitive(\n  input: t.Node | null | undefined,\n  resolveIdentifier?: StaticIdentifierResolver\n): StaticPrimitiveResult {\n  const expression = unwrapExpression(input);\n  if (!expression) return { ok: false };\n  if (expression.type === 'Identifier' && resolveIdentifier) {\n    return resolveIdentifier(expression);\n  }\n  if (expression.type === 'StringLiteral') {\n    return { ok: true, value: expression.value };\n  }\n  if (expression.type === 'NumericLiteral') {\n    return { ok: true, value: expression.value };\n  }\n  if (expression.type === 'BigIntLiteral') {\n    try {\n      return { ok: true, value: BigInt(expression.value) };\n    } catch {\n      return { ok: false };\n    }\n  }\n  if (expression.type === 'BooleanLiteral') {\n    return { ok: true, value: expression.value };\n  }\n  if (expression.type === 'NullLiteral') {\n    return { ok: true, value: null };\n  }\n  if (expression.type === 'TemplateLiteral') {\n    const firstQuasi = expression.quasis[0]?.value.cooked;\n    // Executable, untagged template literals always have cooked values.\n    // Missing cooked data belongs to malformed or tagged-template ASTs and\n    // must fail closed instead of being interpreted with different raw-text\n    // semantics.\n    if (firstQuasi == null) return { ok: false };\n    let value = firstQuasi;\n    for (let index = 0; index < expression.expressions.length; index += 1) {\n      const interpolation = readStaticPrimitive(\n        expression.expressions[index],\n        resolveIdentifier\n      );\n      if (!interpolation.ok) return { ok: false };\n      value += String(interpolation.value);\n      const quasi = expression.quasis[index + 1]?.value.cooked;\n      if (quasi == null) return { ok: false };\n      value += quasi;\n    }\n    return { ok: true, value };\n  }\n  if (expression.type === 'BinaryExpression' && expression.operator === '+') {\n    const left = readStaticPrimitive(expression.left, resolveIdentifier);\n    const right = readStaticPrimitive(expression.right, resolveIdentifier);\n    if (!left.ok || !right.ok) return { ok: false };\n    if (typeof left.value === 'string' || typeof right.value === 'string') {\n      return { ok: true, value: String(left.value) + String(right.value) };\n    }\n    if (typeof left.value === 'bigint' || typeof right.value === 'bigint') {\n      return typeof left.value === 'bigint' && typeof right.value === 'bigint'\n        ? { ok: true, value: left.value + right.value }\n        : { ok: false };\n    }\n    return { ok: true, value: Number(left.value) + Number(right.value) };\n  }\n  if (\n    expression.type === 'UnaryExpression' &&\n    (expression.operator === '+' || expression.operator === '-')\n  ) {\n    const argument = readStaticPrimitive(\n      expression.argument,\n      resolveIdentifier\n    );\n    if (argument.ok && typeof argument.value === 'number') {\n      return {\n        ok: true,\n        value: expression.operator === '-' ? -argument.value : argument.value,\n      };\n    }\n    if (argument.ok && typeof argument.value === 'bigint') {\n      return expression.operator === '-'\n        ? { ok: true, value: -argument.value }\n        : { ok: false };\n    }\n  }\n  return { ok: false };\n}\n"],"mappings":"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"}

package/dist/internal/vueCompiler.d.ts

@@ -0,0 +1,35 @@
+import type { parse as parseVueTemplate } from '@vue/compiler-dom';
+import type * as VueCompilerModule from '@vue/compiler-sfc';
+import type { TemplateCompiler } from '@vue/compiler-sfc';
+import type { VueCompiler } from '../types.js';
+/** Whitespace test used by Vue when it constructs an implicit default slot. */
+export type ImplicitSlotWhitespace = 'ecmascript' | 'html';
+export type ResolvedVueCompiler = {
+    compiler: ExactVueCompiler;
+    implicitSlotWhitespace: ImplicitSlotWhitespace;
+    parseTemplate?: typeof parseVueTemplate;
+    templateCompiler?: TemplateCompiler;
+    templateParseOptionsSupported: boolean;
+    version: string;
+};
+type CompilerResolution = {
+    ok: true;
+    value: ResolvedVueCompiler;
+} | {
+    ok: false;
+    details: string;
+};
+type ExactVueCompiler = Pick<typeof VueCompilerModule, 'compileTemplate' | 'parse' | 'version'> & {
+    parseTemplate?: typeof parseVueTemplate;
+};
+/**
+ * Resolves the exact Vue compiler selected by the consuming source file.
+ *
+ * The `vue/compiler-sfc` export is version-locked to that installation's Vue
+ * runtime. Resolving from the SFC first is important in workspaces where apps
+ * intentionally use different Vue versions.
+ */
+export declare function resolveVueCompiler(file: string, projectRoot: string): CompilerResolution;
+/** Validates an explicitly supplied compiler before extraction uses it. */
+export declare function inspectVueCompiler(compiler: VueCompiler): CompilerResolution;
+export {};

package/dist/internal/vueCompiler.js

@@ -0,0 +1,320 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/internal/vueCompiler.ts
+const resolvedCompilers = /* @__PURE__ */ new Map();
+const inspectedCompilers = /* @__PURE__ */ new WeakMap();
+/**
+* Resolves the exact Vue compiler selected by the consuming source file.
+*
+* The `vue/compiler-sfc` export is version-locked to that installation's Vue
+* runtime. Resolving from the SFC first is important in workspaces where apps
+* intentionally use different Vue versions.
+*/
+function resolveVueCompiler(file, projectRoot) {
+	const absoluteFile = path.isAbsolute(file) ? file : path.resolve(projectRoot, file);
+	const anchors = [absoluteFile, path.join(projectRoot, "package.json")];
+	for (const anchor of anchors) {
+		const requireFromConsumer = createRequire(anchor);
+		let vueManifestPath;
+		try {
+			vueManifestPath = requireFromConsumer.resolve("vue/package.json");
+		} catch (error) {
+			if (isMissingModule(error)) continue;
+			return {
+				ok: false,
+				details: formatResolutionError(error)
+			};
+		}
+		let compilerPath;
+		try {
+			compilerPath = requireFromConsumer.resolve("vue/compiler-sfc");
+		} catch (error) {
+			return {
+				ok: false,
+				details: `Resolved the app's Vue package at ${vueManifestPath}, but its compiler-sfc export could not be loaded: ${formatResolutionError(error)}`
+			};
+		}
+		const cached = resolvedCompilers.get(compilerPath);
+		if (cached) return cached;
+		const resolution = loadCompiler(requireFromConsumer, compilerPath, vueManifestPath, readVueVersion(requireFromConsumer, vueManifestPath));
+		resolvedCompilers.set(compilerPath, resolution);
+		return resolution;
+	}
+	const declaredVersion = findDeclaredVueVersion(absoluteFile, projectRoot);
+	if (declaredVersion) return {
+		ok: false,
+		details: `The project declares Vue ${JSON.stringify(declaredVersion)} but vue/compiler-sfc could not be resolved from ${absoluteFile}.`
+	};
+	return {
+		ok: false,
+		details: `Could not resolve vue/compiler-sfc from ${absoluteFile}.`
+	};
+}
+/** Validates an explicitly supplied compiler before extraction uses it. */
+function inspectVueCompiler(compiler) {
+	if (!compiler || typeof compiler !== "object") return {
+		ok: false,
+		details: "The supplied Vue compiler is not an object."
+	};
+	const cached = inspectedCompilers.get(compiler);
+	if (cached) return cached;
+	const exactCompiler = compiler;
+	const resolution = isVueCompiler(compiler) ? inspectCompiler(exactCompiler, exactCompiler.parseTemplate) : {
+		ok: false,
+		details: "The supplied object does not expose the Vue compiler-sfc API."
+	};
+	inspectedCompilers.set(compiler, resolution);
+	return resolution;
+}
+function loadCompiler(requireFromConsumer, compilerPath, vueManifestPath, vueVersion) {
+	try {
+		const loaded = requireFromConsumer(compilerPath);
+		const defaultExport = readDefaultExport(loaded);
+		const compiler = isVueCompiler(loaded) ? loaded : isVueCompiler(defaultExport) ? defaultExport : void 0;
+		if (!compiler) return {
+			ok: false,
+			details: `The module at ${compilerPath} does not expose the Vue compiler-sfc API.`
+		};
+		if (vueVersion && compiler.version !== vueVersion) return {
+			ok: false,
+			details: `The app resolves Vue ${vueVersion} but vue/compiler-sfc ${compiler.version}. Install one matching Vue package version.`
+		};
+		if (!isSupportedVueVersion(compiler.version)) return {
+			ok: false,
+			details: `Resolved Vue compiler version ${JSON.stringify(compiler.version)}; gt-vue supports Vue 3.3 through Vue 3.x.`
+		};
+		const requireFromCompiler = createRequire(compilerPath);
+		const compilerDomPath = requireFromCompiler.resolve("@vue/compiler-dom");
+		const compilerDom = requireFromCompiler(compilerDomPath);
+		const compilerDomVersion = readVueVersion(requireFromCompiler, requireFromCompiler.resolve("@vue/compiler-dom/package.json"));
+		if (compilerDomVersion !== compiler.version) return {
+			ok: false,
+			details: `vue/compiler-sfc ${compiler.version} resolves @vue/compiler-dom ${String(compilerDomVersion)}. Install matching Vue compiler packages.`
+		};
+		if (typeof compilerDom.parse !== "function") return {
+			ok: false,
+			details: `The template compiler at ${compilerDomPath} does not expose parse().`
+		};
+		if (typeof compilerDom.compile !== "function") return {
+			ok: false,
+			details: `The template compiler at ${compilerDomPath} does not expose compile().`
+		};
+		return inspectCompiler(compiler, compilerDom.parse, {
+			compile: compilerDom.compile,
+			parse: compilerDom.parse
+		});
+	} catch (error) {
+		const bunResolution = loadBunCompiler(requireFromConsumer, vueManifestPath, vueVersion);
+		if (bunResolution) return bunResolution;
+		return {
+			ok: false,
+			details: formatResolutionError(error)
+		};
+	}
+}
+/** Loads exact, self-contained Vue browser compilers in a compiled Bun CLI. */
+function loadBunCompiler(requireFromConsumer, vueManifestPath, vueVersion) {
+	if (typeof process.versions.bun !== "string") return void 0;
+	try {
+		const compilerSfcRoot = findInstalledPackageRoot(vueManifestPath, "@vue/compiler-sfc");
+		const compilerDomRoot = findInstalledPackageRoot(vueManifestPath, "@vue/compiler-dom");
+		if (!compilerSfcRoot || !compilerDomRoot) return {
+			ok: false,
+			details: "The Vue installation does not contain its compiler-sfc and compiler-dom dependencies."
+		};
+		const compilerPath = path.join(compilerSfcRoot, "dist/compiler-sfc.esm-browser.js");
+		const compilerDomPath = path.join(compilerDomRoot, "dist/compiler-dom.esm-browser.js");
+		const loaded = requireFromConsumer(compilerPath);
+		const defaultExport = readDefaultExport(loaded);
+		const compiler = isVueCompiler(loaded) ? loaded : isVueCompiler(defaultExport) ? defaultExport : void 0;
+		if (!compiler) return {
+			ok: false,
+			details: `The module at ${compilerPath} does not expose the Vue compiler-sfc API.`
+		};
+		if (vueVersion && compiler.version !== vueVersion) return {
+			ok: false,
+			details: `The app resolves Vue ${vueVersion} but vue/compiler-sfc ${compiler.version}. Install one matching Vue package version.`
+		};
+		if (!isSupportedVueVersion(compiler.version)) return {
+			ok: false,
+			details: `Resolved Vue compiler version ${JSON.stringify(compiler.version)}; gt-vue supports Vue 3.3 through Vue 3.x.`
+		};
+		const compilerDom = requireFromConsumer(compilerDomPath);
+		const compilerDomVersion = readPackageVersion(compilerDomRoot);
+		if (compilerDomVersion !== compiler.version) return {
+			ok: false,
+			details: `vue/compiler-sfc ${compiler.version} resolves @vue/compiler-dom ${String(compilerDomVersion)}. Install matching Vue compiler packages.`
+		};
+		if (typeof compilerDom.parse !== "function") return {
+			ok: false,
+			details: `The template compiler at ${compilerDomPath} does not expose parse().`
+		};
+		if (typeof compilerDom.compile !== "function") return {
+			ok: false,
+			details: `The template compiler at ${compilerDomPath} does not expose compile().`
+		};
+		return inspectCompiler(compiler, compilerDom.parse, {
+			compile: compilerDom.compile,
+			parse: compilerDom.parse
+		});
+	} catch (error) {
+		return {
+			ok: false,
+			details: formatResolutionError(error)
+		};
+	}
+}
+/** Finds one dependency relative to the physical Vue installation on disk. */
+function findInstalledPackageRoot(vueManifestPath, packageName) {
+	const packageSegments = packageName.split("/");
+	let directory = path.dirname(vueManifestPath);
+	while (true) {
+		const candidate = path.basename(directory) === "node_modules" ? path.join(directory, ...packageSegments) : path.join(directory, "node_modules", ...packageSegments);
+		if (fs.existsSync(path.join(candidate, "package.json"))) return candidate;
+		const parent = path.dirname(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
+}
+function readPackageVersion(packageRoot) {
+	try {
+		const manifest = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+		return typeof manifest.version === "string" ? manifest.version : void 0;
+	} catch {
+		return;
+	}
+}
+function readVueVersion(requireFromConsumer, manifestPath) {
+	try {
+		const manifest = requireFromConsumer(manifestPath);
+		return typeof manifest.version === "string" ? manifest.version : void 0;
+	} catch {
+		return;
+	}
+}
+/** Finds an installed-but-missing declaration that bundled fallback could hide. */
+function findDeclaredVueVersion(absoluteFile, projectRoot) {
+	const stop = path.resolve(projectRoot);
+	let directory = path.dirname(absoluteFile);
+	while (true) {
+		const version = readDeclaredVueVersion(path.join(directory, "package.json"));
+		if (version) return version;
+		if (directory === stop || directory === path.dirname(directory)) break;
+		directory = path.dirname(directory);
+	}
+	return readDeclaredVueVersion(path.join(stop, "package.json"));
+}
+function readDeclaredVueVersion(manifestPath) {
+	try {
+		const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+		for (const section of [
+			"dependencies",
+			"devDependencies",
+			"peerDependencies",
+			"optionalDependencies"
+		]) {
+			const dependencies = manifest[section];
+			if (dependencies && typeof dependencies === "object" && "vue" in dependencies) {
+				const version = dependencies.vue;
+				return typeof version === "string" ? version : "an unknown version";
+			}
+		}
+	} catch (error) {
+		if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") throw error;
+	}
+}
+function inspectCompiler(compiler, parseTemplate, templateCompiler) {
+	const version = compiler.version;
+	if (!isSupportedVueVersion(version)) return {
+		ok: false,
+		details: `Resolved Vue compiler version ${JSON.stringify(version)}; gt-vue supports Vue 3.3 through Vue 3.x.`
+	};
+	try {
+		const templateParseOptionsSupported = supportsTemplateParseOptions(compiler);
+		if (!parseTemplate && !templateParseOptionsSupported) return {
+			ok: false,
+			details: "The supplied compiler does not expose exact template parser options. Let the extractor resolve vue/compiler-sfc from the consuming app instead."
+		};
+		return {
+			ok: true,
+			value: {
+				compiler,
+				implicitSlotWhitespace: detectImplicitSlotWhitespace(compiler),
+				parseTemplate,
+				templateCompiler,
+				templateParseOptionsSupported,
+				version
+			}
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			details: formatResolutionError(error)
+		};
+	}
+}
+/** Detects the SFC parser option added after Vue 3.4. */
+function supportsTemplateParseOptions(compiler) {
+	const source = "<template><Probe>First\n  second</Probe></template>";
+	const parseText = (whitespace) => {
+		return collectText(compiler.parse(source, { templateParseOptions: { whitespace } }).descriptor.template?.ast);
+	};
+	return parseText("condense") !== parseText("preserve");
+}
+function collectText(value) {
+	if (!value || typeof value !== "object") return "";
+	let output = "";
+	if ("type" in value && value.type === 2 && "content" in value) output += String(value.content);
+	if ("children" in value && Array.isArray(value.children)) for (const child of value.children) output += collectText(child);
+	return output;
+}
+/**
+* Detects the compiler's slot-whitespace semantics instead of inferring them
+* from a semver range. Vue 3.3/3.4 use ECMAScript `trim()`, while Vue 3.5 uses
+* the HTML parser's ASCII whitespace set. A behavior probe remains exact if a
+* later Vue 3.x release backports or revises that implementation.
+*/
+function detectImplicitSlotWhitespace(compiler) {
+	const result = compiler.compileTemplate({
+		filename: "gt-vue-compiler-probe.vue",
+		id: "gt-vue-compiler-probe",
+		source: "<Probe><template #named>x</template>&nbsp;</Probe>"
+	});
+	if (result.errors.length > 0) throw new Error(`The Vue compiler compatibility probe failed: ${result.errors.map(String).join("; ")}`);
+	const component = result.ast?.children.find((node) => typeof node === "object" && node !== null && "tag" in node && node.tag === "Probe");
+	const codegen = component && "codegenNode" in component ? component.codegenNode : void 0;
+	const children = codegen && typeof codegen === "object" && "children" in codegen && codegen.children && typeof codegen.children === "object" ? codegen.children : void 0;
+	const properties = children && "properties" in children && Array.isArray(children.properties) ? children.properties : void 0;
+	if (!properties) throw new Error("The Vue compiler compatibility probe returned an unknown slot AST.");
+	return properties.some((property) => {
+		if (!property || typeof property !== "object" || !("key" in property)) return false;
+		const key = property.key;
+		return key != null && typeof key === "object" && "content" in key && key.content === "default";
+	}) ? "html" : "ecmascript";
+}
+function isVueCompiler(value) {
+	if (!value || typeof value !== "object") return false;
+	return "compileTemplate" in value && typeof value.compileTemplate === "function" && "parse" in value && typeof value.parse === "function" && "version" in value && typeof value.version === "string";
+}
+/** Reads a possible CommonJS-interoperability default export. */
+function readDefaultExport(value) {
+	return value && typeof value === "object" && "default" in value ? value.default : void 0;
+}
+function isSupportedVueVersion(version) {
+	const match = /^(\d+)\.(\d+)(?:\.|$)/.exec(version);
+	if (!match) return false;
+	const major = Number(match[1]);
+	const minor = Number(match[2]);
+	return major === 3 && minor >= 3;
+}
+function isMissingModule(error) {
+	return !!error && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND";
+}
+function formatResolutionError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { inspectVueCompiler, resolveVueCompiler };
+
+//# sourceMappingURL=vueCompiler.js.map