@mbler/mcx-core 0.1.3-rc.6 → 0.1.3-rc.8

package/README.md

@@ -22,8 +22,8 @@ pnpm add -D @mbler/mcx-core
 ```
 
 ## Usage
-
-Add the plugin to your Rollup or Rolldown config:
+1. Use manually
+Add the plugin to your Rollup or Rolldown/Rollup config:
 
 ```ts
 import { rollupPlugin } from '@mbler/mcx-core'
@@ -32,7 +32,10 @@ export default {
   plugins: [rollupPlugin({ moduleDir: './modules', tsconfigPath: './tsconfig.json' })],
 }
 ```
-
+2. Use with [mbler](https://npmjs.com/package/mbler)
+```bash
+pnpm create mbler
+```
 For full documentation, visit the **[Docs](https://mbler-docs.ruanhor.dpdns.org/guide/mcx)**.
 
 ## License

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 import * as t from "@babel/types";
 import { ArgumentPlaceholder, CallExpression, ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, Expression, ImportDeclaration, SpreadElement } from "@babel/types";
 import * as Parser from "@babel/parser";
-import { Plugin, TransformPluginContext } from "rollup";
+import * as vm from "node:vm";
 import { CompileOpt, CompileOpt as CompileOpt$1 } from "@mbler/mcx-types";
+import { Plugin } from "rollup";
 import { Plugin as Plugin$1 } from "rolldown";
 import { EnchantableSlot, EntityComponentOptions, FoodEffect, ItemComponentOptions, ParticleType, Rarity, SoundEvent } from "@mbler/mcx-component";
 
@@ -75,8 +76,21 @@ declare class MCXCompileData {
   constructor(raw: ParsedTagNode[], JSIR: JsCompileData, strLoc: MCXstructureLoc);
   setFilePath(dir: string): void;
 }
+//#endregion
+//#region src/mcx-component/moduleResolver.d.ts
+type FileTransformFn = (code: string, id: string) => string;
+declare class ModuleResolver {
+  private cache;
+  private loadingModules;
+  private transformFile;
+  constructor(cache: Map<string, string>, transformFile: FileTransformFn);
+  getCache(): Map<string, string>;
+  clear(): void;
+  ensureModule(specifier: string, importerPath: string, context: vm.Context, nativeRequire?: (id: string) => unknown): unknown;
+  private executeInContext;
+}
 declare namespace types_d_exports$1 {
-  export { AttributeMap, BaseToken, CommentToken, ContentToken, JsType, MCXLoc, MCXPosition, ParseReadFileOpt, ParsedCommentNode, ParsedTagContentNode, ParsedTagNode, PropNode, PropValue, ReadFileOpt, TagEndToken, TagToken, Token, TokenType, TypeVerifyBody, mcxType, transformCtx, transformParseCtx };
+  export { AttributeMap, BaseToken, CommentToken, ContentToken, JsType, MCXLoc, MCXPosition, McxPluginContext, ParseReadFileOpt, ParsedCommentNode, ParsedTagContentNode, ParsedTagNode, PropNode, PropValue, ReadFileOpt, TagEndToken, TagToken, Token, TokenType, TypeVerifyBody, mcxType, transformCtx, transformParseCtx };
 }
 interface BaseToken {
   data: string;
@@ -143,8 +157,20 @@ interface ParseReadFileOpt {
 }
 type ReadFileOpt = Partial<ParseReadFileOpt>;
 type mcxType = 'component' | 'event' | 'app' | 'ui' | 'form';
+interface McxPluginContext {
+  error: (err: string | {
+    message: string;
+    [key: string]: unknown;
+  }, extra?: number | {
+    column: number;
+    line: number;
+  }) => void;
+  warn: (warning: string | {
+    message: string;
+  }) => void;
+}
 interface transformCtx {
-  rollupContext: TransformPluginContext;
+  rollupContext: McxPluginContext;
   compiledCode: MCXCompileData;
   cache: Map<string, MCXCompileData>;
   currentId: string;
@@ -161,6 +187,7 @@ interface transformCtx {
     behavior: string;
     resources: string;
   };
+  moduleResolver?: ModuleResolver;
 }
 interface transformParseCtx {
   prop: t.ObjectProperty[];
@@ -331,7 +358,8 @@ declare class RunScript {
   private _context;
   private _module;
   private _pluginContext;
-  constructor(filePath?: string, module?: 'esm' | 'cjs', pluginContext?: Record<string, string | null | boolean | number> | undefined);
+  private _moduleResolver;
+  constructor(filePath?: string, module?: 'esm' | 'cjs', pluginContext?: Record<string, string | null | boolean | number> | undefined, moduleResolver?: ModuleResolver);
   /**
    * run code in nodejs vm
    * @param code {string} exetuce code
@@ -392,7 +420,7 @@ declare function generateItemTextureJson(output: {
 declare function compileComponent(compiledCode: MCXCompileData, ctx: transformCtx): Promise<void>;
 //#endregion
 //#region src/transforms/index.d.ts
-declare function transform(code: MCXCompileData, cache: Map<string, MCXCompileData>, id: string, context: TransformPluginContext, opt: CompileOpt, output: transformCtx['output']): Promise<string>;
+declare function transform(code: MCXCompileData, cache: Map<string, MCXCompileData>, id: string, context: McxPluginContext, opt: CompileOpt, output: transformCtx['output'], moduleResolver?: ModuleResolver): Promise<string>;
 //#endregion
 export { _default as AST, types_d_exports as ComponentType, types_d_exports$1 as PubType, index_d_exports as compile_component, index_d_exports$1 as compiler, rolldownPlugin, rollupPlugin, transform, Utils as utils };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -3,7 +3,7 @@ import * as Module from "node:module";
 import { createRequire } from "node:module";
 import { NodeTypes, baseParse } from "@vue/compiler-core";
 import * as path from "node:path";
-import { extname } from "node:path";
+import { dirname, extname, resolve, sep } from "node:path";
 import * as t from "@babel/types";
 import { program } from "@babel/types";
 import * as fs from "node:fs/promises";
@@ -1178,11 +1178,12 @@ function generateLayout(ctx, tagNode, tagName, mode) {
 			const formType = detectFormType(name);
 			if (formType) typeTags.push(formType);
 		}
+		const _paramCtx = t.identifier("ctx");
 		const paramsObj = t.objectExpression(Object.entries(cleanedArr).filter(([key]) => key !== "for" && key !== "if").map(([key, value]) => {
 			const isDynamic = key.startsWith(":");
 			const paramName = isDynamic ? key.slice(1) : key;
 			if (paramName === "click") return t.objectProperty(t.identifier(paramName), simpleFn(String(value)));
-			return t.objectProperty(t.identifier(paramName), isDynamic ? simpleFn(String(value)) : typeof value === "boolean" ? t.booleanLiteral(value) : t.stringLiteral(value));
+			return t.objectProperty(t.identifier(paramName), isDynamic ? simpleFn(String(value)) : t.arrowFunctionExpression([_paramCtx], typeof value === "boolean" ? t.booleanLiteral(value) : t.stringLiteral(value)));
 		}));
 		const contentExpr = mode === "form" ? parseContentForm(el.content) : parseContent(el.content);
 		const props = [
@@ -1247,41 +1248,12 @@ function simpleFn(expr) {
 	const body = dotAccess(expr, ctx);
 	return t.arrowFunctionExpression([ctx], body);
 }
-/** Extract root identifiers from an expression for dependency tracking */
-function extractIdentifiers(expr) {
-	const reserved = new Set([
-		"true",
-		"false",
-		"null",
-		"undefined",
-		"this",
-		"new",
-		"typeof",
-		"instanceof"
-	]);
-	const ids = /* @__PURE__ */ new Set();
-	const regex = /\b([a-zA-Z_$][\w$]*)\b/g;
-	let m;
-	while ((m = regex.exec(expr)) !== null) if (!reserved.has(m[1])) ids.add(m[1]);
-	return [...ids];
-}
-/** Generate new Computation((ctx) => expr, [deps]) */
-function arrowFn(expr) {
-	const ctx = t.identifier("ctx");
-	const body = dotAccess(expr, ctx);
-	const evalFn = t.arrowFunctionExpression([ctx], body);
-	const deps = extractIdentifiers(expr).map((id) => {
-		const c = t.identifier("ctx");
-		return t.arrowFunctionExpression([c], dotAccess(id, c));
-	});
-	return t.newExpression(t.identifier("Computation"), [evalFn, t.arrayExpression(deps)]);
-}
 /** Parse content for form mode: never creates Computation, uses plain functions */
 function parseContentForm(raw) {
-	if (!raw.includes("{{ ")) return t.stringLiteral(raw);
+	const ctx = t.identifier("ctx");
+	if (!raw.includes("{{ ")) return t.arrowFunctionExpression([ctx], t.stringLiteral(raw));
 	const parts = splitInterpolation(raw);
 	if (parts.length === 1 && parts[0].type === "expr") return simpleFn(parts[0].value);
-	const ctx = t.identifier("ctx");
 	const quasis = [];
 	const expressions = [];
 	for (const part of parts) if (part.type === "text") quasis.push(t.templateElement({
@@ -1297,43 +1269,29 @@ function parseContentForm(raw) {
 	return t.arrowFunctionExpression([ctx], tpl);
 }
 /**
-* Parse content string, returns:
-* - t.stringLiteral for pure static text
-* - t.NewExpression (Computation) for content with {{ }} interpolation
-*
-* Supports:
-* - "Hello" → "Hello"
-* - "{{ a }}" → new Computation((ctx) => ctx[0].a, [ctx => ctx[0].a])
-* - "Hi {{ a }}" → new Computation((ctx) => `Hi ${ctx[0].a}`, [ctx => ctx[0].a])
-* - "{{ a.slice(1,2) }}" → new Computation((ctx) => ctx[0].a.slice(1,2), [ctx => ctx[0].a])
+* Parse content string, returns an arrow function (ctx) => result:
+* - "Hello" → (ctx) => "Hello"
+* - "{{ a }}" → (ctx) => ctx[0].a
+* - "Hi {{ a }}" → (ctx) => `Hi ${ctx[0].a}`
 */
 function parseContent(raw) {
-	if (!raw.includes("{{ ")) return t.stringLiteral(raw);
-	const parts = splitInterpolation(raw);
-	if (parts.length === 1 && parts[0].type === "expr") return arrowFn(parts[0].value);
 	const ctx = t.identifier("ctx");
+	if (!raw.includes("{{ ")) return t.arrowFunctionExpression([ctx], t.stringLiteral(raw));
+	const parts = splitInterpolation(raw);
+	if (parts.length === 1 && parts[0].type === "expr") return simpleFn(parts[0].value);
 	const quasis = [];
 	const expressions = [];
-	const allIds = /* @__PURE__ */ new Set();
 	for (const part of parts) if (part.type === "text") quasis.push(t.templateElement({
 		raw: part.value,
 		cooked: part.value
 	}));
-	else {
-		expressions.push(dotAccess(part.value, ctx));
-		for (const id of extractIdentifiers(part.value)) allIds.add(id);
-	}
+	else expressions.push(dotAccess(part.value, ctx));
 	quasis.push(t.templateElement({
 		raw: "",
 		cooked: ""
 	}, true));
 	const tpl = t.templateLiteral(quasis, expressions);
-	const evalFn = t.arrowFunctionExpression([ctx], tpl);
-	const deps = [...allIds].map((id) => {
-		const c = t.identifier("ctx");
-		return t.arrowFunctionExpression([c], dotAccess(id, c));
-	});
-	return t.newExpression(t.identifier("Computation"), [evalFn, t.arrayExpression(deps)]);
+	return t.arrowFunctionExpression([ctx], tpl);
 }
 function splitInterpolation(raw) {
 	const result = [];
@@ -1573,12 +1531,14 @@ var RunScript = class {
 	_context;
 	_module;
 	_pluginContext;
-	constructor(filePath = "<repl>", module = "cjs", pluginContext) {
+	_moduleResolver;
+	constructor(filePath = "<repl>", module = "cjs", pluginContext, moduleResolver) {
 		this.filePath = filePath;
 		this.module = module;
 		this.pluginContext = pluginContext;
 		this._module = new Module.Module(this.filePath);
 		this._pluginContext = pluginContext || {};
+		this._moduleResolver = moduleResolver;
 		this._context = this.getContext(this._pluginContext);
 	}
 	/**
@@ -1630,15 +1590,21 @@ var RunScript = class {
 			id: this.filePath
 		};
 		const originalRequire = Module.createRequire ? Module.createRequire(this.filePath) : __require;
-		const restrictedRequire = new Proxy(originalRequire, { apply(target, thisArg, args) {
+		const contextRequire = new Proxy(originalRequire, { apply: (target, thisArg, args) => {
 			const id = args[0];
 			if (typeof id === "string" && BLOCKED_MODULES.has(id)) throw new Error(`[mcx component]: require('${id}') is not allowed in component scripts`);
+			if (this._moduleResolver) try {
+				return Reflect.apply(target, thisArg, args);
+			} catch {
+				const currentImporter = context.module?.filename || this.filePath;
+				return this._moduleResolver.ensureModule(id, currentImporter, context, void 0);
+			}
 			return Reflect.apply(target, thisArg, args);
 		} });
 		Object.assign(context, {
 			exports,
 			module,
-			require: restrictedRequire,
+			require: contextRequire,
 			global: context
 		});
 		return vm.createContext(context);
@@ -1859,23 +1825,7 @@ async function compileComponent(compiledCode, ctx) {
 	const src = compiledCode.strLoc.script;
 	const exportSources = collectExportSources(src);
 	checkComponentImports(exportSources, compiledCode.File);
-	const scriptRunResult = await new RunScript(compiledCode.File, "esm").run(src, 0, (data, setData) => {
-		if (setData && data.type == "CallExpression" && data.callee.type == "Identifier" && data.arguments.length == 1 && data.arguments[0]?.type == "CallExpression" && data.arguments[0].callee.type == "Identifier" && data.arguments[0].callee.name == "require") {
-			const arg = data.arguments[0].arguments[0];
-			if (arg && arg.type == "StringLiteral") {
-				if (/^.+?\.(png|svg|jpg|jpeg|gif)$/.test(arg.value)) {
-					const imageComponentRequire = t.memberExpression(t.callExpression(t.identifier("require"), [t.stringLiteral("@mbler/mcx-component")]), t.identifier({
-						png: "PNGImageComponent",
-						svg: "SVGImageComponent",
-						jpg: "JPGImageComponent",
-						jpeg: "JPGImageComponent",
-						gif: "GIFImageComponent"
-					}[path.extname(arg.value).slice(1)]));
-					setData(t.newExpression(imageComponentRequire, [t.callExpression(t.memberExpression(t.callExpression(t.identifier("require"), [t.stringLiteral("node:path")]), t.identifier("join")), [t.stringLiteral(path.dirname(compiledCode.File)), arg])]));
-				}
-			}
-		}
-	});
+	const scriptRunResult = await new RunScript(compiledCode.File, "esm", void 0, ctx.moduleResolver).run(src, 0);
 	if (!component) throw new Error("[component internal error]: compile component: mcx is not component: filePath: " + compiledCode.File);
 	if (typeof scriptRunResult !== "object") throw new Error("[component compile error]: exec code: mcx export type is not object");
 	for (const i of Object.entries(component)) {
@@ -1973,14 +1923,10 @@ async function _transform(ctx) {
 
 //#endregion
 //#region src/transforms/index.ts
-function createErrorProxy(err, id) {
-	if (err instanceof Error) return {
-		...err,
-		message: `${err.message} (At ${id})`
-	};
-	else return { message: String(err) };
+function toMcxError(err, id) {
+	return { message: err instanceof Error ? `${err.message} (At ${id})` : String(err) };
 }
-async function transform(code, cache, id, context, opt, output) {
+async function transform(code, cache, id, context, opt, output, moduleResolver) {
 	try {
 		const scriptTag = code.raw.find((node) => {
 			return node.name == "script";
@@ -1999,18 +1945,149 @@ async function transform(code, cache, id, context, opt, output) {
 				param: [],
 				body: []
 			},
-			output
+			output,
+			...moduleResolver ? { moduleResolver } : {}
 		});
 	} catch (err) {
-		context.error(createErrorProxy(err, id));
+		context.error(toMcxError(err, id));
 		return "";
 	}
 }
 
+//#endregion
+//#region src/compile-mcx/compiler/resolve.ts
+const RESOLVE_EXTS = [
+	".ts",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs",
+	""
+];
+function resolveFileSync(filePath) {
+	for (const ext of RESOLVE_EXTS) try {
+		const fullPath = filePath + ext;
+		readFileSync(fullPath);
+		return fullPath;
+	} catch {}
+	if (filePath.endsWith(sep) || !extname(filePath)) for (const ext of RESOLVE_EXTS) try {
+		const fullPath = filePath + "/index" + ext;
+		readFileSync(fullPath);
+		return fullPath;
+	} catch {}
+	return null;
+}
+async function resolveFileAsync(filePath) {
+	for (const ext of RESOLVE_EXTS) try {
+		const fullPath = filePath + ext;
+		await readFile(fullPath, "utf-8");
+		return fullPath;
+	} catch {}
+	if (filePath.endsWith(sep) || !extname(filePath)) for (const ext of RESOLVE_EXTS) try {
+		const fullPath = filePath + "/index" + ext;
+		await readFile(fullPath, "utf-8");
+		return fullPath;
+	} catch {}
+	return null;
+}
+function resolveSync(specifier, importerPath) {
+	if (specifier.startsWith(".") || specifier.startsWith("/")) return resolveFileSync(resolve(dirname(importerPath), specifier));
+	try {
+		return __require.resolve(specifier, { paths: [dirname(importerPath)] });
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/mcx-component/moduleResolver.ts
+var ModuleResolver = class {
+	cache;
+	loadingModules = /* @__PURE__ */ new Set();
+	transformFile;
+	constructor(cache, transformFile) {
+		this.cache = cache;
+		this.transformFile = transformFile;
+	}
+	getCache() {
+		return this.cache;
+	}
+	clear() {
+		this.cache.clear();
+		this.loadingModules.clear();
+	}
+	ensureModule(specifier, importerPath, context, nativeRequire) {
+		if (nativeRequire) try {
+			return nativeRequire(specifier);
+		} catch {}
+		const resolved = resolveSync(specifier, importerPath);
+		if (!resolved) throw new Error(`[mcx component]: cannot resolve '${specifier}' from '${importerPath}'`);
+		if (this.cache.has(resolved)) return this.executeInContext(resolved, context);
+		if (this.loadingModules.has(resolved)) return context.exports;
+		this.loadingModules.add(resolved);
+		try {
+			const code = readFileSync(resolved, "utf-8");
+			const compiled = this.transformFile(code, resolved);
+			this.cache.set(resolved, compiled);
+			return this.executeInContext(resolved, context);
+		} finally {
+			this.loadingModules.delete(resolved);
+		}
+	}
+	executeInContext(resolvedPath, context) {
+		const compiled = this.cache.get(resolvedPath);
+		const script = new vm.Script(compiled, { filename: resolvedPath });
+		const savedExports = context.exports;
+		const savedModule = context.module;
+		const childExports = {};
+		const childModule = {
+			exports: childExports,
+			filename: resolvedPath,
+			path: dirname(resolvedPath),
+			id: resolvedPath
+		};
+		context.exports = childExports;
+		context.module = childModule;
+		try {
+			script.runInContext(context);
+			return context.exports;
+		} finally {
+			context.exports = savedExports;
+			context.module = savedModule;
+		}
+	}
+};
+function createImageTransformCode(absolutePath, ext) {
+	const className = {
+		".png": "PNGImageComponent",
+		".svg": "SVGImageComponent",
+		".jpg": "JPGImageComponent",
+		".jpeg": "JPGImageComponent",
+		".gif": "GIFImageComponent"
+	}[ext.toLowerCase()];
+	if (!className) throw new Error(`[mcx component]: unsupported image extension '${ext}' for '${absolutePath}'`);
+	return [
+		`Object.defineProperty(exports, '__esModule', { value: true });`,
+		`var { ${className} } = require('@mbler/mcx-component');`,
+		`var path = require('node:path');`,
+		`exports.default = new ${className}(${JSON.stringify(absolutePath)});`
+	].join("\n");
+}
+
 //#endregion
 //#region src/compile-mcx/compiler/main.ts
+const IMAGE_EXTS = new Set([
+	".png",
+	".svg",
+	".jpg",
+	".jpeg",
+	".gif"
+]);
 function createMcxPlugin(opt, output) {
 	let cache = /* @__PURE__ */ new Map();
+	let moduleTransformCache;
+	let moduleResolver;
 	let tsconfig;
 	try {
 		const configResult = ts.readConfigFile(opt.tsconfigPath, (path) => {
@@ -2037,29 +2114,6 @@ function createMcxPlugin(opt, output) {
 			errors: []
 		};
 	}
-	const resolveExtensions = [
-		"",
-		".ts",
-		".mts",
-		".cts",
-		".js",
-		".mjs",
-		".cjs"
-	];
-	const indexExtensions = resolveExtensions.map((ext) => "/index" + ext);
-	async function tryResolvePath(filePath) {
-		for (const idxExt of indexExtensions) try {
-			const fullPath = filePath + idxExt;
-			await readFile(fullPath, "utf-8");
-			return fullPath;
-		} catch {}
-		for (const ext of resolveExtensions) try {
-			const fullPath = filePath + ext;
-			await readFile(fullPath, "utf-8");
-			return fullPath;
-		} catch {}
-		return null;
-	}
 	async function resolvePackageExports(pkgDir, subPath, pkgJson) {
 		const exports = pkgJson.exports;
 		if (exports) {
@@ -2093,7 +2147,7 @@ function createMcxPlugin(opt, output) {
 			if (i.dir.startsWith(".") || i.root) {
 				if (imp) {
 					const baseDir = path.dirname(imp);
-					const resolved = await tryResolvePath(path.join(baseDir, id));
+					const resolved = await resolveFileAsync(path.join(baseDir, id));
 					if (resolved) return resolved;
 				}
 				return null;
@@ -2118,9 +2172,9 @@ function createMcxPlugin(opt, output) {
 				if (subPath) {
 					const fromExports = await resolvePackageExports(d, subPath, pkgJson);
 					if (fromExports) return fromExports;
-					const fromDist = await tryResolvePath(path.join(d, "./dist", subPath));
+					const fromDist = await resolveFileAsync(path.join(d, "./dist", subPath));
 					if (fromDist) return fromDist;
-					const fromRoot = await tryResolvePath(path.join(d, subPath));
+					const fromRoot = await resolveFileAsync(path.join(d, subPath));
 					if (fromRoot) return fromRoot;
 					return null;
 				}
@@ -2146,31 +2200,60 @@ function createMcxPlugin(opt, output) {
 				}
 				compileData.setFilePath(id);
 				return {
-					code: await transform(compileData, cache, id, this, opt, output),
-					map: opt.sourcemap ? magic.generateMap({
+					code: await transform(compileData, cache, id, this, opt, output, moduleResolver),
+					...opt.sourcemap ? { map: magic.generateMap({
 						hires: true,
 						source: id
-					}) : void 0
+					}) } : {}
 				};
-			} else if (tsRegex.test(id)) return {
-				code: ts.transpileModule(code, {
-					compilerOptions: tsconfig.options,
-					fileName: id
-				}).outputText,
-				map: opt.sourcemap ? magic.generateMap({
+			}
+			const cached = moduleTransformCache.get(id);
+			if (cached) return {
+				code: cached,
+				...opt.sourcemap ? { map: magic.generateMap({
 					hires: true,
 					source: id
-				}) : void 0
+				}) } : {}
 			};
+			let compiledCode = null;
+			if (tsRegex.test(id)) compiledCode = ts.transpileModule(code, {
+				compilerOptions: tsconfig.options,
+				fileName: id
+			}).outputText;
+			else {
+				const fileExt = extname(id).toLowerCase();
+				if (IMAGE_EXTS.has(fileExt)) compiledCode = createImageTransformCode(id, fileExt);
+			}
+			if (compiledCode !== null) {
+				moduleTransformCache.set(id, compiledCode);
+				return {
+					code: compiledCode,
+					...opt.sourcemap ? { map: magic.generateMap({
+						hires: true,
+						source: id
+					}) } : {}
+				};
+			}
 			return null;
 		},
 		async buildEnd() {
 			cache.clear();
+			moduleResolver?.clear();
 			await generateItemTextureJson(output);
 			clearCachedOptions();
 		},
 		buildStart() {
 			cache = /* @__PURE__ */ new Map();
+			moduleTransformCache = /* @__PURE__ */ new Map();
+			moduleResolver = new ModuleResolver(moduleTransformCache, (fileCode, fileId) => {
+				const fileExt = extname(fileId).toLowerCase();
+				if (fileExt === ".ts" || fileExt === ".mts" || fileExt === ".cts") return ts.transpileModule(fileCode, {
+					compilerOptions: tsconfig.options,
+					fileName: fileId
+				}).outputText;
+				if (IMAGE_EXTS.has(fileExt)) return createImageTransformCode(fileId, fileExt);
+				return fileCode;
+			});
 		}
 	};
 }