@agiflowai/scaffold-mcp 0.3.0 → 0.3.2

package/dist/ScaffoldConfigLoader-BhrrsLya.js

@@ -0,0 +1,3 @@
+const require_ScaffoldConfigLoader = require('./ScaffoldConfigLoader-CvIJEFcI.js');
+
+exports.ScaffoldConfigLoader = require_ScaffoldConfigLoader.ScaffoldConfigLoader;

package/dist/{ScaffoldConfigLoader-CI0T6zdG.js → ScaffoldConfigLoader-CvIJEFcI.js}

@@ -1,42 +1,46 @@
-import path from "node:path";
-import yaml from "js-yaml";
-import { z } from "zod";
+const require_chunk = require('./chunk-nOFOJqeH.js');
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let js_yaml = require("js-yaml");
+js_yaml = require_chunk.__toESM(js_yaml);
+let zod = require("zod");
+zod = require_chunk.__toESM(zod);
 
 //#region src/services/ScaffoldConfigLoader.ts
-const VariablesSchemaSchema = z.object({
-	type: z.literal("object"),
-	properties: z.record(z.any()),
-	required: z.array(z.string()),
-	additionalProperties: z.boolean()
+const VariablesSchemaSchema = zod.z.object({
+	type: zod.z.literal("object"),
+	properties: zod.z.record(zod.z.any()),
+	required: zod.z.array(zod.z.string()),
+	additionalProperties: zod.z.boolean()
 });
-const ScaffoldConfigEntrySchema = z.object({
-	name: z.string(),
-	description: z.string().optional(),
-	instruction: z.string().optional(),
-	targetFolder: z.string().optional(),
+const ScaffoldConfigEntrySchema = zod.z.object({
+	name: zod.z.string(),
+	description: zod.z.string().optional(),
+	instruction: zod.z.string().optional(),
+	targetFolder: zod.z.string().optional(),
 	variables_schema: VariablesSchemaSchema,
-	includes: z.array(z.string()),
-	generator: z.string().optional(),
-	patterns: z.array(z.string()).optional()
+	includes: zod.z.array(zod.z.string()),
+	generator: zod.z.string().optional(),
+	patterns: zod.z.array(zod.z.string()).optional()
 });
-const ScaffoldYamlSchema = z.object({
-	boilerplate: z.union([ScaffoldConfigEntrySchema, z.array(ScaffoldConfigEntrySchema)]).optional(),
-	features: z.union([ScaffoldConfigEntrySchema, z.array(ScaffoldConfigEntrySchema)]).optional()
-}).catchall(z.union([ScaffoldConfigEntrySchema, z.array(ScaffoldConfigEntrySchema)]));
+const ScaffoldYamlSchema = zod.z.object({
+	boilerplate: zod.z.union([ScaffoldConfigEntrySchema, zod.z.array(ScaffoldConfigEntrySchema)]).optional(),
+	features: zod.z.union([ScaffoldConfigEntrySchema, zod.z.array(ScaffoldConfigEntrySchema)]).optional()
+}).catchall(zod.z.union([ScaffoldConfigEntrySchema, zod.z.array(ScaffoldConfigEntrySchema)]));
 var ScaffoldConfigLoader = class {
 	constructor(fileSystem, templateService) {
 		this.fileSystem = fileSystem;
 		this.templateService = templateService;
 	}
 	async parseArchitectConfig(templatePath) {
-		const architectPath = path.join(templatePath, "scaffold.yaml");
+		const architectPath = node_path.default.join(templatePath, "scaffold.yaml");
 		if (!await this.fileSystem.pathExists(architectPath)) return null;
 		try {
 			const content = await this.fileSystem.readFile(architectPath, "utf8");
-			const rawConfig = yaml.load(content);
+			const rawConfig = js_yaml.default.load(content);
 			return ScaffoldYamlSchema.parse(rawConfig);
 		} catch (error) {
-			if (error instanceof z.ZodError) {
+			if (error instanceof zod.z.ZodError) {
 				const errorMessages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("; ");
 				throw new Error(`scaffold.yaml validation failed: ${errorMessages}`);
 			}
@@ -124,7 +128,7 @@ var ScaffoldConfigLoader = class {
 		const config = architectConfig[scaffoldType];
 		if (config.includes && Array.isArray(config.includes)) for (const includeFile of config.includes) {
 			const parsed = this.parseIncludeEntry(includeFile, {});
-			const sourcePath = path.join(templatePath, parsed.sourcePath);
+			const sourcePath = node_path.default.join(templatePath, parsed.sourcePath);
 			const liquidSourcePath = `${sourcePath}.liquid`;
 			const sourceExists = await this.fileSystem.pathExists(sourcePath);
 			const liquidExists = await this.fileSystem.pathExists(liquidSourcePath);
@@ -139,4 +143,9 @@ var ScaffoldConfigLoader = class {
 };
 
 //#endregion
-export { ScaffoldConfigLoader };
+Object.defineProperty(exports, 'ScaffoldConfigLoader', {
+  enumerable: true,
+  get: function () {
+    return ScaffoldConfigLoader;
+  }
+});

package/dist/ScaffoldService-CEJt8Yw4.js

@@ -0,0 +1,4 @@
+require('./logger-Dno88AK9.js');
+const require_ScaffoldService = require('./ScaffoldService-N6X24Vw0.js');
+
+exports.ScaffoldService = require_ScaffoldService.ScaffoldService;

package/dist/{ScaffoldService-CnJ1nj1v.js → ScaffoldService-N6X24Vw0.js}

@@ -1,12 +1,12 @@
-import { createRequire } from "node:module";
-import path from "node:path";
-import * as fs$1 from "fs-extra";
-import { fileURLToPath } from "node:url";
+const require_chunk = require('./chunk-nOFOJqeH.js');
+const require_logger = require('./logger-Dno88AK9.js');
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let fs_extra = require("fs-extra");
+fs_extra = require_chunk.__toESM(fs_extra);
+let node_url = require("node:url");
+node_url = require_chunk.__toESM(node_url);
 
-//#region rolldown:runtime
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-//#endregion
 //#region src/services/ScaffoldProcessingService.ts
 /**
 * Shared service for common scaffolding operations like processing templates and tracking files
@@ -43,7 +43,7 @@ var ScaffoldProcessingService = class {
 	* Automatically handles .liquid template files by stripping the extension
 	*/
 	async copyAndProcess(sourcePath, targetPath, variables, createdFiles, existingFiles) {
-		await this.fileSystem.ensureDir(path.dirname(targetPath));
+		await this.fileSystem.ensureDir(node_path.default.dirname(targetPath));
 		if (await this.fileSystem.pathExists(targetPath) && existingFiles) {
 			await this.trackExistingFiles(targetPath, existingFiles);
 			return;
@@ -66,18 +66,18 @@ var ScaffoldProcessingService = class {
 		try {
 			items = await this.fileSystem.readdir(dirPath);
 		} catch (error) {
-			console.warn(`Cannot read directory ${dirPath}: ${error}`);
+			require_logger.log.warn(`Cannot read directory ${dirPath}: ${error}`);
 			return;
 		}
 		for (const item of items) {
 			if (!item) continue;
-			const itemPath = path.join(dirPath, item);
+			const itemPath = node_path.default.join(dirPath, item);
 			try {
 				const stat = await this.fileSystem.stat(itemPath);
 				if (stat.isDirectory()) await this.trackCreatedFilesRecursive(itemPath, createdFiles);
 				else if (stat.isFile()) createdFiles.push(itemPath);
 			} catch (error) {
-				console.warn(`Cannot stat ${itemPath}: ${error}`);
+				require_logger.log.warn(`Cannot stat ${itemPath}: ${error}`);
 			}
 		}
 	}
@@ -89,18 +89,18 @@ var ScaffoldProcessingService = class {
 		try {
 			items = await this.fileSystem.readdir(dirPath);
 		} catch (error) {
-			console.warn(`Cannot read directory ${dirPath}: ${error}`);
+			require_logger.log.warn(`Cannot read directory ${dirPath}: ${error}`);
 			return;
 		}
 		for (const item of items) {
 			if (!item) continue;
-			const itemPath = path.join(dirPath, item);
+			const itemPath = node_path.default.join(dirPath, item);
 			try {
 				const stat = await this.fileSystem.stat(itemPath);
 				if (stat.isDirectory()) await this.trackExistingFilesRecursive(itemPath, existingFiles);
 				else if (stat.isFile()) existingFiles.push(itemPath);
 			} catch (error) {
-				console.warn(`Cannot stat ${itemPath}: ${error}`);
+				require_logger.log.warn(`Cannot stat ${itemPath}: ${error}`);
 			}
 		}
 	}
@@ -129,32 +129,32 @@ var TemplatesManager = class TemplatesManager {
 	*/
 	static async findTemplatesPath(startPath = process.cwd()) {
 		const workspaceRoot = await TemplatesManager.findWorkspaceRoot(startPath);
-		const toolkitConfigPath = path.join(workspaceRoot, TemplatesManager.TOOLKIT_CONFIG_FILE);
-		if (await fs$1.pathExists(toolkitConfigPath)) {
+		const toolkitConfigPath = node_path.default.join(workspaceRoot, TemplatesManager.TOOLKIT_CONFIG_FILE);
+		if (await fs_extra.pathExists(toolkitConfigPath)) {
 			const yaml = await import("js-yaml");
-			const content = await fs$1.readFile(toolkitConfigPath, "utf-8");
+			const content = await fs_extra.readFile(toolkitConfigPath, "utf-8");
 			const config = yaml.load(content);
 			if (config?.templatesPath) {
-				const templatesPath$1 = path.isAbsolute(config.templatesPath) ? config.templatesPath : path.join(workspaceRoot, config.templatesPath);
-				if (await fs$1.pathExists(templatesPath$1)) return templatesPath$1;
+				const templatesPath$1 = node_path.default.isAbsolute(config.templatesPath) ? config.templatesPath : node_path.default.join(workspaceRoot, config.templatesPath);
+				if (await fs_extra.pathExists(templatesPath$1)) return templatesPath$1;
 				else throw new Error(`Templates path specified in toolkit.yaml does not exist: ${templatesPath$1}`);
 			}
 		}
-		const templatesPath = path.join(workspaceRoot, TemplatesManager.TEMPLATES_FOLDER);
-		if (await fs$1.pathExists(templatesPath)) return templatesPath;
+		const templatesPath = node_path.default.join(workspaceRoot, TemplatesManager.TEMPLATES_FOLDER);
+		if (await fs_extra.pathExists(templatesPath)) return templatesPath;
 		throw new Error(`Templates folder not found at ${templatesPath}.\nEither create a 'templates' folder or specify templatesPath in toolkit.yaml`);
 	}
 	/**
 	* Find the workspace root by searching upwards for .git folder
 	*/
 	static async findWorkspaceRoot(startPath) {
-		let currentPath = path.resolve(startPath);
-		const rootPath = path.parse(currentPath).root;
+		let currentPath = node_path.default.resolve(startPath);
+		const rootPath = node_path.default.parse(currentPath).root;
 		while (true) {
-			const gitPath = path.join(currentPath, ".git");
-			if (await fs$1.pathExists(gitPath)) return currentPath;
+			const gitPath = node_path.default.join(currentPath, ".git");
+			if (await fs_extra.pathExists(gitPath)) return currentPath;
 			if (currentPath === rootPath) return process.cwd();
-			currentPath = path.dirname(currentPath);
+			currentPath = node_path.default.dirname(currentPath);
 		}
 	}
 	/**
@@ -167,32 +167,32 @@ var TemplatesManager = class TemplatesManager {
 	*/
 	static findTemplatesPathSync(startPath = process.cwd()) {
 		const workspaceRoot = TemplatesManager.findWorkspaceRootSync(startPath);
-		const toolkitConfigPath = path.join(workspaceRoot, TemplatesManager.TOOLKIT_CONFIG_FILE);
-		if (fs$1.pathExistsSync(toolkitConfigPath)) {
-			const yaml = __require("js-yaml");
-			const content = fs$1.readFileSync(toolkitConfigPath, "utf-8");
+		const toolkitConfigPath = node_path.default.join(workspaceRoot, TemplatesManager.TOOLKIT_CONFIG_FILE);
+		if (fs_extra.pathExistsSync(toolkitConfigPath)) {
+			const yaml = require("js-yaml");
+			const content = fs_extra.readFileSync(toolkitConfigPath, "utf-8");
 			const config = yaml.load(content);
 			if (config?.templatesPath) {
-				const templatesPath$1 = path.isAbsolute(config.templatesPath) ? config.templatesPath : path.join(workspaceRoot, config.templatesPath);
-				if (fs$1.pathExistsSync(templatesPath$1)) return templatesPath$1;
+				const templatesPath$1 = node_path.default.isAbsolute(config.templatesPath) ? config.templatesPath : node_path.default.join(workspaceRoot, config.templatesPath);
+				if (fs_extra.pathExistsSync(templatesPath$1)) return templatesPath$1;
 				else throw new Error(`Templates path specified in toolkit.yaml does not exist: ${templatesPath$1}`);
 			}
 		}
-		const templatesPath = path.join(workspaceRoot, TemplatesManager.TEMPLATES_FOLDER);
-		if (fs$1.pathExistsSync(templatesPath)) return templatesPath;
+		const templatesPath = node_path.default.join(workspaceRoot, TemplatesManager.TEMPLATES_FOLDER);
+		if (fs_extra.pathExistsSync(templatesPath)) return templatesPath;
 		throw new Error(`Templates folder not found at ${templatesPath}.\nEither create a 'templates' folder or specify templatesPath in toolkit.yaml`);
 	}
 	/**
 	* Find the workspace root synchronously by searching upwards for .git folder
 	*/
 	static findWorkspaceRootSync(startPath) {
-		let currentPath = path.resolve(startPath);
-		const rootPath = path.parse(currentPath).root;
+		let currentPath = node_path.default.resolve(startPath);
+		const rootPath = node_path.default.parse(currentPath).root;
 		while (true) {
-			const gitPath = path.join(currentPath, ".git");
-			if (fs$1.pathExistsSync(gitPath)) return currentPath;
+			const gitPath = node_path.default.join(currentPath, ".git");
+			if (fs_extra.pathExistsSync(gitPath)) return currentPath;
 			if (currentPath === rootPath) return process.cwd();
-			currentPath = path.dirname(currentPath);
+			currentPath = node_path.default.dirname(currentPath);
 		}
 	}
 	/**
@@ -202,8 +202,8 @@ var TemplatesManager = class TemplatesManager {
 	* @returns true if templates folder exists and is a directory
 	*/
 	static async isInitialized(templatesPath) {
-		if (!await fs$1.pathExists(templatesPath)) return false;
-		return (await fs$1.stat(templatesPath)).isDirectory();
+		if (!await fs_extra.pathExists(templatesPath)) return false;
+		return (await fs_extra.stat(templatesPath)).isDirectory();
 	}
 	/**
 	* Get the scaffold config file name
@@ -237,8 +237,8 @@ var ScaffoldService = class {
 	async useBoilerplate(options) {
 		try {
 			const { projectName, packageName, targetFolder, templateFolder, boilerplateName, variables = {} } = options;
-			const targetPath = path.isAbsolute(targetFolder) ? path.join(targetFolder, projectName) : path.join(process.cwd(), targetFolder, projectName);
-			const templatePath = path.join(this.templatesRootPath, templateFolder);
+			const targetPath = node_path.default.isAbsolute(targetFolder) ? node_path.default.join(targetFolder, projectName) : node_path.default.join(process.cwd(), targetFolder, projectName);
+			const templatePath = node_path.default.join(this.templatesRootPath, templateFolder);
 			const validationResult = await this.scaffoldConfigLoader.validateTemplate(templatePath, "boilerplate");
 			if (!validationResult.isValid) return {
 				success: false,
@@ -287,9 +287,9 @@ var ScaffoldService = class {
 	async useFeature(options) {
 		try {
 			const { projectPath, templateFolder, featureName, variables = {} } = options;
-			const targetPath = path.resolve(projectPath);
-			const templatePath = path.join(this.templatesRootPath, templateFolder);
-			const projectName = path.basename(targetPath);
+			const targetPath = node_path.default.resolve(projectPath);
+			const templatePath = node_path.default.join(this.templatesRootPath, templateFolder);
+			const projectName = node_path.default.basename(targetPath);
 			const validationResult = await this.scaffoldConfigLoader.validateTemplate(templatePath, "features");
 			if (!validationResult.isValid) return {
 				success: false,
@@ -338,12 +338,12 @@ var ScaffoldService = class {
 	*/
 	async processScaffold(params) {
 		const { config, targetPath, templatePath, allVariables, scaffoldType } = params;
-		console.log("Config generator:", config.generator);
-		console.log("Config:", JSON.stringify(config, null, 2));
+		require_logger.log.debug("Config generator:", config.generator);
+		require_logger.log.debug("Config:", JSON.stringify(config, null, 2));
 		if (config.generator) {
-			console.log("Using custom generator:", config.generator);
+			require_logger.log.info("Using custom generator:", config.generator);
 			try {
-				const generator = (await import(path.join(templatePath, "generators", config.generator))).default;
+				const generator = (await import(node_path.default.join(templatePath, "generators", config.generator))).default;
 				if (typeof generator !== "function") return {
 					success: false,
 					message: `Invalid generator: ${config.generator} does not export a default function`
@@ -358,12 +358,12 @@ var ScaffoldService = class {
 					variableReplacer: this.variableReplacer,
 					ScaffoldProcessingService: this.processingService.constructor,
 					getRootPath: () => {
-						const __dirname = path.dirname(fileURLToPath(import.meta.url));
-						return path.join(__dirname, "../../../../..");
+						const __dirname$1 = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+						return node_path.default.join(__dirname$1, "../../../../..");
 					},
 					getProjectPath: (projectPath) => {
-						const __dirname = path.dirname(fileURLToPath(import.meta.url));
-						const rootPath = path.join(__dirname, "../../../../..");
+						const __dirname$1 = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+						const rootPath = node_path.default.join(__dirname$1, "../../../../..");
 						return projectPath.replace(rootPath, "").replace("/", "");
 					}
 				});
@@ -380,15 +380,15 @@ var ScaffoldService = class {
 			const parsed = this.scaffoldConfigLoader.parseIncludeEntry(includeEntry, allVariables);
 			if (!this.scaffoldConfigLoader.shouldIncludeFile(parsed.conditions, allVariables)) continue;
 			parsedIncludes.push(parsed);
-			const targetFilePath = path.join(targetPath, parsed.targetPath);
+			const targetFilePath = node_path.default.join(targetPath, parsed.targetPath);
 			if (await this.fileSystem.pathExists(targetFilePath)) warnings.push(`File/folder ${parsed.targetPath} already exists and will be preserved`);
 		}
 		await this.fileSystem.ensureDir(targetPath);
 		const createdFiles = [];
 		const existingFiles = [];
 		for (const parsed of parsedIncludes) {
-			const sourcePath = path.join(templatePath, parsed.sourcePath);
-			const targetFilePath = path.join(targetPath, parsed.targetPath);
+			const sourcePath = node_path.default.join(templatePath, parsed.sourcePath);
+			const targetFilePath = node_path.default.join(targetPath, parsed.targetPath);
 			await this.processingService.copyAndProcess(sourcePath, targetFilePath, allVariables, createdFiles, existingFiles);
 		}
 		let message = `Successfully scaffolded ${scaffoldType} at ${targetPath}`;
@@ -405,4 +405,15 @@ var ScaffoldService = class {
 };
 
 //#endregion
-export { ScaffoldService, TemplatesManager };
+Object.defineProperty(exports, 'ScaffoldService', {
+  enumerable: true,
+  get: function () {
+    return ScaffoldService;
+  }
+});
+Object.defineProperty(exports, 'TemplatesManager', {
+  enumerable: true,
+  get: function () {
+    return TemplatesManager;
+  }
+});

package/dist/{TemplateService-CnxvhRVW.js → TemplateService-Em2i9bb7.js}

@@ -1,14 +1,18 @@
-import { Liquid } from "liquidjs";
+const require_chunk = require('./chunk-nOFOJqeH.js');
+const require_logger = require('./logger-Dno88AK9.js');
+let liquidjs = require("liquidjs");
+liquidjs = require_chunk.__toESM(liquidjs);
 
 //#region src/services/TemplateService.ts
 var TemplateService = class {
 	liquid;
 	constructor() {
-		this.liquid = new Liquid({
+		this.liquid = new liquidjs.Liquid({
 			strictFilters: false,
 			strictVariables: false
 		});
 		this.setupCustomFilters();
+		require_logger.log.info("TemplateService initialized");
 	}
 	toPascalCase(str) {
 		const camelCase = str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "");
@@ -46,12 +50,25 @@ var TemplateService = class {
 			else if (str.endsWith("s") && !str.endsWith("ss")) return str.slice(0, -1);
 			else return str;
 		});
+		this.liquid.registerFilter("strip", (str) => {
+			return str.trim();
+		});
 	}
 	renderString(template, variables) {
 		try {
-			return this.liquid.parseAndRenderSync(template, variables);
+			require_logger.log.debug("Rendering template", {
+				variables,
+				templatePreview: template.substring(0, 100)
+			});
+			const result = this.liquid.parseAndRenderSync(template, variables);
+			require_logger.log.debug("Rendered template", { resultPreview: result.substring(0, 100) });
+			return result;
 		} catch (error) {
-			console.warn(`LiquidJS rendering error: ${error}`);
+			require_logger.log.error("LiquidJS rendering error", {
+				error: error instanceof Error ? error.message : String(error),
+				templatePreview: template.substring(0, 200),
+				variables
+			});
 			return template;
 		}
 	}
@@ -61,4 +78,9 @@ var TemplateService = class {
 };
 
 //#endregion
-export { TemplateService };
+Object.defineProperty(exports, 'TemplateService', {
+  enumerable: true,
+  get: function () {
+    return TemplateService;
+  }
+});

package/dist/TemplateService-Z2SW_58N.js

@@ -0,0 +1,4 @@
+require('./logger-Dno88AK9.js');
+const require_TemplateService = require('./TemplateService-Em2i9bb7.js');
+
+exports.TemplateService = require_TemplateService.TemplateService;

package/dist/{VariableReplacementService-Bq0GDhTo.js → VariableReplacementService-BGmF2DVE.js}

@@ -1,4 +1,7 @@
-import path from "node:path";
+const require_chunk = require('./chunk-nOFOJqeH.js');
+const require_logger = require('./logger-Dno88AK9.js');
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
 
 //#region src/services/VariableReplacementService.ts
 var VariableReplacementService = class {
@@ -30,18 +33,18 @@ var VariableReplacementService = class {
 		try {
 			items = await this.fileSystem.readdir(dirPath);
 		} catch (error) {
-			console.warn(`Skipping directory ${dirPath}: ${error}`);
+			require_logger.log.warn(`Skipping directory ${dirPath}: ${error}`);
 			return;
 		}
 		for (const item of items) {
 			if (!item) continue;
-			const itemPath = path.join(dirPath, item);
+			const itemPath = node_path.default.join(dirPath, item);
 			try {
 				const stat = await this.fileSystem.stat(itemPath);
 				if (stat.isDirectory()) await this.processFilesForVariableReplacement(itemPath, variables);
 				else if (stat.isFile()) await this.replaceVariablesInFile(itemPath, variables);
 			} catch (error) {
-				console.warn(`Skipping item ${itemPath}: ${error}`);
+				require_logger.log.warn(`Skipping item ${itemPath}: ${error}`);
 			}
 		}
 	}
@@ -52,14 +55,19 @@ var VariableReplacementService = class {
 			const renderedContent = this.templateService.renderString(content, variables);
 			await this.fileSystem.writeFile(filePath, renderedContent, "utf8");
 		} catch (error) {
-			console.warn(`Skipping file ${filePath}: ${error}`);
+			require_logger.log.warn(`Skipping file ${filePath}: ${error}`);
 		}
 	}
 	isBinaryFile(filePath) {
-		const ext = path.extname(filePath).toLowerCase();
+		const ext = node_path.default.extname(filePath).toLowerCase();
 		return this.binaryExtensions.includes(ext);
 	}
 };
 
 //#endregion
-export { VariableReplacementService };
+Object.defineProperty(exports, 'VariableReplacementService', {
+  enumerable: true,
+  get: function () {
+    return VariableReplacementService;
+  }
+});

package/dist/VariableReplacementService-BLwdHUSz.js

@@ -0,0 +1,4 @@
+require('./logger-Dno88AK9.js');
+const require_VariableReplacementService = require('./VariableReplacementService-BGmF2DVE.js');
+
+exports.VariableReplacementService = require_VariableReplacementService.VariableReplacementService;

package/dist/chunk-nOFOJqeH.js

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});