unplugin-env 1.0.2 → 1.0.4

package/dist/index.cjs

@@ -1147,7 +1147,7 @@ var require_parse = __commonJS({
       CHAR_NO_BREAK_SPACE,
       CHAR_ZERO_WIDTH_NOBREAK_SPACE
     } = require_constants();
-    var parse = (input, options = {}) => {
+    var parse2 = (input, options = {}) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
       }
@@ -1347,7 +1347,7 @@ var require_parse = __commonJS({
       push({ type: "eos" });
       return ast;
     };
-    module2.exports = parse;
+    module2.exports = parse2;
   }
 });
 
@@ -1358,7 +1358,7 @@ var require_braces = __commonJS({
     var stringify = require_stringify();
     var compile = require_compile();
     var expand = require_expand();
-    var parse = require_parse();
+    var parse2 = require_parse();
     var braces = (input, options = {}) => {
       let output = [];
       if (Array.isArray(input)) {
@@ -1378,7 +1378,7 @@ var require_braces = __commonJS({
       }
       return output;
     };
-    braces.parse = (input, options = {}) => parse(input, options);
+    braces.parse = (input, options = {}) => parse2(input, options);
     braces.stringify = (input, options = {}) => {
       if (typeof input === "string") {
         return stringify(braces.parse(input, options), options);
@@ -1914,7 +1914,7 @@ var require_scan = __commonJS({
         isExtglob = false;
         isGlob = false;
       }
-      let base2 = str;
+      let base = str;
       let prefix = "";
       let glob = "";
       if (start > 0) {
@@ -1922,31 +1922,31 @@ var require_scan = __commonJS({
         str = str.slice(start);
         lastIndex -= start;
       }
-      if (base2 && isGlob === true && lastIndex > 0) {
-        base2 = str.slice(0, lastIndex);
+      if (base && isGlob === true && lastIndex > 0) {
+        base = str.slice(0, lastIndex);
         glob = str.slice(lastIndex);
       } else if (isGlob === true) {
-        base2 = "";
+        base = "";
         glob = str;
       } else {
-        base2 = str;
+        base = str;
       }
-      if (base2 && base2 !== "" && base2 !== "/" && base2 !== str) {
-        if (isPathSeparator(base2.charCodeAt(base2.length - 1))) {
-          base2 = base2.slice(0, -1);
+      if (base && base !== "" && base !== "/" && base !== str) {
+        if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+          base = base.slice(0, -1);
         }
       }
       if (opts.unescape === true) {
         if (glob) glob = utils.removeBackslashes(glob);
-        if (base2 && backslashes === true) {
-          base2 = utils.removeBackslashes(base2);
+        if (base && backslashes === true) {
+          base = utils.removeBackslashes(base);
         }
       }
       const state = {
         prefix,
         input,
         start,
-        base: base2,
+        base,
         glob,
         isBrace,
         isBracket,
@@ -2031,7 +2031,7 @@ var require_parse2 = __commonJS({
     var syntaxError = (type, char) => {
       return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
     };
-    var parse = (input, options) => {
+    var parse2 = (input, options) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
       }
@@ -2180,7 +2180,7 @@ var require_parse2 = __commonJS({
             output = token.close = `)$))${extglobStar}`;
           }
           if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-            const expression = parse(rest, { ...options, fastpaths: false }).output;
+            const expression = parse2(rest, { ...options, fastpaths: false }).output;
             output = token.close = `)${expression})${extglobStar})`;
           }
           if (token.prev.type === "bos") {
@@ -2705,7 +2705,7 @@ var require_parse2 = __commonJS({
       }
       return state;
     };
-    parse.fastpaths = (input, options) => {
+    parse2.fastpaths = (input, options) => {
       const opts = { ...options };
       const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
       const len = input.length;
@@ -2771,7 +2771,7 @@ var require_parse2 = __commonJS({
       }
       return source;
     };
-    module2.exports = parse;
+    module2.exports = parse2;
   }
 });
 
@@ -2781,7 +2781,7 @@ var require_picomatch = __commonJS({
     "use strict";
     var path3 = require("path");
     var scan = require_scan();
-    var parse = require_parse2();
+    var parse2 = require_parse2();
     var utils = require_utils2();
     var constants = require_constants2();
     var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
@@ -2869,7 +2869,7 @@ var require_picomatch = __commonJS({
     picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
     picomatch.parse = (pattern, options) => {
       if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
-      return parse(pattern, { ...options, fastpaths: false });
+      return parse2(pattern, { ...options, fastpaths: false });
     };
     picomatch.scan = (input, options) => scan(input, options);
     picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
@@ -2895,10 +2895,10 @@ var require_picomatch = __commonJS({
       }
       let parsed = { negated: false, fastpaths: true };
       if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
-        parsed.output = parse.fastpaths(input, options);
+        parsed.output = parse2.fastpaths(input, options);
       }
       if (!parsed.output) {
-        parsed = parse(input, options);
+        parsed = parse2(input, options);
       }
       return picomatch.compileRe(parsed, options, returnOutput, returnState);
     };
@@ -3499,28 +3499,28 @@ var require_tasks = __commonJS({
     function groupPatternsByBaseDirectory(patterns) {
       const group = {};
       return patterns.reduce((collection, pattern) => {
-        const base2 = utils.pattern.getBaseDirectory(pattern);
-        if (base2 in collection) {
-          collection[base2].push(pattern);
+        const base = utils.pattern.getBaseDirectory(pattern);
+        if (base in collection) {
+          collection[base].push(pattern);
         } else {
-          collection[base2] = [pattern];
+          collection[base] = [pattern];
         }
         return collection;
       }, group);
     }
     exports2.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
     function convertPatternGroupsToTasks(positive, negative, dynamic) {
-      return Object.keys(positive).map((base2) => {
-        return convertPatternGroupToTask(base2, positive[base2], negative, dynamic);
+      return Object.keys(positive).map((base) => {
+        return convertPatternGroupToTask(base, positive[base], negative, dynamic);
       });
     }
     exports2.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
-    function convertPatternGroupToTask(base2, positive, negative, dynamic) {
+    function convertPatternGroupToTask(base, positive, negative, dynamic) {
       return {
         dynamic,
         positive,
         negative,
-        base: base2,
+        base,
         patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
       };
     }
@@ -4460,8 +4460,8 @@ var require_async3 = __commonJS({
       onEnd(callback) {
         this._emitter.once("end", callback);
       }
-      _pushToQueue(directory, base2) {
-        const queueItem = { directory, base: base2 };
+      _pushToQueue(directory, base) {
+        const queueItem = { directory, base };
         this._queue.push(queueItem, (error) => {
           if (error !== null) {
             this._handleError(error);
@@ -4488,19 +4488,19 @@ var require_async3 = __commonJS({
         this._isDestroyed = true;
         this._emitter.emit("error", error);
       }
-      _handleEntry(entry, base2) {
+      _handleEntry(entry, base) {
         if (this._isDestroyed || this._isFatalError) {
           return;
         }
         const fullpath = entry.path;
-        if (base2 !== void 0) {
-          entry.path = common.joinPathSegments(base2, entry.name, this._settings.pathSegmentSeparator);
+        if (base !== void 0) {
+          entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
         }
         if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
           this._emitEntry(entry);
         }
         if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
-          this._pushToQueue(fullpath, base2 === void 0 ? void 0 : entry.path);
+          this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
         }
       }
       _emitEntry(entry) {
@@ -4608,19 +4608,19 @@ var require_sync3 = __commonJS({
         this._handleQueue();
         return this._storage;
       }
-      _pushToQueue(directory, base2) {
-        this._queue.add({ directory, base: base2 });
+      _pushToQueue(directory, base) {
+        this._queue.add({ directory, base });
       }
       _handleQueue() {
         for (const item of this._queue.values()) {
           this._handleDirectory(item.directory, item.base);
         }
       }
-      _handleDirectory(directory, base2) {
+      _handleDirectory(directory, base) {
         try {
           const entries = this._scandir(directory, this._settings.fsScandirSettings);
           for (const entry of entries) {
-            this._handleEntry(entry, base2);
+            this._handleEntry(entry, base);
           }
         } catch (error) {
           this._handleError(error);
@@ -4632,16 +4632,16 @@ var require_sync3 = __commonJS({
         }
         throw error;
       }
-      _handleEntry(entry, base2) {
+      _handleEntry(entry, base) {
         const fullpath = entry.path;
-        if (base2 !== void 0) {
-          entry.path = common.joinPathSegments(base2, entry.name, this._settings.pathSegmentSeparator);
+        if (base !== void 0) {
+          entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
         }
         if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
           this._pushToStorage(entry);
         }
         if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
-          this._pushToQueue(fullpath, base2 === void 0 ? void 0 : entry.path);
+          this._pushToQueue(fullpath, base === void 0 ? void 0 : entry.path);
         }
       }
       _pushToStorage(entry) {
@@ -5537,14 +5537,14 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_node_fs3 = require("fs");
-var import_node_process4 = __toESM(require("process"), 1);
+var import_node_process5 = __toESM(require("process"), 1);
 var import_unplugin = require("unplugin");
 
 // src/core/compress.ts
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
 var import_node_process2 = __toESM(require("process"), 1);
-var import_archiver = __toESM(require("archiver"), 1);
+var import_zip_lib = require("zip-lib");
 
 // node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -6056,48 +6056,45 @@ var Log = class {
 };
 
 // src/core/compress.ts
-async function createCompress(options, outDir2) {
-  const { ignoreBase } = options;
-  const zipFilePath = import_node_path.default.resolve(import_node_process2.default.cwd(), `${import_node_path.default.basename(outDir2)}.zip`);
-  Log.log("Compressing the directory", outDir2);
-  return new Promise((resolve, reject) => {
-    try {
-      const output = import_node_fs.default.createWriteStream(zipFilePath);
-      const archive = (0, import_archiver.default)("zip");
-      output.on("close", () => {
-        const size = archive.pointer();
-        const sizeInMB = size > 1024 * 1024 ? `${(size / 1024 / 1024).toFixed(1)} MB` : `${(size / 1024).toFixed(1)} KB`;
-        Log.success("Successfully compressed to", `${zipFilePath} (${sizeInMB})`);
-        resolve(null);
-      });
-      archive.on("warning", (err) => {
-        if (err.code === "ENOENT")
-          Log.log("File not found during compression:", err.message);
-        else
-          Log.log("Compression warning:", err.message);
-      });
-      archive.on("error", (err) => {
-        Log.error("Compression error:", err);
-        reject(err);
-      });
-      archive.pipe(output);
-      const absoluteOutDir = import_node_path.default.resolve(outDir2);
-      archive.directory(absoluteOutDir, ignoreBase ? false : import_node_path.default.basename(outDir2));
-      archive.finalize();
-    } catch (error) {
-      Log.error("Error compressing the directory", error);
-      throw error;
-    }
-  });
+async function createCompress(options, outDir) {
+  const { includeBaseDir } = options;
+  const zipFilePath = import_node_path.default.resolve(import_node_process2.default.cwd(), `${import_node_path.default.basename(outDir)}.zip`);
+  const absoluteOutDir = import_node_path.default.resolve(outDir);
+  Log.log("Compressing directory:", absoluteOutDir);
+  try {
+    const zip = new import_zip_lib.Zip();
+    if (!includeBaseDir) {
+      zip.addFolder(absoluteOutDir);
+    } else {
+      zip.addFolder(absoluteOutDir, import_node_path.default.basename(outDir));
+    }
+    await zip.archive(zipFilePath);
+    const stat = import_node_fs.default.statSync(zipFilePath);
+    const size = stat.size;
+    const readableSize = size > 1024 * 1024 ? `${(size / 1024 / 1024).toFixed(1)} MB` : `${(size / 1024).toFixed(1)} KB`;
+    Log.success(
+      "Successfully compressed to:",
+      `${zipFilePath} (${readableSize})`
+    );
+    return null;
+  } catch (error) {
+    Log.error("Compression error:", error);
+    throw error;
+  }
 }
 
+// src/core/options.ts
+var import_node_process4 = __toESM(require("process"), 1);
+var import_utils = require("@antfu/utils");
+
 // src/core/generate.ts
+var import_node_child_process = require("child_process");
 var import_node_fs2 = require("fs");
 var import_node_path2 = __toESM(require("path"), 1);
 var import_node_process3 = __toESM(require("process"), 1);
 var import_fast_glob = __toESM(require_out4(), 1);
-var import_local_pkg = require("local-pkg");
-var import_recast = __toESM(require("recast"), 1);
+var recast = __toESM(require("recast"), 1);
+var import_typescript = __toESM(require("recast/parsers/typescript"), 1);
 function mergeObjects(prodObj, devObj) {
   const prodProps = new Map(prodObj.properties.map((p) => [p.key.name || p.key.value, p]));
   for (const prop of devObj.properties) {
@@ -6111,90 +6108,264 @@ function mergeObjects(prodObj, devObj) {
     }
   }
 }
-async function generateScript(options, mode, base2) {
-  const { dir, fileName, globalName, serve, build } = options.env;
-  const folder = await findFolder(import_node_process3.default.cwd(), dir);
-  const files = await (0, import_fast_glob.default)("*.+(js|ts)", {
+async function generateScript(options, context) {
+  const { configDir, emitFileName, emitDir, globalName, devMatch, buildMatch } = options.env;
+  const folder = await resolveConfigFolder(import_node_process3.default.cwd(), configDir);
+  if (!folder)
+    throw new Error(`[unplugin-env] Config directory "${configDir}" not found from ${import_node_process3.default.cwd()}`);
+  const files = await (0, import_fast_glob.default)("*.{js,ts}", {
     absolute: true,
     cwd: folder
   });
-  const testReg = mode === "serve" ? serve : build;
+  if (!files.length)
+    throw new Error(`[unplugin-env] No config files found in ${folder}`);
+  const { mode, base } = context;
+  const testReg = mode === "dev" ? devMatch : buildMatch;
   let target = "";
   let source = "";
   let code = "";
-  const name = fileName;
+  let targetFile = "";
+  let sourceFile = "";
+  const resolvedEmitFileName = resolveEmitFileName(emitDir, emitFileName);
   for (const file of files) {
     try {
       const mod = await import_node_fs2.promises.readFile(file, "utf-8");
-      if (testReg?.test(file))
+      if (testReg?.test(file)) {
         target = mod;
-      else
+        targetFile = file;
+      } else {
         source = mod;
+        sourceFile = file;
+      }
     } catch (error) {
       console.error(`Error loading file ${file}:`, error);
     }
   }
-  const targetAst = import_recast.default.parse(target);
-  const sourceAst = import_recast.default.parse(source);
-  const targetExport = targetAst.program.body.find((n) => n.type === "ExportDefaultDeclaration").declaration;
-  const sourceExport = sourceAst.program.body.find((n) => n.type === "ExportDefaultDeclaration").declaration;
+  if (files.length === 1) {
+    if (!target) {
+      target = source;
+      targetFile = sourceFile;
+    }
+    if (!source) {
+      source = target;
+      sourceFile = targetFile;
+    }
+  }
+  if (!target || !targetFile)
+    throw new Error(`[unplugin-env] No file matched "${testReg}" in ${folder}`);
+  if (!source || !sourceFile)
+    throw new Error(`[unplugin-env] No base config file found in ${folder}`);
+  const targetAst = parseConfig(target, targetFile);
+  const sourceAst = parseConfig(source, sourceFile);
+  const targetExport = getDefaultExportObject(targetAst, targetFile);
+  const sourceExport = getDefaultExportObject(sourceAst, sourceFile);
   mergeObjects(sourceExport, targetExport);
-  const mergedCode = import_recast.default.print(sourceExport).code;
+  const mergedCode = recast.print(sourceExport).code;
   const returnedTarget = mergedCode;
   const versionInfo = await generateVersion(options, mode);
   code = `window.${globalName}=${returnedTarget};
 ${versionInfo}`;
   const formatCode = code;
+  const viteIgnoreAttr = context.framework === "vite" ? " vite-ignore" : "";
+  const scriptSrc = joinBasePath(base, resolvedEmitFileName);
   return {
     code,
-    script: `  <script type="text/javascript" src="${base2}${fileName}"></script>
+    script: `  <script type="text/javascript"${viteIgnoreAttr} src="${scriptSrc}"></script>
 </head>`,
     emit: {
       type: "asset",
-      fileName: name,
+      fileName: resolvedEmitFileName,
       source: formatCode
     },
     watchFiles: files
   };
 }
+async function getFullPackageJson(cwd = import_node_process3.default.cwd()) {
+  const pkgPath = import_node_path2.default.resolve(cwd, "package.json");
+  const content = await import_node_fs2.promises.readFile(pkgPath, "utf-8");
+  return JSON.parse(content);
+}
+function wrapText(text, maxLen) {
+  const lines = [];
+  let current = "";
+  for (const char of text) {
+    current += char;
+    if (current.length >= maxLen) {
+      lines.push(current);
+      current = "";
+    }
+  }
+  if (current)
+    lines.push(current);
+  return lines;
+}
+function parseConfig(code, filePath) {
+  const parser = filePath.endsWith(".ts") ? import_typescript.default : void 0;
+  return parser ? recast.parse(code, { parser }) : recast.parse(code);
+}
+function getDefaultExportObject(ast, filePath) {
+  const exportNode = ast?.program?.body?.find((node) => node.type === "ExportDefaultDeclaration");
+  if (!exportNode?.declaration)
+    throw new Error(`[unplugin-env] ${filePath} must have a default export of an object`);
+  let decl = exportNode.declaration;
+  if (decl.type === "TSAsExpression" || decl.type === "TSTypeAssertion")
+    decl = decl.expression;
+  if (decl.type === "CallExpression" && decl.arguments?.[0]?.type === "ObjectExpression")
+    decl = decl.arguments[0];
+  if (decl.type !== "ObjectExpression")
+    throw new Error(`[unplugin-env] ${filePath} default export must be an object literal`);
+  return decl;
+}
+function joinBasePath(base, resourcePath) {
+  const safeBase = base && base.endsWith("/") ? base : `${base || "/"}`.replace(/\/?$/, "/");
+  const safeFile = resourcePath.replace(/^\/+/, "");
+  return `${safeBase}${safeFile}`;
+}
+function resolveEmitFileName(emitDir, emitFileName) {
+  const normalizedFile = emitFileName.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!emitDir)
+    return normalizedFile;
+  const normalizedDir = emitDir.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  if (!normalizedDir)
+    return normalizedFile;
+  const prefix = `${normalizedDir}/`;
+  if (normalizedFile === normalizedDir || normalizedFile.startsWith(prefix))
+    return normalizedFile;
+  return import_node_path2.default.posix.join(normalizedDir, normalizedFile);
+}
+async function resolveConfigFolder(root, configDir) {
+  if (!configDir)
+    return "";
+  const candidate = import_node_path2.default.isAbsolute(configDir) ? configDir : import_node_path2.default.resolve(root, configDir);
+  try {
+    const stat = await import_node_fs2.promises.stat(candidate);
+    if (stat.isDirectory())
+      return candidate;
+  } catch {
+  }
+  return findFolder(root, configDir);
+}
 async function generateVersion(options, mode) {
-  const pkg = await (0, import_local_pkg.getPackageInfo)(import_node_process3.default.cwd());
-  return `console.info("Version: %c${pkg?.version}%c -  ${mode === "serve" ? "runtime" : "built"} on %c${options.datetime}%c", "color: green;", '', "color: blue;", '')`;
+  const pkg = await getFullPackageJson(import_node_process3.default.cwd());
+  const name = pkg?.name ?? "Unknown App";
+  const version = `v${pkg?.version ?? "0.0.0"}`;
+  const branchName = getBranchName() || "unknown";
+  const commitHash = getCommitHash() || "unknown";
+  const datetime = options.datetime;
+  const stateLabel = mode === "dev" ? "runtime" : "built";
+  const stateColor = mode === "dev" ? "#059669" : "#2563EB";
+  const MAX_DESC_LINE_LEN = 36;
+  const rawDesc = pkg?.description ?? "unknown";
+  const descLines = wrapText(rawDesc, MAX_DESC_LINE_LEN);
+  const baseLines = [
+    `${name}  ${version}  ${stateLabel}`,
+    `Branch : ${branchName}`,
+    `Commit : ${commitHash}`,
+    `Time   : ${datetime}`,
+    `Desc   : ${descLines[0]}`,
+    ...descLines.slice(1).map((l) => `         ${l}`)
+  ];
+  const maxLen = Math.max(...baseLines.map((l) => l.length));
+  const divider = "-".repeat(maxLen + 4);
+  const textParts = [
+    `${divider}
+`,
+    ` ${name} `,
+    ` ${version} `,
+    ` ${stateLabel}
+`,
+    `${divider}
+`,
+    ` Branch :`,
+    ` ${branchName}
+`,
+    ` Commit :`,
+    ` ${commitHash}
+`,
+    ` Time   :`,
+    ` ${datetime}
+`,
+    ` Desc   :`,
+    ` ${descLines[0]}
+`,
+    ...descLines.slice(1).map((l) => `          ${l}
+`),
+    `${divider}`
+  ];
+  const styles3 = [
+    "color:#9CA3AF",
+    // divider
+    "color:#111827;font-weight:600",
+    // name
+    "color:#2563EB;font-weight:600",
+    // version
+    `color:${stateColor};font-weight:600`,
+    // state
+    "color:#9CA3AF",
+    // divider
+    "color:#6B7280",
+    // Branch label
+    "color:#111827",
+    "color:#6B7280",
+    // Commit label
+    "color:#111827",
+    "color:#6B7280",
+    // Time label
+    "color:#2563EB",
+    "color:#6B7280",
+    // Desc label
+    "color:#4B5563",
+    ...descLines.slice(1).map(() => "color:#4B5563"),
+    "color:#9CA3AF"
+    // divider
+  ];
+  return `
+console.log(
+  ${JSON.stringify(`%c${textParts.join("%c")}`)},
+  ${styles3.map((s) => JSON.stringify(s)).join(",\n  ")}
+)
+`.trim();
 }
 async function findFolder(directoryPath, dir) {
   const ignore = /* @__PURE__ */ new Set(["dist", "node_modules", "playground", "example", "test", "jest", "tests", "locales", "public", ".git", ".github", ".vscode"]);
-  const files = await import_node_fs2.promises.readdir(directoryPath);
-  const filePaths = files.filter((item) => !ignore.has(item));
+  const entries = await import_node_fs2.promises.readdir(directoryPath, { withFileTypes: true });
+  const dirLower = dir.toLowerCase();
+  const filePaths = entries.filter((entry) => !ignore.has(entry.name));
   let nestedFolder = "";
-  for (const file of filePaths) {
-    const fullFilePath = import_node_path2.default.join(directoryPath, file);
-    const stat = await import_node_fs2.promises.stat(fullFilePath);
-    if (stat.isDirectory()) {
-      if (file.toLowerCase() === dir) {
-        return fullFilePath;
-      } else {
-        nestedFolder = await findFolder(fullFilePath, dir);
-        if (nestedFolder)
-          return nestedFolder;
-      }
-    }
+  for (const entry of filePaths) {
+    if (!entry.isDirectory())
+      continue;
+    const fullFilePath = import_node_path2.default.join(directoryPath, entry.name);
+    if (entry.name.toLowerCase() === dirLower)
+      return fullFilePath;
+    nestedFolder = await findFolder(fullFilePath, dir);
+    if (nestedFolder)
+      return nestedFolder;
   }
   return "";
 }
+function getBranchName() {
+  const branchName = (0, import_node_child_process.execSync)("git rev-parse --abbrev-ref HEAD").toString().trim();
+  return branchName;
+}
+function getCommitHash() {
+  const commitHash = (0, import_node_child_process.execSync)("git rev-parse HEAD").toString().trim();
+  return commitHash.slice(0, 8);
+}
 
 // src/core/options.ts
-var import_utils = require("@antfu/utils");
 function resolveOptions(options) {
   const defaults = {
     env: {
-      dir: "config",
-      fileName: "manifest.js",
+      configDir: "config",
+      emitFileName: "manifest.js",
+      emitDir: "",
       globalName: "manifest",
-      serve: /dev/i,
-      build: /prod/i
+      devMatch: /dev/i,
+      buildMatch: /prod/i
     },
     compress: {
-      ignoreBase: false
+      includeBaseDir: true
     }
   };
   const mergeOptions = (0, import_utils.deepMerge)(defaults, options);
@@ -6207,67 +6378,273 @@ function resolveOptions(options) {
     datetime: formatter.format(/* @__PURE__ */ new Date())
   };
 }
+function createUnifiedContext(resolved) {
+  const ctx = {
+    framework: "",
+    base: "/",
+    outDir: "dist",
+    mode: "build",
+    scriptInfo: {
+      code: "",
+      script: "",
+      emit: {
+        type: "asset",
+        source: "",
+        fileName: ""
+      },
+      watchFiles: []
+    },
+    get isDev() {
+      return this.mode === "dev";
+    },
+    get isBuild() {
+      return this.mode === "build";
+    },
+    // --- VITE ---
+    async setVite(config) {
+      this.framework = "vite";
+      this.base = config.base || "/";
+      this.outDir = config.build?.outDir || "dist";
+      this.mode = config.command === "serve" ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    },
+    // --- ROLLUP ---
+    async setRollup(options) {
+      this.framework = "rollup";
+      this.outDir = options.dir || "dist";
+      this.mode = import_node_process4.default.env.ROLLUP_WATCH ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    },
+    // --- WEBPACK ---
+    async setWebpack(compiler) {
+      this.framework = "webpack";
+      this.base = compiler.options.output?.publicPath || "/";
+      this.outDir = compiler.options.output?.path || "dist";
+      const raw = compiler.options.mode || "production";
+      this.mode = raw === "development" ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    },
+    // --- RSPACK ---
+    async setRspack(compiler) {
+      this.framework = "rspack";
+      this.base = compiler.options.output?.publicPath || "/";
+      this.outDir = compiler.options.output?.path || "dist";
+      const raw = compiler.options.mode || "production";
+      this.mode = raw === "development" ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    },
+    // --- ESBUILD ---
+    async setEsbuild(build) {
+      this.framework = "esbuild";
+      this.outDir = build.initialOptions.outdir || "dist";
+      this.mode = build.initialOptions.watch ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    },
+    // --- FARM ---
+    async setFarm(compiler) {
+      this.framework = "farm";
+      this.base = compiler.config.output?.publicPath || "/";
+      this.outDir = compiler.config.output?.path || "dist";
+      const raw = compiler.config.mode || "production";
+      this.mode = raw === "development" ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    },
+    // --- ROLLDOWN ---
+    async setRolldown(options) {
+      this.framework = "rolldown";
+      this.outDir = options.dir || "dist";
+      this.mode = import_node_process4.default.env.ROLLDOWN_WATCH ? "dev" : "build";
+      ctx.scriptInfo = await generateScript(resolved, ctx);
+    }
+  };
+  return ctx;
+}
 
 // src/index.ts
 var virtualEnvId = "virtual:env";
+var virtualEnvAliasId = "virtual-env";
 var resolvedVirtualEnvId = `\0${virtualEnvId}`;
-var base = "";
-var outDir = "";
+var resolvedVirtualEnvAliasId = `\0${virtualEnvAliasId}`;
+function isVirtualEnvId(id) {
+  return id.startsWith(virtualEnvId) || id.startsWith(virtualEnvAliasId);
+}
+function resolveVirtualEnvId(id) {
+  return id.startsWith(virtualEnvAliasId) ? resolvedVirtualEnvAliasId : resolvedVirtualEnvId;
+}
+function isResolvedVirtualEnvId(id) {
+  return id.startsWith(resolvedVirtualEnvId) || id.startsWith(resolvedVirtualEnvAliasId);
+}
 var unpluginFactory = (options = {}) => {
   const resolved = resolveOptions(options);
+  const ctx = createUnifiedContext(resolved);
+  let frameworkReady = null;
+  let legacyEmitHooked = false;
   return [{
-    name: "plugin-env-serve",
-    apply: "serve",
+    name: "plugin-env",
     enforce: "post",
-    configResolved(config) {
-      outDir = config.build.outDir;
-      base = config.base;
+    rollup: {
+      async buildStart() {
+        const outputOptions = { dir: ctx.outDir };
+        await ctx.setRollup(outputOptions);
+      },
+      outputOptions(outputOptions) {
+        ctx.outDir = outputOptions.dir || ctx.outDir;
+        return outputOptions;
+      }
     },
-    async resolveId(id) {
-      if (id.startsWith(virtualEnvId))
-        return resolvedVirtualEnvId;
+    vite: {
+      async configResolved(config) {
+        await ctx.setVite(config);
+      }
     },
-    async load(id) {
-      if (id.startsWith(resolvedVirtualEnvId)) {
-        const { code, watchFiles } = await generateScript(resolved, "serve", base);
-        watchFiles.forEach((file) => {
-          this.addWatchFile(file);
-        });
-        return code;
+    async webpack(compiler) {
+      frameworkReady = ctx.setWebpack(compiler);
+      const webpackLib = compiler.webpack;
+      const RawSource = webpackLib?.sources?.RawSource;
+      compiler.hooks.thisCompilation.tap("plugin-env", (compilation) => {
+        if (webpackLib?.Compilation?.PROCESS_ASSETS_STAGE_PRE_PROCESS) {
+          const { Compilation, sources } = webpackLib;
+          compilation.hooks.processAssets.tapPromise(
+            { name: "plugin-env", stage: Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS },
+            async () => {
+              await frameworkReady;
+              const manifestName = ctx.scriptInfo.emit.fileName;
+              if (!manifestName)
+                return;
+              const asset = compilation.getAsset(manifestName);
+              if (!asset || asset.info?.minimized)
+                return;
+              compilation.updateAsset(manifestName, asset.source, { ...asset.info, minimized: true });
+            }
+          );
+          compilation.hooks.processAssets.tapPromise(
+            { name: "plugin-env", stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE },
+            async (assets) => {
+              await frameworkReady;
+              const { script } = ctx.scriptInfo;
+              if (!script)
+                return;
+              const scriptTag = script.replace(/<\/head>\s*$/i, "").trim();
+              for (const name of Object.keys(assets)) {
+                if (!name.endsWith(".html"))
+                  continue;
+                const asset = compilation.getAsset(name);
+                const html = asset?.source.source().toString() || "";
+                if (!html || html.includes(scriptTag))
+                  continue;
+                const nextHtml = html.replace(/<\/head>/i, script);
+                if (nextHtml !== html)
+                  compilation.updateAsset(name, new sources.RawSource(nextHtml));
+              }
+            }
+          );
+        } else if (!legacyEmitHooked) {
+          legacyEmitHooked = true;
+          compiler.hooks.emit.tapAsync("plugin-env", (comp, cb) => {
+            const run = () => {
+              const { script } = ctx.scriptInfo;
+              if (!script)
+                return cb();
+              const scriptTag = script.replace(/<\/head>\s*$/i, "").trim();
+              for (const name of Object.keys(comp.assets)) {
+                if (!name.endsWith(".html"))
+                  continue;
+                const asset = comp.assets[name];
+                const html = asset?.source().toString() || "";
+                if (!html || html.includes(scriptTag))
+                  continue;
+                const nextHtml = html.replace(/<\/head>/i, script);
+                if (nextHtml !== html) {
+                  comp.assets[name] = RawSource ? new RawSource(nextHtml) : {
+                    source: () => nextHtml,
+                    size: () => nextHtml.length
+                  };
+                }
+              }
+              cb();
+            };
+            if (frameworkReady) {
+              frameworkReady.then(run).catch((error) => cb(error));
+            } else {
+              run();
+            }
+          });
+        }
+      });
+    },
+    rspack: async (compiler) => {
+      frameworkReady = ctx.setRspack(compiler);
+    },
+    esbuild: {
+      async setup(build) {
+        await ctx.setEsbuild(build);
       }
-    }
-  }, {
-    name: "unplugin-env-build",
-    apply: "build",
-    enforce: "post",
-    configResolved(config) {
-      base = config.base;
-      outDir = config.build.outDir;
     },
-    resolveId(id) {
-      if (id.startsWith(virtualEnvId))
-        return resolvedVirtualEnvId;
+    async farm(compiler) {
+      await ctx.setFarm(compiler);
     },
-    async load(id) {
-      const { emit, script } = await generateScript(resolved, "build", base);
-      if (id.startsWith(resolvedVirtualEnvId)) {
-        this.emitFile(emit);
-        return "";
+    rolldown: {
+      async outputOptions(outputOptions) {
+        await ctx.setRolldown(outputOptions);
       }
+    },
+    async resolveId(id) {
+      if (isVirtualEnvId(id))
+        return resolveVirtualEnvId(id);
+    },
+    loadInclude(id) {
+      if (isResolvedVirtualEnvId(id) || isVirtualEnvId(id))
+        return true;
       if (id.endsWith(".html")) {
-        let code = await import_node_fs3.promises.readFile(id, "utf8");
-        code = code.replace(/<\/head>/g, script);
-        return {
-          code
-        };
+        return ctx.framework === "vite" || ctx.framework === "rollup" || ctx.framework === "rolldown";
       }
-      return null;
+      return false;
+    },
+    async load(id) {
+      if (frameworkReady)
+        await frameworkReady;
+      const { code, watchFiles, emit, script } = ctx.scriptInfo;
+      if (ctx.isDev) {
+        if (isResolvedVirtualEnvId(id)) {
+          watchFiles.forEach((file) => {
+            this.addWatchFile(file);
+          });
+          return code;
+        }
+      } else {
+        if (isResolvedVirtualEnvId(id)) {
+          this.emitFile(emit);
+          return "";
+        }
+        const canTransformHtml = ctx.framework === "vite" || ctx.framework === "rollup" || ctx.framework === "rolldown";
+        if (canTransformHtml && id.endsWith(".html")) {
+          let code2 = await import_node_fs3.promises.readFile(id, "utf-8");
+          code2 = code2.replace(/<\/head>/g, script);
+          return { code: code2 };
+        }
+      }
+    },
+    transformInclude(id) {
+      return /\.(?:c|m)?(?:j|t)sx?$/.test(id);
+    },
+    async transform(code, id) {
+      if (ctx.framework !== "webpack" && ctx.framework !== "rspack")
+        return;
+      if (!id.match(/\.(?:c|m)?(?:j|t)sx?$/))
+        return;
+      if (!code.includes(virtualEnvId))
+        return;
+      return code.replaceAll(virtualEnvId, virtualEnvAliasId);
     },
     buildEnd: () => {
-      import_node_process4.default.on("beforeExit", async () => {
+      import_node_process5.default.on("beforeExit", () => {
         const { compress } = resolved;
-        await createCompress(compress, outDir);
-        import_node_process4.default.exit(0);
+        createCompress(compress, ctx.outDir).then(() => {
+          import_node_process5.default.exit(0);
+        }).catch((error) => {
+          import_node_process5.default.exitCode = 1;
+          throw error;
+        });
       });
     }
   }];