@xysfe/vite-plugin-dev-proxy 1.0.2 → 1.0.4

package/dist/index.mjs

@@ -2,205 +2,305 @@ import zlib from 'zlib';
 import { resolve } from 'path';
 import fs from 'fs';
 
-function createProxyConfig(options) {
-  const {
+const SCRIPT_LINK_REGEX = /<(?:script[^>]*>.*?<\/script>|link[^>]*>)/g;
+const ASSET_REGEX = /\.(js|mjs|ts|tsx|jsx|css|scss|sass|less|vue|json|woff2?|ttf|eot|ico|png|jpe?g|gif|svg|webp)(\?.*)?$/i;
+const STATIC_PATH_REGEX = /^\/(static|assets|public|images|css|js)\//i;
+const BYPASS_REGEX = /\.(vue|js|mjs|ts|tsx|jsx|css|scss|sass|less|json|png|jpe?g|gif|svg|webp|ico|woff2?|ttf|eot)$/i;
+const REDIRECT_STATUS_MIN = 300;
+const REDIRECT_STATUS_MAX = 400;
+const DEFAULT_APP_DIV_REGEX = /<div[^>]*id=["']app["'][^>]*><\/div>/g;
+const HTTPS_TO_HTTP_REGEX = /https:\/\/(localhost|127\.0\.0\.1|192\.168\.\d{1,3}\.\d{1,3}|10\.\d{1,3}\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3})(:\d+)?/gi;
+function createLogger(debug) {
+  return {
+    log: debug ? console.log.bind(console) : () => {
+    },
+    logError: debug ? console.error.bind(console) : () => {
+    }
+  };
+}
+function normalizePath(path) {
+  return path.endsWith("/") ? path.slice(0, -1) : path;
+}
+function generateEntryScript(entry, staticPrefix) {
+  if (Array.isArray(entry)) {
+    return entry.map(
+      (e) => `<script crossorigin type="module"  src="${staticPrefix + e}"><\/script>`
+    ).join("\n");
+  }
+  return `<script crossorigin type="module" src="${staticPrefix + entry}"><\/script>`;
+}
+function rewriteCookies(headers, log2) {
+  const setCookie = headers["set-cookie"];
+  if (setCookie) {
+    headers["set-cookie"] = setCookie.map((cookie) => {
+      const rewrittenCookie = cookie.replace(/;\s*secure\s*(;|$)/gi, "$1").replace(/;\s*domain\s*=[^;]+(;|$)/gi, "$1").replace(/;\s*samesite\s*=[^;]+(;|$)/gi, "$1").replace(/;+/g, ";").replace(/;\s*$/g, "");
+      log2("[rewrittenCookie]", rewrittenCookie);
+      return rewrittenCookie;
+    });
+  }
+  return headers;
+}
+function decompressBuffer(buffer, encoding) {
+  if (encoding === "gzip") {
+    return zlib.gunzipSync(buffer);
+  } else if (encoding === "deflate") {
+    return zlib.inflateSync(buffer);
+  } else if (encoding === "br") {
+    return zlib.brotliDecompressSync(buffer);
+  }
+  return buffer;
+}
+function shouldClearScriptCss(match, clearRule) {
+  const srcMatch = match.match(/src="([^"]+)"/i);
+  const hrefMatch = match.match(/href="([^"]+)"/i);
+  const srcOrHref = srcMatch ? srcMatch[1] : hrefMatch ? hrefMatch[1] : null;
+  if (clearRule === "") {
+    return false;
+  }
+  if (typeof clearRule === "string") {
+    return srcOrHref?.startsWith(clearRule) ?? false;
+  }
+  if (Array.isArray(clearRule)) {
+    return clearRule.some((prefix) => srcOrHref?.startsWith(prefix));
+  }
+  if (clearRule instanceof RegExp) {
+    return clearRule.test(match);
+  }
+  if (typeof clearRule === "function") {
+    return clearRule(match);
+  }
+  return false;
+}
+function injectEntryScript(html, fullEntry, developmentAgentOccupancy) {
+  if (developmentAgentOccupancy) {
+    return html.replace(developmentAgentOccupancy, fullEntry);
+  }
+  return html.replace(DEFAULT_APP_DIV_REGEX, (match) => `${match}${fullEntry}`);
+}
+function clearScriptCssTags(html, clearRule, log2) {
+  return html.replace(SCRIPT_LINK_REGEX, (match) => {
+    const isClear = shouldClearScriptCss(match, clearRule);
+    if (isClear) {
+      log2?.(`[clearScriptCssTags]: ${match}`);
+    }
+    return isClear ? "" : match;
+  });
+}
+function isRedirectResponse(proxyRes) {
+  return proxyRes.statusCode >= REDIRECT_STATUS_MIN && proxyRes.statusCode < REDIRECT_STATUS_MAX && !!proxyRes.headers.location;
+}
+function shouldProcessAsHtml(contentType, acceptHeader, requestUrl, isRedirect) {
+  const isNavigationRequest = acceptHeader.includes("text/html");
+  const isAssetRequest = ASSET_REGEX.test(requestUrl);
+  const isStaticPath = STATIC_PATH_REGEX.test(requestUrl);
+  return contentType.includes("text/html") && isNavigationRequest && !isAssetRequest && !isStaticPath && !isRedirect;
+}
+function matchesRemoteResource(url, remoteRule) {
+  if (typeof remoteRule === "string") {
+    return url.startsWith(remoteRule);
+  }
+  if (Array.isArray(remoteRule)) {
+    return remoteRule.some((prefix) => url.startsWith(prefix));
+  }
+  if (remoteRule instanceof RegExp) {
+    return remoteRule.test(url);
+  }
+  if (typeof remoteRule === "function") {
+    return remoteRule(url);
+  }
+  return false;
+}
+function shouldUseLocal(url, normalizedStaticPrefix, remotePrefixes) {
+  const pathname = url.split("?")[0];
+  const isLocalResource = normalizedStaticPrefix && url.startsWith(normalizedStaticPrefix) || url.startsWith("/@") || url.startsWith("/src") || url.startsWith("/node_modules") || url.includes(".hot-update.") || url.startsWith("/sockjs-node") || // Vue CLI/Webpack 热更新 WebSocket (3.x)
+  url.startsWith("/ws") || // Vue CLI/Webpack 热更新 WebSocket (4.x+/Vite)
+  url === "/" || BYPASS_REGEX.test(pathname);
+  const isRemoteResource = matchesRemoteResource(url, remotePrefixes);
+  return isLocalResource && !isRemoteResource;
+}
+function handleRedirect(proxyRes, req, res, appHost, log2, startTime) {
+  const redirectUrl = proxyRes.headers.location;
+  const host = req.headers.host;
+  const regex = new RegExp(appHost, "gi");
+  let location = redirectUrl.replace(regex, host || "");
+  location = location.replace(HTTPS_TO_HTTP_REGEX, "http://$1$2");
+  const headers = rewriteCookies({ ...proxyRes.headers }, log2);
+  headers.location = location;
+  res.writeHead(proxyRes.statusCode, headers);
+  res.end();
+  log2(
+    `Redirect handled: ${redirectUrl} -> ${location} (${Date.now() - startTime}ms)`
+  );
+}
+function handleLibModeHtml(localIndexHtml, res, log2, logError, startTime) {
+  try {
+    const indexHtml = fs.readFileSync(
+      resolve(__dirname, localIndexHtml),
+      "utf-8"
+    );
+    res.writeHead(200, {
+      "Content-Type": "text/html; charset=utf-8"
+    });
+    res.end(indexHtml);
+    log2(`Local HTML served: ${localIndexHtml} (${Date.now() - startTime}ms)`);
+  } catch (err) {
+    logError("Failed to read local HTML:", err);
+    res.writeHead(500);
+    res.end("Failed to read local HTML");
+  }
+}
+function handleHtmlResponse(proxyRes, req, res, context) {
+  const encoding = proxyRes.headers["content-encoding"];
+  const requestUrl = req.url || "";
+  const chunks = [];
+  proxyRes.on("data", (chunk) => {
+    if (chunk) {
+      chunks.push(chunk);
+    }
+  });
+  proxyRes.on("end", () => {
+    try {
+      const buffer = Buffer.concat(chunks);
+      const decompressed = decompressBuffer(buffer, encoding);
+      let html = decompressed.toString("utf-8");
+      html = injectEntryScript(
+        html,
+        context.fullEntry,
+        context.developmentAgentOccupancy
+      );
+      html = clearScriptCssTags(
+        html,
+        context.clearScriptCssPrefixes,
+        context.log
+      );
+      const headers = rewriteCookies({ ...proxyRes.headers }, context.log);
+      headers["content-type"] = "text/html; charset=utf-8";
+      delete headers["content-encoding"];
+      delete headers["content-length"];
+      res.writeHead(200, headers);
+      res.end(html);
+      context.log(
+        `[HTML processed]: ${requestUrl} (${Date.now() - context.startTime}ms)`
+      );
+    } catch (err) {
+      context.logError("Decompress error:", err);
+      context.logError("Request URL:", requestUrl);
+      context.logError("Response headers:", proxyRes.headers);
+      res.writeHead(500);
+      res.end("Decompress error");
+    }
+  });
+}
+function validateOptions(options, pluginName) {
+  const { appHost } = options;
+  if (!appHost) {
+    throw new Error(`${pluginName}: appHost is required`);
+  }
+}
+function processOptions(options, isVite) {
+  let {
     https = true,
     appHost = "",
-    isLib = false,
-    localIndexHtml = "index.html",
-    staticPrefix = "",
-    bypassPrefixes = ["/static"],
-    // scriptCssPrefix = "",
+    localIndexHtml = "",
+    staticPrefix = "/dev/static",
+    remotePrefixes = ["/static/component"],
     developmentAgentOccupancy = "",
     clearScriptCssPrefixes = "",
-    entry = "/src/main.js",
+    entry = isVite ? "/src/main.js" : ["/js/chunk-vendors.js", "/js/app.js"],
     debug = false
   } = options;
-  if (!appHost) {
-    throw new Error("vite-plugin-dev-proxy: appHost is required");
-  }
-  if (!Array.isArray(bypassPrefixes)) {
-    throw new Error("vite-plugin-dev-proxy: bypassPrefixes must be an array");
-  }
-  const log = debug ? console.log : () => {
-  };
-  const logError = debug ? console.error : () => {
+  appHost = normalizePath(appHost);
+  const normalizedStaticPrefix = normalizePath(staticPrefix);
+  const fullEntry = generateEntryScript(entry, normalizedStaticPrefix);
+  const { log: log2, logError } = createLogger(debug);
+  return {
+    https,
+    appHost,
+    localIndexHtml,
+    normalizedStaticPrefix,
+    remotePrefixes,
+    developmentAgentOccupancy,
+    clearScriptCssPrefixes,
+    fullEntry,
+    log: log2,
+    logError
   };
-  const normalizedStaticPrefix = staticPrefix.endsWith("/") ? staticPrefix.slice(0, -1) : staticPrefix;
+}
+
+function createProxyConfig(options) {
+  validateOptions(options, "vite-plugin-dev-proxy");
+  const {
+    https,
+    appHost,
+    localIndexHtml,
+    normalizedStaticPrefix,
+    remotePrefixes,
+    developmentAgentOccupancy,
+    clearScriptCssPrefixes,
+    fullEntry,
+    log,
+    logError
+  } = processOptions(options, true);
   log("vite-plugin-dev-proxy: staticPrefix", normalizedStaticPrefix);
-  const fullEntry = normalizedStaticPrefix + entry;
-  const scriptLinkRegex = /<(?:script[^>]*>.*?<\/script>|link[^>]*>)/g;
-  const assetRegex = /\.(js|mjs|ts|tsx|jsx|css|scss|sass|less|vue|json|woff2?|ttf|eot|ico|png|jpe?g|gif|svg|webp)(\?.*)?$/i;
-  const staticPathRegex = /^\/(static|assets|public|images|css|js)\//i;
-  const bypassRegex = /\.(vue|js|mjs|ts|tsx|jsx|css|scss|sass|less|json|png|jpe?g|gif|svg|webp|ico|woff2?|ttf|eot)$/i;
+  const protocol = https ? "https://" : "http://";
   return {
     "/": {
-      target: `${https ? "https" : "http"}://${appHost}`,
+      target: `${protocol}${appHost}`,
       changeOrigin: true,
       secure: false,
       cookieDomainRewrite: { "*": "localhost" },
       selfHandleResponse: true,
-      configure: (proxy, options2) => {
-        const rewriteCookies = (headers) => {
-          const setCookie = headers["set-cookie"];
-          if (setCookie) {
-            headers["set-cookie"] = setCookie.map((cookie) => {
-              let rewrittenCookie = cookie.replace(/;\s*secure\s*(;|$)/gi, "$1").replace(/;\s*domain\s*=[^;]+(;|$)/gi, "$1").replace(/;\s*samesite\s*=[^;]+(;|$)/gi, "$1").replace(/;+/g, ";").replace(/;\s*$/g, "");
-              log("vite-plugin-dev-proxy: rewrittenCookie", rewrittenCookie);
-              return rewrittenCookie;
-            });
-          }
-          return headers;
-        };
+      configure: (proxy, _options) => {
         proxy.on(
           "proxyRes",
           (proxyRes, req, res) => {
             const startTime = Date.now();
             const contentType = proxyRes.headers["content-type"] || "";
-            const redirectUrl = proxyRes.headers.location;
             const requestUrl = req.url || "";
             const acceptHeader = req.headers.accept || "";
-            const isRedirect = proxyRes.statusCode >= 300 && proxyRes.statusCode < 400 && redirectUrl;
+            const isRedirect = isRedirectResponse(proxyRes);
             if (isRedirect) {
-              const host = req.headers.host;
-              const regex = new RegExp(appHost, "gi");
-              let location = redirectUrl.replace(regex, host || "");
-              location = location.replace(
-                /https:\/\/(localhost|127\.0\.0\.1)(:\d+)?/gi,
-                "http://$1$2"
-              );
-              const headers2 = rewriteCookies({ ...proxyRes.headers });
-              headers2.location = location;
-              res.writeHead(proxyRes.statusCode, headers2);
-              res.end();
-              log(
-                `Redirect handled: ${redirectUrl} -> ${location} (${Date.now() - startTime}ms)`
-              );
+              handleRedirect(proxyRes, req, res, appHost, log, startTime);
               return;
             }
-            const isNavigationRequest = acceptHeader.includes("text/html");
-            const isAssetRequest = assetRegex.test(requestUrl);
-            const isStaticPath = staticPathRegex.test(requestUrl);
-            const shouldProcessHtml = contentType.includes("text/html") && isNavigationRequest && !isAssetRequest && !isStaticPath && !isRedirect;
+            const shouldProcessHtml = shouldProcessAsHtml(
+              contentType,
+              acceptHeader,
+              requestUrl,
+              isRedirect
+            );
             if (shouldProcessHtml) {
-              if (isLib) {
-                try {
-                  const indexHtml = fs.readFileSync(
-                    resolve(__dirname, localIndexHtml),
-                    "utf-8"
-                  );
-                  res.writeHead(200, {
-                    "Content-Type": "text/html; charset=utf-8"
-                  });
-                  res.end(indexHtml);
-                  log(
-                    `Local HTML served: ${localIndexHtml}\uFF09 (${Date.now() - startTime}ms)`
-                  );
-                } catch (err) {
-                  logError("Failed to read local HTML:", err);
-                  res.writeHead(500);
-                  res.end("Failed to read local HTML");
-                }
+              if (localIndexHtml) {
+                handleLibModeHtml(
+                  localIndexHtml,
+                  res,
+                  log,
+                  logError,
+                  startTime
+                );
                 return;
               }
-              const encoding = proxyRes.headers["content-encoding"];
-              const chunks = [];
-              proxyRes.on(
-                "data",
-                (chunk) => {
-                  if (chunk) {
-                    chunks.push(chunk);
-                  }
-                }
-              );
-              proxyRes.on("end", () => {
-                try {
-                  let buffer = Buffer.concat(chunks);
-                  const decompress = () => {
-                    if (encoding === "gzip") {
-                      return zlib.gunzipSync(buffer);
-                    } else if (encoding === "deflate") {
-                      return zlib.inflateSync(buffer);
-                    } else if (encoding === "br") {
-                      return zlib.brotliDecompressSync(buffer);
-                    }
-                    return buffer;
-                  };
-                  const decompressed = decompress();
-                  let html = decompressed.toString("utf-8");
-                  if (developmentAgentOccupancy) {
-                    html = html.replace(
-                      developmentAgentOccupancy,
-                      `<script crossorigin type="module" src="${fullEntry}"><\/script>`
-                    );
-                  } else {
-                    html = html.replace(
-                      /<div[^>]*id=["']app["'][^>]*><\/div>/g,
-                      (match) => `${match}<script crossorigin type="module" src="${fullEntry}"><\/script>`
-                    );
-                  }
-                  clearScriptCssPrefixes;
-                  html = html.replace(scriptLinkRegex, (match) => {
-                    const srcMatch = match.match(/src="([^"]+)"/i);
-                    const hrefMatch = match.match(/href="([^"]+)"/i);
-                    const srcOrHref = srcMatch ? srcMatch[1] : hrefMatch ? hrefMatch[1] : null;
-                    if (typeof clearScriptCssPrefixes === "string") {
-                      if (srcOrHref?.startsWith(clearScriptCssPrefixes)) {
-                        return "";
-                      }
-                    }
-                    if (Array.isArray(clearScriptCssPrefixes)) {
-                      if (clearScriptCssPrefixes.some(
-                        (prefix) => srcOrHref?.startsWith(prefix)
-                      )) {
-                        return "";
-                      }
-                    }
-                    if (clearScriptCssPrefixes instanceof RegExp) {
-                      return clearScriptCssPrefixes.test(match) ? "" : match;
-                    }
-                    if (typeof clearScriptCssPrefixes === "function") {
-                      return clearScriptCssPrefixes(match) ? "" : match;
-                    }
-                    return match;
-                  });
-                  if (html.indexOf(fullEntry) === -1) {
-                    html = html.replace(
-                      /<!--\sS 公共组件 提示信息\s-->/g,
-                      `<script crossorigin type="module" src="${fullEntry}"><\/script>`
-                    );
-                  }
-                  const headers2 = rewriteCookies({ ...proxyRes.headers });
-                  headers2["content-type"] = "text/html; charset=utf-8";
-                  delete headers2["content-encoding"];
-                  delete headers2["content-length"];
-                  res.writeHead(200, headers2);
-                  res.end(html);
-                  log(
-                    `HTML processed: ${requestUrl} (${Date.now() - startTime}ms)`
-                  );
-                } catch (err) {
-                  logError("Decompress error:", err);
-                  logError("Request URL:", requestUrl);
-                  logError("Response headers:", proxyRes.headers);
-                  res.writeHead(500);
-                  res.end("Decompress error");
-                }
+              handleHtmlResponse(proxyRes, req, res, {
+                fullEntry,
+                developmentAgentOccupancy,
+                clearScriptCssPrefixes,
+                log,
+                logError,
+                startTime
               });
               return;
             }
-            const headers = rewriteCookies({ ...proxyRes.headers });
+            const headers = rewriteCookies({ ...proxyRes.headers }, log);
             res.writeHead(proxyRes.statusCode, headers);
             proxyRes.pipe(res);
-            log(`Proxy request: ${requestUrl} (${Date.now() - startTime}ms)`);
+            log(`[Proxy request] ${requestUrl} (${Date.now() - startTime}ms)`);
           }
         );
       },
       bypass: (req) => {
         const url = req.url || "";
-        const pathname = url.split("?")[0];
-        if ((normalizedStaticPrefix && url.startsWith(`${normalizedStaticPrefix}`) || url.startsWith("/@") || url.startsWith("/src") || url.startsWith("/node_modules") || url.includes(".hot-update.") || url === "/" || bypassRegex.test(pathname)) && !bypassPrefixes.some((prefix) => url.startsWith(prefix))) {
-          log(`Bypass proxy: ${url}`);
+        if (shouldUseLocal(url, normalizedStaticPrefix, remotePrefixes)) {
+          log(`shouldUseLocal: ${url}`);
           return url;
         }
       }
@@ -229,4 +329,126 @@ function viteDevProxy(options = {}) {
   };
 }
 
-export { viteDevProxy as default };
+function createVueCliProxyConfig(options) {
+  validateOptions(options, "vue-cli-plugin-dev-proxy");
+  const {
+    https,
+    appHost,
+    localIndexHtml,
+    normalizedStaticPrefix,
+    remotePrefixes,
+    developmentAgentOccupancy,
+    clearScriptCssPrefixes,
+    fullEntry,
+    log,
+    logError
+  } = processOptions(options);
+  log("vue-cli-plugin-dev-proxy: staticPrefix", normalizedStaticPrefix);
+  const protocol = https ? "https://" : "http://";
+  return {
+    "/": {
+      target: `${protocol}${appHost}`,
+      changeOrigin: true,
+      secure: false,
+      ws: false,
+      //5.x 版本需要设置，否则会报错 Invalid frame header，4.x 版本不需要设置
+      cookieDomainRewrite: { "*": "localhost" },
+      selfHandleResponse: true,
+      onProxyReq: (proxyReq, req, res) => {
+        const upgradeHeader = req.headers.upgrade;
+        const isWebSocket = upgradeHeader && upgradeHeader.toLowerCase() === "websocket";
+        if (isWebSocket) {
+          log(
+            `[WebSocket] ${req.method} ${req.url} -> ${protocol}${proxyReq.getHeader("host")}${proxyReq.path}`
+          );
+        } else {
+          log(
+            `[proxyReq] ${req.method} ${req.url} -> ${protocol}${proxyReq.getHeader("host")}${proxyReq.path}`
+          );
+        }
+      },
+      onError: (err, req, res) => {
+        const upgradeHeader = req.headers.upgrade;
+        const isWebSocket = upgradeHeader && upgradeHeader.toLowerCase() === "websocket";
+        if (isWebSocket) {
+          logError(`[WebSocket Error] ${req.url}:`, err.message);
+        } else {
+          logError(`[proxyError] ${req.url}:`, err.message);
+        }
+        if (!res.headersSent && !isWebSocket) {
+          res.writeHead(500, { "Content-Type": "text/plain" });
+          res.end("Proxy Error: " + err.message);
+        }
+      },
+      onProxyRes: (proxyRes, req, res) => {
+        const startTime = Date.now();
+        const contentType = proxyRes.headers["content-type"] || "";
+        const requestUrl = req.url || "";
+        const acceptHeader = req.headers.accept || "";
+        log(
+          `[proxyRes] ${requestUrl} - Status: ${proxyRes.statusCode}, ContentType: ${contentType}`
+        );
+        const isRedirect = isRedirectResponse(proxyRes);
+        if (isRedirect) {
+          handleRedirect(proxyRes, req, res, appHost, log, startTime);
+          return;
+        }
+        const shouldProcessHtml = shouldProcessAsHtml(
+          contentType,
+          acceptHeader,
+          requestUrl,
+          isRedirect
+        );
+        log(
+          `[shouldProcessHtml] ${shouldProcessHtml}, requestUrl: ${requestUrl}`
+        );
+        if (shouldProcessHtml) {
+          if (localIndexHtml) {
+            handleLibModeHtml(localIndexHtml, res, log, logError, startTime);
+            return;
+          }
+          handleHtmlResponse(proxyRes, req, res, {
+            fullEntry,
+            developmentAgentOccupancy,
+            clearScriptCssPrefixes,
+            log,
+            logError,
+            startTime
+          });
+          return;
+        }
+        const headers = rewriteCookies({ ...proxyRes.headers }, log);
+        res.writeHead(proxyRes.statusCode, headers);
+        proxyRes.pipe(res);
+        log(`[Proxy request]: ${requestUrl} (${Date.now() - startTime}ms)`);
+      },
+      bypass: (req) => {
+        const url = req.url || "";
+        if (shouldUseLocal(url, normalizedStaticPrefix, remotePrefixes)) {
+          log(`[shouldUseLocal] ${url}`);
+          return url;
+        }
+        log(`[Proxy] ${url}`);
+        return null;
+      }
+    }
+  };
+}
+function vueCliDevProxy(options = {}) {
+  if (process.env.NODE_ENV !== "development") {
+    return {};
+  }
+  const proxyConfig = createVueCliProxyConfig(options);
+  return {
+    devServer: {
+      proxy: proxyConfig
+    }
+  };
+}
+
+const index = {
+  VitePluginDevProxy: viteDevProxy,
+  VueCliPluginDevProxy: vueCliDevProxy
+};
+
+export { viteDevProxy as VitePluginDevProxy, vueCliDevProxy as VueCliPluginDevProxy, createVueCliProxyConfig, index as default };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xysfe/vite-plugin-dev-proxy",
-	"version": "1.0.2",
+	"version": "1.0.4",
 	"description": "A Vite plugin for development environment proxy that automatically proxies remote server requests and handles HTML responses",
 	"files": [
 		"dist"
@@ -51,6 +51,5 @@
 		"typescript": "^5.3.3",
 		"unbuild": "^2.0.0",
 		"vite": "^5.0.12"
-	},
-	"packageManager": "pnpm"
+	}
 }