keq 2.8.14 → 2.9.0

package/packages/cli/dist/compiler-0Kli6UCr.cjs

@@ -0,0 +1,738 @@
+const require_logger = require("./logger-D7PyVZo3.cjs");
+const require_plugins = require("./plugins-CgMhaNZq.cjs");
+const require_micro_function_translator = require("./micro-function.translator-BmJZzkKh.cjs");
+let listr2 = require("listr2");
+let tapable = require("tapable");
+let fs_extra = require("fs-extra");
+fs_extra = require_logger.__toESM(fs_extra, 1);
+let path = require("path");
+path = require_logger.__toESM(path, 1);
+let cosmiconfig = require("cosmiconfig");
+let ramda = require("ramda");
+ramda = require_logger.__toESM(ramda, 1);
+let picomatch = require("picomatch");
+picomatch = require_logger.__toESM(picomatch, 1);
+let node_fs = require("node:fs");
+node_fs = require_logger.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_logger.__toESM(node_path, 1);
+let _sinclair_typebox_value = require("@sinclair/typebox/value");
+let _sinclair_typebox = require("@sinclair/typebox");
+let _scalar_openapi_parser = require("@scalar/openapi-parser");
+//#region src/constants/file-naming-style.ts
+/**
+* File naming style options
+*/
+let FileNamingStyle = /* @__PURE__ */ function(FileNamingStyle) {
+	/** Camel case style (e.g., myFileName) */
+	FileNamingStyle["camelCase"] = "camelCase";
+	/** Capital case style (e.g., My File Name) */
+	FileNamingStyle["capitalCase"] = "capitalCase";
+	/** Constant case style (e.g., MY_FILE_NAME) */
+	FileNamingStyle["constantCase"] = "constantCase";
+	/** Dot case style (e.g., my.file.name) */
+	FileNamingStyle["dotCase"] = "dotCase";
+	/** Header case style (e.g., My-File-Name) */
+	FileNamingStyle["headerCase"] = "headerCase";
+	/** No case style (e.g., my file name) */
+	FileNamingStyle["noCase"] = "noCase";
+	/** Param case style (e.g., my-file-name) */
+	FileNamingStyle["paramCase"] = "paramCase";
+	/** Pascal case style (e.g., MyFileName) */
+	FileNamingStyle["pascalCase"] = "pascalCase";
+	/** Path case style (e.g., my/file/name) */
+	FileNamingStyle["pathCase"] = "pathCase";
+	/** Sentence case style (e.g., My file name) */
+	FileNamingStyle["sentenceCase"] = "sentenceCase";
+	/** Snake case style (e.g., my_file_name) */
+	FileNamingStyle["snakeCase"] = "snakeCase";
+	/** Kebab case style (e.g., my-file-name) */
+	FileNamingStyle["kebabCase"] = "kebabCase";
+	return FileNamingStyle;
+}({});
+//#endregion
+//#region src/utils/matcher.ts
+const ALL_HTTP_METHODS = [
+	"get",
+	"post",
+	"put",
+	"delete",
+	"patch",
+	"head",
+	"options"
+];
+function deduplicateRules(rules) {
+	const sorted = ramda.sortBy(ramda.prop("deny"), rules);
+	return ramda.uniqWith((a, b) => a.moduleName === b.moduleName && a.operationMethod === b.operationMethod && a.operationPathname === b.operationPathname, sorted);
+}
+function sortRulesForOutput(rules) {
+	return [...rules].sort((a, b) => {
+		if (a.moduleName === "*" && b.moduleName !== "*") return -1;
+		if (a.moduleName !== "*" && b.moduleName === "*") return 1;
+		if (a.moduleName !== b.moduleName) return a.moduleName.localeCompare(b.moduleName);
+		if (a.operationMethod === "*" && b.operationMethod !== "*") return -1;
+		if (a.operationMethod !== "*" && b.operationMethod === "*") return 1;
+		if (a.operationMethod !== b.operationMethod) return a.operationMethod.localeCompare(b.operationMethod);
+		return a.operationPathname.localeCompare(b.operationPathname);
+	});
+}
+function renderBlock(section, rules) {
+	if (rules.length === 0) return "";
+	const maxMethodLen = Math.max(...rules.map((r) => r.operationMethod.toUpperCase().length));
+	const lines = [];
+	for (const r of rules) {
+		if (r.leadingComments && r.leadingComments.length > 0) lines.push(...r.leadingComments);
+		const ruleLine = `${r.operationMethod.toUpperCase().padEnd(maxMethodLen + 2)}${r.moduleName}:${r.operationPathname}`;
+		lines.push(r.inlineComment ? `${ruleLine}  ${r.inlineComment}` : ruleLine);
+	}
+	return `[${section}]\n${lines.join("\n")}`;
+}
+function compileRule(rule) {
+	return {
+		rule,
+		matchModuleName: (0, picomatch.default)(rule.moduleName),
+		matchMethod: (0, picomatch.default)(rule.operationMethod),
+		matchPathname: (0, picomatch.default)(rule.operationPathname)
+	};
+}
+/**
+* Matches API operations and modules against `.keqfilter` rules to determine
+* which should be denied (excluded) or allowed during code generation.
+* Supports glob patterns (via picomatch) for module names, HTTP methods, and pathnames.
+*/
+var Matcher = class Matcher {
+	compiled;
+	preambleComments;
+	trailingComments;
+	constructor(rules, meta = {}) {
+		this.compiled = rules.map(compileRule);
+		this.preambleComments = meta.preambleComments ?? [];
+		this.trailingComments = meta.trailingComments ?? [];
+	}
+	get rules() {
+		return this.compiled.map((c) => c.rule);
+	}
+	/**
+	* Parse `.keqfilter` file content into a Matcher instance.
+	*
+	* File format:
+	* ```
+	* [deny]
+	* GET     petStore:/pets
+	* *       userService:/**
+	*
+	* [allow]
+	* GET     petStore:/pets/details
+	* ```
+	*
+	* Line format: `METHOD module:/pathname`
+	* - method: HTTP method or `*`, case-insensitive
+	* - module:/pathname: module name + `:` + path pattern (glob supported)
+	*/
+	static parse(content) {
+		const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+		const rules = [];
+		let currentDeny = null;
+		let firstSectionSeen = false;
+		let preambleComments = [];
+		const pendingComments = [];
+		for (const rawLine of normalized.split("\n")) {
+			const line = rawLine.replace(/#.*$/, "").trim();
+			if (!line) {
+				pendingComments.push(rawLine);
+				continue;
+			}
+			if (line === "[deny]") {
+				if (!firstSectionSeen) {
+					preambleComments = [...pendingComments];
+					pendingComments.length = 0;
+					firstSectionSeen = true;
+				} else while (pendingComments.length > 0 && pendingComments[0].trim() === "") pendingComments.shift();
+				currentDeny = true;
+				continue;
+			}
+			if (line === "[allow]") {
+				if (!firstSectionSeen) {
+					preambleComments = [...pendingComments];
+					pendingComments.length = 0;
+					firstSectionSeen = true;
+				} else while (pendingComments.length > 0 && pendingComments[0].trim() === "") pendingComments.shift();
+				currentDeny = false;
+				continue;
+			}
+			if (currentDeny === null) continue;
+			const matched = line.match(/^([^\s]+)\s+([^:\s]+):(.*)$/);
+			if (!matched) throw new Error(`Invalid filter rule: "${line}"`);
+			const [, operationMethod, moduleName, operationPathname] = matched;
+			const inlineCommentMatch = rawLine.match(/\s+(#.*)$/);
+			const inlineComment = inlineCommentMatch ? inlineCommentMatch[1] : void 0;
+			rules.push({
+				persist: true,
+				deny: currentDeny,
+				moduleName,
+				operationMethod: operationMethod.toLowerCase(),
+				operationPathname,
+				leadingComments: pendingComments.length > 0 ? [...pendingComments] : void 0,
+				inlineComment
+			});
+			pendingComments.length = 0;
+		}
+		const trailingComments = [...pendingComments];
+		while (trailingComments.length > 0 && trailingComments[trailingComments.length - 1].trim() === "") trailingComments.pop();
+		while (preambleComments.length > 0 && preambleComments[preambleComments.length - 1].trim() === "") preambleComments.pop();
+		return new Matcher(deduplicateRules(rules), {
+			preambleComments,
+			trailingComments
+		});
+	}
+	static async read(filepath) {
+		const content = await fs_extra.default.readFile(filepath, "utf-8");
+		return Matcher.parse(content);
+	}
+	async write(filepath) {
+		const persistRules = ramda.compose(ramda.reverse, ramda.uniqWith((a, b) => a.moduleName === b.moduleName && a.operationMethod === b.operationMethod && a.operationPathname === b.operationPathname), ramda.filter((rule) => rule.persist))(this.rules);
+		const denyRules = sortRulesForOutput(persistRules.filter((r) => r.deny));
+		const allowRules = sortRulesForOutput(persistRules.filter((r) => !r.deny));
+		const blocks = [renderBlock("deny", denyRules), renderBlock("allow", allowRules)].filter(Boolean);
+		if (blocks.length === 0) return;
+		const blockContent = blocks.join("\n\n");
+		const mainContent = this.preambleComments.length > 0 ? `${this.preambleComments.join("\n")}\n${blockContent}` : blockContent;
+		const output = this.trailingComments.length > 0 ? `${mainContent}\n\n${this.trailingComments.join("\n")}` : mainContent;
+		await fs_extra.default.writeFile(filepath, output, "utf-8");
+	}
+	append(rule) {
+		this.compiled.unshift(compileRule(rule));
+	}
+	isOperationDenied(operationDefinition) {
+		const moduleName = operationDefinition.module.name;
+		const operationMethod = operationDefinition.method.toLowerCase();
+		const operationPathname = operationDefinition.pathname;
+		for (const { rule, matchModuleName, matchMethod, matchPathname } of this.compiled) {
+			if (!matchModuleName(moduleName)) continue;
+			if (!matchMethod(operationMethod)) continue;
+			if (!matchPathname(operationPathname)) continue;
+			return rule.deny;
+		}
+		return false;
+	}
+	isModuleDenied(moduleDefinition) {
+		const moduleName = moduleDefinition.name;
+		for (const { rule, matchModuleName, matchMethod, matchPathname } of this.compiled) {
+			if (!matchModuleName(moduleName)) continue;
+			if (!rule.deny) return false;
+			if (!ALL_HTTP_METHODS.every((m) => matchMethod(m))) continue;
+			if (!matchPathname("/a/b/c/d")) continue;
+			return true;
+		}
+		return false;
+	}
+};
+//#endregion
+//#region src/compiler/tasks/setup/utils/find-nearest-package-json.ts
+function findNearestPackageJson(startDir = process.cwd()) {
+	let dir = startDir;
+	while (true) {
+		const pkgPath = node_path.default.join(dir, "package.json");
+		if (node_fs.default.existsSync(pkgPath)) return {
+			json: JSON.parse(node_fs.default.readFileSync(pkgPath, "utf8")),
+			path: pkgPath
+		};
+		const parent = node_path.default.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+//#endregion
+//#region src/compiler/tasks/setup/utils/get-project-module-system.ts
+function getProjectModuleSystem(pkgInfo) {
+	if (!pkgInfo?.json) return "cjs";
+	const { json } = pkgInfo;
+	if (json.type === "module") return "esm";
+	return "cjs";
+}
+//#endregion
+//#region src/types/address.ts
+const Address = _sinclair_typebox.Type.Object({
+	url: _sinclair_typebox.Type.String(),
+	headers: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Record(_sinclair_typebox.Type.String(), _sinclair_typebox.Type.String(), { default: {} })),
+	encoding: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Union([_sinclair_typebox.Type.Literal("utf8"), _sinclair_typebox.Type.Literal("ascii")], { default: "utf8" }))
+});
+//#endregion
+//#region src/utils/is-valid-url.ts
+/**
+* 通用 URL 验证正则表达式，支持任意协议
+*
+* 格式: protocol://[user:password@][host][:port][/path][?query][#fragment]
+*
+* 支持的协议示例:
+* - http://, https://
+* - file:// (支持 file:///path 和 file://host/path 两种格式)
+* - ftp://, sftp://
+* - ws://, wss://
+* - 以及任何其他自定义协议
+*/
+const URL_REGEX = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/(?:[^\s@]+@)?[^\s/:?#]*(?::\d+)?(?:\/[^\s?#]*)?(?:\?[^\s#]*)?(?:#[^\s]*)?$/;
+/**
+* 验证是否为有效的 URL
+*
+* @param url - 待验证的 URL 字符串
+* @returns 如果是有效的 URL 返回 true，否则返回 false
+*
+* @example
+* ```typescript
+* isValidURL('http://example.com') // true
+* isValidURL('https://example.com:8080/path?query=1#fragment') // true
+* isValidURL('file:///path/to/file.json') // true
+* isValidURL('not a url') // false
+* ```
+*/
+function isValidURL(url) {
+	return URL_REGEX.test(url);
+}
+//#endregion
+//#region src/types/runtime-config.ts
+const Modules = _sinclair_typebox.Type.Transform(_sinclair_typebox.Type.Record(_sinclair_typebox.Type.String(), _sinclair_typebox.Type.Union([_sinclair_typebox.Type.String(), Address]))).Decode((value) => {
+	const keys = Object.keys(value);
+	for (const key of keys) if (!/^[A-Za-z_][A-Za-z0-9_$]*$/.test(key)) throw new Error(`Module name "${key}" is not valid. It must start with a letter or underscore, and can only contain letters, numbers, and underscores.`);
+	const keysGroupByLowerCase = ramda.groupBy(ramda.toLower, keys);
+	for (const groupKey in keysGroupByLowerCase) {
+		const keys = keysGroupByLowerCase[groupKey] || [];
+		if (keys.length > 1) throw new Error(`Module names ${keys.map((name) => `"${name}"`).join(", ")} are case-insensitively duplicated.`);
+	}
+	for (const key in value) {
+		const url = typeof value[key] === "string" ? value[key] : value[key].url;
+		if (isValidURL(url)) continue;
+		throw new Error(`The ${JSON.stringify(url)} of module "${key}" is not a valid URL.`);
+	}
+	return ramda.map((item) => typeof item !== "string" ? item : {
+		url: item,
+		headers: {},
+		encoding: "utf8"
+	}, value);
+}).Encode((value) => value);
+const RawConfig = _sinclair_typebox.Type.Object({
+	/**
+	* Output directory for generated files
+	*/
+	outdir: _sinclair_typebox.Type.String({ default: `${process.cwd()}/api` }),
+	/**
+	* Rendering options that directly control code generation output
+	*/
+	rendering: _sinclair_typebox.Type.Object({
+		/**
+		* Whether to generate ES Module code
+		*
+		* If not specified, the module system will be inferred from the nearest package.json "type" field
+		* or defaults to "cjs" if no package.json is found.
+		*/
+		esm: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Boolean({ default: false })),
+		/**
+		* File naming style for generated files
+		*/
+		fileNamingStyle: _sinclair_typebox.Type.Enum(FileNamingStyle, { default: "snakeCase" }),
+		/**
+		* Controls how `additionalProperties: true` (or undefined) is rendered in generated TypeScript types.
+		*
+		* - `'unknown'` (default): renders as `unknown`, which is stricter and type-safe
+		* - `'any'`: renders as `any`, which is more permissive
+		*/
+		additionalPropertiesType: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Union([_sinclair_typebox.Type.Literal("unknown"), _sinclair_typebox.Type.Literal("any")], { default: "unknown" })),
+		/**
+		* Whether to generate entrypoint (index) files that re-export all generated modules.
+		*
+		* Disable this to avoid merge conflicts in multi-branch collaborative development,
+		* as auto-generated index files change frequently.
+		*/
+		entrypoint: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Boolean({ default: false }))
+	}, { default: {} }),
+	/**
+	* OpenAPI/Swagger document sources
+	*
+	* A map of module names to their document URLs or Address objects.
+	* The module name must be a valid JavaScript identifier.
+	*/
+	modules: Modules,
+	/**
+	* Enable debug mode to output detailed logs during compilation
+	*/
+	debug: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Boolean({ default: false })),
+	/**
+	* Whether to tolerate wrong openapi/swagger structure
+	*/
+	tolerant: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Boolean({ default: false })),
+	/**
+	* Translators to transform generated code
+	*
+	* Used to customize the code generation process for different frameworks or patterns.
+	* Can be a single translator or an array of translators.
+	*/
+	translators: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Transform(_sinclair_typebox.Type.Union([_sinclair_typebox.Type.Unsafe(_sinclair_typebox.Type.Any()), _sinclair_typebox.Type.Array(_sinclair_typebox.Type.Unsafe(_sinclair_typebox.Type.Any()))], { default: [] })).Decode((value) => {
+		if (value === void 0) return [];
+		if (Array.isArray(value)) return value;
+		return [value];
+	}).Encode((value) => value)),
+	/**
+	* Plugins to extend code generation functionality
+	*
+	* An array of plugin instances that can hook into various stages of the compilation process,
+	* such as code transformation, formatting, linting, or custom file generation.
+	*/
+	plugins: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Array(_sinclair_typebox.Type.Unsafe(_sinclair_typebox.Type.Any()), { default: [] }))
+});
+//#endregion
+//#region src/compiler/tasks/setup/utils/parse-runtime-config.ts
+function parseRuntimeConfig(data) {
+	try {
+		const record = typeof data === "object" && data !== null ? data : void 0;
+		const originalPlugins = record && "plugins" in record ? record.plugins : void 0;
+		const originalTranslators = record && "translators" in record ? record.translators : void 0;
+		const sanitized = record ? { ...record } : data;
+		if (record) {
+			delete sanitized.plugins;
+			delete sanitized.translators;
+		}
+		const parsed = _sinclair_typebox_value.Value.Parse(RawConfig, sanitized);
+		if (originalPlugins !== void 0) parsed.plugins = originalPlugins;
+		if (originalTranslators !== void 0) parsed.translators = originalTranslators;
+		return parsed;
+	} catch (error) {
+		if (error instanceof Error) error.message = `Invalid Config: ${error.message}`;
+		throw error;
+	}
+}
+//#endregion
+//#region src/compiler/tasks/setup/index.ts
+const explore = (0, cosmiconfig.cosmiconfig)("keq");
+function main$3(compiler, options) {
+	return { task: async (context, task) => {
+		const result = options?.config ? await explore.load(options.config) : await explore.search();
+		if (!result || "isEmpty" in result && result.isEmpty) throw new Error("Cannot find config file.");
+		const rc = parseRuntimeConfig(result.config);
+		if (options?.debug) {
+			await fs_extra.default.ensureDir(".keq");
+			rc.debug = true;
+		}
+		rc.tolerant = Boolean(rc.tolerant || options?.tolerant);
+		if (!rc.translators || !rc.translators.length) rc.translators = [new require_micro_function_translator.MicroFunctionTranslator()];
+		const packageJsonInfo = findNearestPackageJson();
+		if (packageJsonInfo) {
+			const moduleSystem = getProjectModuleSystem(packageJsonInfo);
+			rc.rendering.esm = moduleSystem === "esm";
+		}
+		context.rc = rc;
+		let matcher = new Matcher([]);
+		if (options.filter !== false && result.filepath) {
+			const filterFilepath = path.default.resolve(path.default.dirname(result.filepath), ".keqfilter");
+			if (await fs_extra.default.exists(filterFilepath)) matcher = await Matcher.read(filterFilepath);
+		}
+		const filterRules = options.filter === false ? [] : options.filter?.rules || [];
+		for (const rule of filterRules) matcher.append({
+			persist: !!rule.persist,
+			deny: rule.deny,
+			moduleName: rule.moduleName,
+			operationMethod: rule.operationMethod,
+			operationPathname: rule.operationPathname
+		});
+		context.matcher = matcher;
+		await compiler.hooks.setup.promise(task);
+	} };
+}
+function createSetupTask(compiler, options) {
+	return {
+		title: "Setup",
+		enabled: options?.enabled,
+		skip: options?.skip,
+		task: (context, task) => task.newListr([main$3(compiler, options), { task: (context, task) => compiler.hooks.afterSetup.promise(task) }], { concurrent: false })
+	};
+}
+//#endregion
+//#region src/compiler/tasks/download/validate-spec.ts
+async function validateSpec(spec, options) {
+	const { valid, errors } = await (0, _scalar_openapi_parser.validate)(spec);
+	if (valid) return { valid: true };
+	const errorLines = errors?.map((e) => {
+		const path = e.path;
+		if (path) {
+			const readablePath = path.replace(/~1/g, "/").replace(/~0/g, "~");
+			return `  - ${e.message}\n    at: ${readablePath}`;
+		}
+		return `  - ${e.message}`;
+	}).join("\n");
+	let message = `${options.moduleDefinition.name} module openapi/swagger file does not conform to the openapi specifications or have grammatical errors, which may cause unexpected errors: \n${errorLines}`;
+	if (errors?.some((e) => e.message?.includes("Error-ModelName"))) message += "\n\n  [Hint] \"Error-ModelName\" in $ref indicates that SpringDoc failed to resolve a Java class. Check that the referenced class (e.g. cn.dotfashion.soa.api.vo.Response) is on the classpath and properly annotated with @Schema.";
+	if (errors?.some((e) => e.message?.includes("Property extensions is not expected to be here"))) message += "\n\n  [Hint] \"Property extensions is not expected to be here\" is typically caused by SpringDoc/Swagger wrapping x- extensions in an \"extensions\" object. Add SpringdocCompatPlugin to your config plugins to fix this automatically.";
+	if (options.tolerant) return {
+		valid: false,
+		warning: message
+	};
+	throw new require_plugins.Exception(options.moduleDefinition, message);
+}
+//#endregion
+//#region src/compiler/tasks/download/index.ts
+function main$2(compiler, options) {
+	return { task: (context, task) => {
+		if (!context.rc || !context.matcher) throw new Error("Please run setup task first.");
+		const rc = context.rc;
+		const matcher = context.matcher;
+		context.documents = [];
+		return task.newListr(Object.entries(rc.modules).map(([moduleName, address]) => new require_plugins.ModuleDefinition(moduleName, address)).map((moduleDefinition) => ({
+			title: moduleDefinition.name,
+			task: async (ctx, task) => {
+				if (options?.skipFilteredModules && matcher.isModuleDenied(moduleDefinition)) {
+					task.skip(`(${moduleDefinition.name}) is filtered`);
+					return;
+				}
+				task.output = `Downloaded from ${moduleDefinition.address.url}`;
+				const content = await compiler.hooks.download.promise(moduleDefinition.address, moduleDefinition, task);
+				if (!content) throw new require_plugins.Exception(moduleDefinition, `Cannot download document from ${moduleDefinition.address.url}`);
+				const spec = JSON.parse(content);
+				await compiler.hooks.beforeValidate.promise(spec, moduleDefinition);
+				const result = await validateSpec(spec, {
+					moduleDefinition,
+					tolerant: !!compiler.options.tolerant
+				});
+				if (result.warning) task.output = result.warning;
+				require_plugins.OpenapiUtils.dereferenceOperation(spec);
+				const document = new require_plugins.ApiDocumentV3_1(spec, moduleDefinition);
+				ctx.documents?.push(document);
+			}
+		})), {
+			concurrent: true,
+			exitOnError: !compiler.options.tolerant,
+			collectErrors: compiler.options.tolerant ? "minimal" : false,
+			rendererOptions: {
+				collapseSubtasks: false,
+				suffixSkips: true,
+				timer: listr2.PRESET_TIMER
+			}
+		});
+	} };
+}
+function createDownloadTask(compiler, options) {
+	return {
+		title: "Download",
+		enabled: options?.enabled,
+		skip: options?.skip,
+		task: (_, task) => task.newListr([main$2(compiler, options), { task: (context, task) => compiler.hooks.afterDownload.promise(task) }], { concurrent: false })
+	};
+}
+//#endregion
+//#region src/compiler/tasks/persist/index.ts
+function createPersistArtifactTask() {
+	return {
+		title: "Write files",
+		task: async (context, task) => {
+			if (!context.rc) throw new Error("Please run setup task first.");
+			if (!context.artifacts || context.artifacts.length === 0) {
+				task.skip("No compiled artifacts to persist.");
+				return;
+			}
+			const rc = context.rc;
+			const artifacts = context.artifacts;
+			const total = artifacts.length;
+			let completed = 0;
+			context.assets = await Promise.all(artifacts.map(async (artifact) => {
+				const realpath = `./${path.join(rc.outdir, artifact.filepath)}`;
+				await fs_extra.default.ensureFile(realpath);
+				await fs_extra.default.writeFile(realpath, artifact.renderer());
+				completed += 1;
+				task.output = `Persisted ${completed}/${total} files`;
+				return new require_plugins.Asset(path.resolve(realpath));
+			}));
+		}
+	};
+}
+function createPersistFilterTask() {
+	return {
+		title: "Update .keqfilter",
+		task: async (context, task) => {
+			if (!context.matcher) throw new Error("Please run setup task first.");
+			await context.matcher.write(".keqfilter");
+		}
+	};
+}
+function main$1() {
+	return { task: (context, task) => task.newListr([createPersistArtifactTask(), createPersistFilterTask()], {
+		concurrent: true,
+		rendererOptions: { collapseSubtasks: true }
+	}) };
+}
+function createPersistTask(compiler, options) {
+	return {
+		title: "Persist",
+		enabled: options?.enabled,
+		skip: options?.skip,
+		task: (context, task) => task.newListr([
+			{ task: (context, task) => compiler.hooks.beforePersist.promise(task) },
+			main$1(),
+			{ task: (context, task) => compiler.hooks.afterPersist.promise(task) }
+		], { concurrent: false })
+	};
+}
+//#endregion
+//#region src/compiler/tasks/compile/index.ts
+function main(compiler) {
+	return { task: async (context, task) => {
+		if (!context.rc) throw new Error("Please run setup task first.");
+		if (!context.documents) throw new Error("Please run shaking task first.");
+		context.artifacts = [];
+		await compiler.hooks.compile.promise(task);
+	} };
+}
+function createCompileTask(compiler, options) {
+	return {
+		title: "Compile",
+		enabled: options?.enabled,
+		skip: options?.skip,
+		task: (context, task) => task.newListr([
+			{ task: (context, task) => compiler.hooks.beforeCompile.promise(task) },
+			main(compiler),
+			{ task: (context, task) => compiler.hooks.afterCompile.promise(task) }
+		], { concurrent: false })
+	};
+}
+//#endregion
+//#region src/compiler/intercepter/print-information.ts
+function proxyTaskWrapper(pluginName, task) {
+	return new Proxy(task, { set(target, prop, value) {
+		if (prop !== "output") return Reflect.set(target, prop, value);
+		target.output = `[Plugin: ${pluginName}] ${value}`;
+		return true;
+	} });
+}
+function printInformation(taskIndex) {
+	return { register: (tap) => {
+		const fn = tap.fn;
+		if (tap.type === "promise") tap.fn = (...args) => {
+			const task = args[taskIndex];
+			const proxyTask = proxyTaskWrapper(tap.name, task);
+			args[taskIndex] = proxyTask;
+			proxyTask.output = "Processing...";
+			return fn(...args);
+		};
+		if (tap.type === "sync") tap.fn = (...args) => {
+			const task = args[taskIndex];
+			const proxyTask = proxyTaskWrapper(tap.name, task);
+			args[taskIndex] = proxyTask;
+			proxyTask.output = "Processing...";
+			return fn(...args);
+		};
+		if (tap.type === "async") tap.fn = (...args) => {
+			const task = args[taskIndex];
+			const proxyTask = proxyTaskWrapper(tap.name, task);
+			args[taskIndex] = proxyTask;
+			proxyTask.output = "Processing...";
+			return fn(...args);
+		};
+		return tap;
+	} };
+}
+//#endregion
+//#region src/compiler/intercepter/perfect-error-message.ts
+function perfectErrorMessage() {
+	return { register: (tap) => {
+		const fn = tap.fn;
+		function prefix(err) {
+			if (err instanceof Error) err.message = `[Plugin: ${tap.name}] ${err.message}`;
+		}
+		if (tap.type === "promise") tap.fn = async (...args) => {
+			try {
+				return await fn(...args);
+			} catch (err) {
+				prefix(err);
+				throw err;
+			}
+		};
+		if (tap.type === "sync") tap.fn = (...args) => {
+			try {
+				return fn(...args);
+			} catch (err) {
+				prefix(err);
+				throw err;
+			}
+		};
+		if (tap.type === "async") tap.fn = (...args) => {
+			const callback = ramda.last(args);
+			return fn(...ramda.init(args), (err, result) => {
+				prefix(err);
+				return callback(err, result);
+			});
+		};
+		return tap;
+	} };
+}
+//#endregion
+//#region src/compiler/compiler.ts
+var Compiler = class {
+	context = {};
+	hooks = {
+		setup: new tapable.AsyncParallelHook(["task"]),
+		afterSetup: new tapable.AsyncSeriesHook(["task"]),
+		beforeDownload: new tapable.AsyncSeriesHook(["task"]),
+		download: new tapable.AsyncSeriesBailHook([
+			"address",
+			"moduleDefinition",
+			"task"
+		]),
+		beforeValidate: new tapable.AsyncSeriesHook(["spec", "moduleDefinition"]),
+		afterDownload: new tapable.AsyncSeriesHook(["task"]),
+		beforeCompile: new tapable.AsyncSeriesHook(["task"]),
+		compile: new tapable.AsyncParallelHook(["task"]),
+		afterCompile: new tapable.AsyncSeriesHook(["task"]),
+		beforePersist: new tapable.AsyncSeriesHook(["task"]),
+		persist: new tapable.AsyncParallelHook(["task"]),
+		afterPersist: new tapable.AsyncSeriesHook(["task"]),
+		done: new tapable.SyncHook()
+	};
+	constructor(options) {
+		this.options = options;
+		for (const hook of Object.values(this.hooks)) hook.intercept(perfectErrorMessage());
+		this.hooks.afterSetup.intercept(printInformation(0));
+		this.hooks.afterPersist.intercept(printInformation(0));
+		new require_plugins.InitializePlugin({
+			build: options.build,
+			fresh: options.fresh,
+			interactive: options.interactive
+		}).apply(this);
+	}
+	async run() {
+		const options = this.options;
+		await new listr2.Listr([
+			createSetupTask(this, options),
+			createDownloadTask(this, { skipFilteredModules: !options.interactive }),
+			createCompileTask(this, { enabled: !!options.build }),
+			createPersistTask(this, { enabled: !!options.persist })
+		], {
+			concurrent: false,
+			renderer: options.silent ? "silent" : "default",
+			rendererOptions: {
+				suffixSkips: true,
+				collapseSubtasks: false,
+				collapseErrors: false
+			}
+		}).run(this.context);
+		await this.hooks.done.promise();
+	}
+};
+//#endregion
+Object.defineProperty(exports, "Compiler", {
+	enumerable: true,
+	get: function() {
+		return Compiler;
+	}
+});
+Object.defineProperty(exports, "FileNamingStyle", {
+	enumerable: true,
+	get: function() {
+		return FileNamingStyle;
+	}
+});
+Object.defineProperty(exports, "Matcher", {
+	enumerable: true,
+	get: function() {
+		return Matcher;
+	}
+});
+
+//# sourceMappingURL=compiler-0Kli6UCr.cjs.map